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

Last change on this file since 77 was 77, checked in by Paul Smedley, 13 years ago

Update trunk to 3.2.0pre1

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