source: trunk/samba/source/nmbd/nmbd_elections.c @ 26

Last change on this file since 26 was 26, checked in by Paul Smedley, 14 years ago

Updated source to 3.0.25rc1

File size: 13.3 KB
Line 
1/*
2   Unix SMB/CIFS implementation.
3   NBT netbios routines and daemon - version 2
4   Copyright (C) Andrew Tridgell 1994-1998
5   Copyright (C) Luke Kenneth Casson Leighton 1994-1998
6   Copyright (C) Jeremy Allison 1994-2003
7   
8   This program is free software; you can redistribute it and/or modify
9   it under the terms of the GNU General Public License as published by
10   the Free Software Foundation; either version 2 of the License, or
11   (at your option) any later version.
12   
13   This program is distributed in the hope that it will be useful,
14   but WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16   GNU General Public License for more details.
17   
18   You should have received a copy of the GNU General Public License
19   along with this program; if not, write to the Free Software
20   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21   
22*/
23
24#include "includes.h"
25
26/* Election parameters. */
27extern time_t StartupTime;
28
29/****************************************************************************
30  Send an election datagram packet.
31**************************************************************************/
32
33static void send_election_dgram(struct subnet_record *subrec, const char *workgroup_name,
34                                uint32 criterion, int timeup,const char *server_name)
35{
36        pstring outbuf;
37        unstring srv_name;
38        char *p;
39
40        DEBUG(2,("send_election_dgram: Sending election packet for workgroup %s on subnet %s\n",
41                workgroup_name, subrec->subnet_name ));
42
43        memset(outbuf,'\0',sizeof(outbuf));
44        p = outbuf;
45        SCVAL(p,0,ANN_Election); /* Election opcode. */
46        p++;
47
48        SCVAL(p,0,((criterion == 0 && timeup == 0) ? 0 : ELECTION_VERSION));
49        SIVAL(p,1,criterion);
50        SIVAL(p,5,timeup*1000); /* ms - Despite what the spec says. */
51        p += 13;
52        unstrcpy(srv_name, server_name);
53        strupper_m(srv_name);
54        /* The following call does UNIX -> DOS charset conversion. */
55        pstrcpy_base(p, srv_name, outbuf);
56        p = skip_string(outbuf,sizeof(outbuf),p);
57 
58        send_mailslot(False, BROWSE_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
59                global_myname(), 0,
60                workgroup_name, 0x1e,
61                subrec->bcast_ip, subrec->myip, DGRAM_PORT);
62}
63
64/*******************************************************************
65 We found a current master browser on one of our broadcast interfaces.
66******************************************************************/
67
68static void check_for_master_browser_success(struct subnet_record *subrec,
69                                 struct userdata_struct *userdata,
70                                 struct nmb_name *answer_name,
71                                 struct in_addr answer_ip, struct res_rec *rrec)
72{
73        unstring aname;
74        pull_ascii_nstring(aname, sizeof(aname), answer_name->name);
75        DEBUG(3,("check_for_master_browser_success: Local master browser for workgroup %s exists at \
76IP %s (just checking).\n", aname, inet_ntoa(answer_ip) ));
77}
78
79/*******************************************************************
80 We failed to find a current master browser on one of our broadcast interfaces.
81******************************************************************/
82
83static void check_for_master_browser_fail( struct subnet_record *subrec,
84                                           struct response_record *rrec,
85                                           struct nmb_name *question_name,
86                                           int fail_code)
87{
88        unstring workgroup_name;
89        struct work_record *work;
90
91        pull_ascii_nstring(workgroup_name,sizeof(workgroup_name),question_name->name);
92
93        work = find_workgroup_on_subnet(subrec, workgroup_name);
94        if(work == NULL) {
95                DEBUG(0,("check_for_master_browser_fail: Unable to find workgroup %s on subnet %s.=\n",
96                        workgroup_name, subrec->subnet_name ));
97                return;
98        }
99
100        if (strequal(work->work_group, lp_workgroup())) {
101
102                if (lp_local_master()) {
103                        /* We have discovered that there is no local master
104                                browser, and we are configured to initiate
105                                an election that we will participate in.
106                        */
107                        DEBUG(2,("check_for_master_browser_fail: Forcing election on workgroup %s subnet %s\n",
108                                work->work_group, subrec->subnet_name ));
109
110                        /* Setting this means we will participate when the
111                                election is run in run_elections(). */
112                        work->needelection = True;
113                } else {
114                        /* We need to force an election, because we are configured
115                                not to become the local master, but we still need one,
116                                having detected that one doesn't exist.
117                        */
118                        send_election_dgram(subrec, work->work_group, 0, 0, "");
119                }
120        }
121}
122
123/*******************************************************************
124  Ensure there is a local master browser for a workgroup on our
125  broadcast interfaces.
126******************************************************************/
127
128void check_master_browser_exists(time_t t)
129{
130        static time_t lastrun=0;
131        struct subnet_record *subrec;
132        const char *workgroup_name = lp_workgroup();
133
134        if (!lastrun)
135                lastrun = t;
136
137        if (t < (lastrun + (CHECK_TIME_MST_BROWSE * 60)))
138                return;
139
140        lastrun = t;
141
142        dump_workgroups(False);
143
144        for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
145                struct work_record *work;
146
147                for (work = subrec->workgrouplist; work; work = work->next) {
148                        if (strequal(work->work_group, workgroup_name) && !AM_LOCAL_MASTER_BROWSER(work)) {
149                                /* Do a name query for the local master browser on this net. */
150                                query_name( subrec, work->work_group, 0x1d,
151                                        check_for_master_browser_success,
152                                        check_for_master_browser_fail,
153                                        NULL);
154                        }
155                }
156        }
157}
158
159/*******************************************************************
160  Run an election.
161******************************************************************/
162
163void run_elections(time_t t)
164{
165        static time_t lastime = 0;
166 
167        struct subnet_record *subrec;
168 
169        START_PROFILE(run_elections);
170
171        /* Send election packets once every 2 seconds - note */
172        if (lastime && (t - lastime < 2)) {
173                END_PROFILE(run_elections);
174                return;
175        }
176 
177        lastime = t;
178 
179        for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
180                struct work_record *work;
181
182                for (work = subrec->workgrouplist; work; work = work->next) {
183                        if (work->RunningElection) {
184                                /*
185                                 * We can only run an election for a workgroup if we have
186                                 * registered the WORKGROUP<1e> name, as that's the name
187                                 * we must listen to.
188                                 */
189                                struct nmb_name nmbname;
190
191                                make_nmb_name(&nmbname, work->work_group, 0x1e);
192                                if(find_name_on_subnet( subrec, &nmbname, FIND_SELF_NAME)==NULL) {
193                                        DEBUG(8,("run_elections: Cannot send election packet yet as name %s not \
194yet registered on subnet %s\n", nmb_namestr(&nmbname), subrec->subnet_name ));
195                                        continue;
196                                }
197
198                                send_election_dgram(subrec, work->work_group, work->ElectionCriterion,
199                                                t - StartupTime, global_myname());
200             
201                                if (work->ElectionCount++ >= 4) {
202                                        /* Won election (4 packets were sent out uncontested. */
203                                        DEBUG(2,("run_elections: >>> Won election for workgroup %s on subnet %s <<<\n",
204                                                work->work_group, subrec->subnet_name ));
205
206                                        work->RunningElection = False;
207
208                                        become_local_master_browser(subrec, work);
209                                }
210                        }
211                }
212        }
213        END_PROFILE(run_elections);
214}
215
216/*******************************************************************
217  Determine if I win an election.
218******************************************************************/
219
220static BOOL win_election(struct work_record *work, int version,
221                         uint32 criterion, int timeup, const char *server_name)
222{ 
223        int mytimeup = time(NULL) - StartupTime;
224        uint32 mycriterion = work->ElectionCriterion;
225
226        /* If local master is false then never win in election broadcasts. */
227        if(!lp_local_master()) {
228                DEBUG(3,("win_election: Losing election as local master == False\n"));
229                return False;
230        }
231 
232        DEBUG(4,("win_election: election comparison: %x:%x %x:%x %d:%d %s:%s\n",
233                        version, ELECTION_VERSION,
234                        criterion, mycriterion,
235                        timeup, mytimeup,
236                        server_name, global_myname()));
237
238        if (version > ELECTION_VERSION)
239                return(False);
240        if (version < ELECTION_VERSION)
241                return(True);
242 
243        if (criterion > mycriterion)
244                return(False);
245        if (criterion < mycriterion)
246                return(True);
247
248        if (timeup > mytimeup)
249                return(False);
250        if (timeup < mytimeup)
251                return(True);
252
253        if (StrCaseCmp(global_myname(), server_name) > 0)
254                return(False);
255 
256        return(True);
257}
258
259/*******************************************************************
260  Process an incoming election datagram packet.
261******************************************************************/
262
263void process_election(struct subnet_record *subrec, struct packet_struct *p, char *buf)
264{
265        struct dgram_packet *dgram = &p->packet.dgram;
266        int version = CVAL(buf,0);
267        uint32 criterion = IVAL(buf,1);
268        int timeup = IVAL(buf,5)/1000;
269        unstring server_name;
270        struct work_record *work;
271        unstring workgroup_name;
272
273        START_PROFILE(election);
274
275        pull_ascii_nstring(server_name, sizeof(server_name), buf+13);
276        pull_ascii_nstring(workgroup_name, sizeof(workgroup_name), dgram->dest_name.name);
277
278        server_name[15] = 0; 
279
280        DEBUG(3,("process_election: Election request from %s at IP %s on subnet %s for workgroup %s.\n",
281                server_name,inet_ntoa(p->ip), subrec->subnet_name, workgroup_name ));
282
283        DEBUG(5,("process_election: vers=%d criterion=%08x timeup=%d\n", version,criterion,timeup));
284
285        if(( work = find_workgroup_on_subnet(subrec, workgroup_name)) == NULL) {
286                DEBUG(0,("process_election: Cannot find workgroup %s on subnet %s.\n",
287                        workgroup_name, subrec->subnet_name ));
288                goto done;
289        }
290
291        if (!strequal(work->work_group, lp_workgroup())) {
292                DEBUG(3,("process_election: ignoring election request for workgroup %s on subnet %s as this \
293is not my workgroup.\n", work->work_group, subrec->subnet_name ));
294                goto done;
295        }
296
297        if (win_election(work, version,criterion,timeup,server_name)) {
298                /* We take precedence over the requesting server. */
299                if (!work->RunningElection) {
300                        /* We weren't running an election - start running one. */
301
302                        work->needelection = True;
303                        work->ElectionCount=0;
304                }
305
306                /* Note that if we were running an election for this workgroup on this
307                        subnet already, we just ignore the server we take precedence over. */
308        } else {
309                /* We lost. Stop participating. */
310                work->needelection = False;
311
312                if (work->RunningElection || AM_LOCAL_MASTER_BROWSER(work)) {
313                        work->RunningElection = False;
314                        DEBUG(3,("process_election: >>> Lost election for workgroup %s on subnet %s <<<\n",
315                                work->work_group, subrec->subnet_name ));
316                        if (AM_LOCAL_MASTER_BROWSER(work))
317                                unbecome_local_master_browser(subrec, work, False);
318                }
319        }
320done:
321
322        END_PROFILE(election);
323}
324
325/****************************************************************************
326  This function looks over all the workgroups known on all the broadcast
327  subnets and decides if a browser election is to be run on that workgroup.
328  It returns True if any election packets need to be sent (this will then
329  be done by run_elections().
330***************************************************************************/
331
332BOOL check_elections(void)
333{
334        struct subnet_record *subrec;
335        BOOL run_any_election = False;
336
337        for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
338                struct work_record *work;
339                for (work = subrec->workgrouplist; work; work = work->next) {
340                        run_any_election |= work->RunningElection;
341
342                        /*
343                         * Start an election if we have any chance of winning.
344                         * Note this is a change to the previous code, that would
345                         * only run an election if nmbd was in the potential browser
346                         * state. We need to run elections in any state if we're told
347                         * to. JRA.
348                         */
349
350                        if (work->needelection && !work->RunningElection && lp_local_master()) {
351                                /*
352                                 * We can only run an election for a workgroup if we have
353                                 * registered the WORKGROUP<1e> name, as that's the name
354                                 * we must listen to.
355                                 */
356                                struct nmb_name nmbname;
357
358                                make_nmb_name(&nmbname, work->work_group, 0x1e);
359                                if(find_name_on_subnet( subrec, &nmbname, FIND_SELF_NAME)==NULL) {
360                                        DEBUG(8,("check_elections: Cannot send election packet yet as name %s not \
361yet registered on subnet %s\n", nmb_namestr(&nmbname), subrec->subnet_name ));
362                                        continue;
363                                }
364
365                                DEBUG(3,("check_elections: >>> Starting election for workgroup %s on subnet %s <<<\n",
366                                        work->work_group, subrec->subnet_name ));
367
368                                work->ElectionCount = 0;
369                                work->RunningElection = True;
370                                work->needelection = False;
371                        }
372                }
373        }
374        return run_any_election;
375}
376
377/****************************************************************************
378 Process a internal Samba message forcing an election.
379***************************************************************************/
380
381void nmbd_message_election(int msg_type, struct process_id src,
382                           void *buf, size_t len, void *private_data)
383{
384        struct subnet_record *subrec;
385
386        for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
387                struct work_record *work;
388                for (work = subrec->workgrouplist; work; work = work->next) {
389                        if (strequal(work->work_group, lp_workgroup())) {
390                                work->needelection = True;
391                                work->ElectionCount=0;
392                                work->mst_state = lp_local_master() ? MST_POTENTIAL : MST_NONE;
393                        }
394                }
395        }
396}
Note: See TracBrowser for help on using the repository browser.