Fix bug #6224 - nmbd waits 5 minutes at startup before checking if it needs to run...
[jra/samba/.git] / source3 / nmbd / nmbd_elections.c
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. */
26 extern time_t StartupTime;
27
28 /****************************************************************************
29   Send an election datagram packet.
30 **************************************************************************/
31
32 static void send_election_dgram(struct subnet_record *subrec, const char *workgroup_name,
33                                 uint32 criterion, int timeup,const char *server_name)
34 {
35         char outbuf[1024];
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         push_ascii(p, srv_name, sizeof(outbuf)-PTR_DIFF(p,outbuf)-1, STR_TERMINATE);
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
67 static 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 \
75 IP %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
82 static 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
127 void 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 (t < (lastrun + (CHECK_TIME_MST_BROWSE * 60)))
134                 return;
135
136         lastrun = t;
137
138         dump_workgroups(False);
139
140         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
141                 struct work_record *work;
142
143                 for (work = subrec->workgrouplist; work; work = work->next) {
144                         if (strequal(work->work_group, workgroup_name) && !AM_LOCAL_MASTER_BROWSER(work)) {
145                                 /* Do a name query for the local master browser on this net. */
146                                 query_name( subrec, work->work_group, 0x1d,
147                                         check_for_master_browser_success,
148                                         check_for_master_browser_fail,
149                                         NULL);
150                         }
151                 }
152         }
153 }
154
155 /*******************************************************************
156   Run an election.
157 ******************************************************************/
158
159 void run_elections(time_t t)
160 {
161         static time_t lastime = 0;
162   
163         struct subnet_record *subrec;
164   
165         START_PROFILE(run_elections);
166
167         /* Send election packets once every 2 seconds - note */
168         if (lastime && (t - lastime < 2)) {
169                 END_PROFILE(run_elections);
170                 return;
171         }
172   
173         lastime = t;
174   
175         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
176                 struct work_record *work;
177
178                 for (work = subrec->workgrouplist; work; work = work->next) {
179                         if (work->RunningElection) {
180                                 /*
181                                  * We can only run an election for a workgroup if we have
182                                  * registered the WORKGROUP<1e> name, as that's the name
183                                  * we must listen to.
184                                  */
185                                 struct nmb_name nmbname;
186
187                                 make_nmb_name(&nmbname, work->work_group, 0x1e);
188                                 if(find_name_on_subnet( subrec, &nmbname, FIND_SELF_NAME)==NULL) {
189                                         DEBUG(8,("run_elections: Cannot send election packet yet as name %s not \
190 yet registered on subnet %s\n", nmb_namestr(&nmbname), subrec->subnet_name ));
191                                         continue;
192                                 }
193
194                                 send_election_dgram(subrec, work->work_group, work->ElectionCriterion,
195                                                 t - StartupTime, global_myname());
196               
197                                 if (work->ElectionCount++ >= 4) {
198                                         /* Won election (4 packets were sent out uncontested. */
199                                         DEBUG(2,("run_elections: >>> Won election for workgroup %s on subnet %s <<<\n",
200                                                 work->work_group, subrec->subnet_name ));
201
202                                         work->RunningElection = False;
203
204                                         become_local_master_browser(subrec, work);
205                                 }
206                         }
207                 }
208         }
209         END_PROFILE(run_elections);
210 }
211
212 /*******************************************************************
213   Determine if I win an election.
214 ******************************************************************/
215
216 static bool win_election(struct work_record *work, int version,
217                          uint32 criterion, int timeup, const char *server_name)
218 {  
219         int mytimeup = time(NULL) - StartupTime;
220         uint32 mycriterion = work->ElectionCriterion;
221
222         /* If local master is false then never win in election broadcasts. */
223         if(!lp_local_master()) {
224                 DEBUG(3,("win_election: Losing election as local master == False\n"));
225                 return False;
226         }
227  
228         DEBUG(4,("win_election: election comparison: %x:%x %x:%x %d:%d %s:%s\n",
229                         version, ELECTION_VERSION,
230                         criterion, mycriterion,
231                         timeup, mytimeup,
232                         server_name, global_myname()));
233
234         if (version > ELECTION_VERSION)
235                 return(False);
236         if (version < ELECTION_VERSION)
237                 return(True);
238   
239         if (criterion > mycriterion)
240                 return(False);
241         if (criterion < mycriterion)
242                 return(True);
243
244         if (timeup > mytimeup)
245                 return(False);
246         if (timeup < mytimeup)
247                 return(True);
248
249         if (StrCaseCmp(global_myname(), server_name) > 0)
250                 return(False);
251   
252         return(True);
253 }
254
255 /*******************************************************************
256   Process an incoming election datagram packet.
257 ******************************************************************/
258
259 void process_election(struct subnet_record *subrec, struct packet_struct *p, char *buf)
260 {
261         struct dgram_packet *dgram = &p->packet.dgram;
262         int version = CVAL(buf,0);
263         uint32 criterion = IVAL(buf,1);
264         int timeup = IVAL(buf,5)/1000;
265         unstring server_name;
266         struct work_record *work;
267         unstring workgroup_name;
268
269         START_PROFILE(election);
270
271         pull_ascii_nstring(server_name, sizeof(server_name), buf+13);
272         pull_ascii_nstring(workgroup_name, sizeof(workgroup_name), dgram->dest_name.name);
273
274         server_name[15] = 0;  
275
276         DEBUG(3,("process_election: Election request from %s at IP %s on subnet %s for workgroup %s.\n",
277                 server_name,inet_ntoa(p->ip), subrec->subnet_name, workgroup_name ));
278
279         DEBUG(5,("process_election: vers=%d criterion=%08x timeup=%d\n", version,criterion,timeup));
280
281         if(( work = find_workgroup_on_subnet(subrec, workgroup_name)) == NULL) {
282                 DEBUG(0,("process_election: Cannot find workgroup %s on subnet %s.\n",
283                         workgroup_name, subrec->subnet_name ));
284                 goto done;
285         }
286
287         if (!strequal(work->work_group, lp_workgroup())) {
288                 DEBUG(3,("process_election: ignoring election request for workgroup %s on subnet %s as this \
289 is not my workgroup.\n", work->work_group, subrec->subnet_name ));
290                 goto done;
291         }
292
293         if (win_election(work, version,criterion,timeup,server_name)) {
294                 /* We take precedence over the requesting server. */
295                 if (!work->RunningElection) {
296                         /* We weren't running an election - start running one. */
297
298                         work->needelection = True;
299                         work->ElectionCount=0;
300                 }
301
302                 /* Note that if we were running an election for this workgroup on this
303                         subnet already, we just ignore the server we take precedence over. */
304         } else {
305                 /* We lost. Stop participating. */
306                 work->needelection = False;
307
308                 if (work->RunningElection || AM_LOCAL_MASTER_BROWSER(work)) {
309                         work->RunningElection = False;
310                         DEBUG(3,("process_election: >>> Lost election for workgroup %s on subnet %s <<<\n",
311                                 work->work_group, subrec->subnet_name ));
312                         if (AM_LOCAL_MASTER_BROWSER(work))
313                                 unbecome_local_master_browser(subrec, work, False);
314                 }
315         }
316 done:
317
318         END_PROFILE(election);
319 }
320
321 /****************************************************************************
322   This function looks over all the workgroups known on all the broadcast
323   subnets and decides if a browser election is to be run on that workgroup.
324   It returns True if any election packets need to be sent (this will then
325   be done by run_elections().
326 ***************************************************************************/
327
328 bool check_elections(void)
329 {
330         struct subnet_record *subrec;
331         bool run_any_election = False;
332
333         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
334                 struct work_record *work;
335                 for (work = subrec->workgrouplist; work; work = work->next) {
336                         if (work->RunningElection) {
337                                 run_any_election = work->RunningElection;
338                         }
339
340                         /* 
341                          * Start an election if we have any chance of winning.
342                          * Note this is a change to the previous code, that would
343                          * only run an election if nmbd was in the potential browser
344                          * state. We need to run elections in any state if we're told
345                          * to. JRA.
346                          */
347
348                         if (work->needelection && !work->RunningElection && lp_local_master()) {
349                                 /*
350                                  * We can only run an election for a workgroup if we have
351                                  * registered the WORKGROUP<1e> name, as that's the name
352                                  * we must listen to.
353                                  */
354                                 struct nmb_name nmbname;
355
356                                 make_nmb_name(&nmbname, work->work_group, 0x1e);
357                                 if(find_name_on_subnet( subrec, &nmbname, FIND_SELF_NAME)==NULL) {
358                                         DEBUG(8,("check_elections: Cannot send election packet yet as name %s not \
359 yet registered on subnet %s\n", nmb_namestr(&nmbname), subrec->subnet_name ));
360                                         continue;
361                                 }
362
363                                 DEBUG(3,("check_elections: >>> Starting election for workgroup %s on subnet %s <<<\n",
364                                         work->work_group, subrec->subnet_name ));
365
366                                 work->ElectionCount = 0;
367                                 work->RunningElection = True;
368                                 work->needelection = False;
369                         }
370                 }
371         }
372         return run_any_election;
373 }
374
375 /****************************************************************************
376  Process a internal Samba message forcing an election.
377 ***************************************************************************/
378
379 void nmbd_message_election(struct messaging_context *msg,
380                            void *private_data,
381                            uint32_t msg_type,
382                            struct server_id server_id,
383                            DATA_BLOB *data)
384 {
385         struct subnet_record *subrec;
386
387         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
388                 struct work_record *work;
389                 for (work = subrec->workgrouplist; work; work = work->next) {
390                         if (strequal(work->work_group, lp_workgroup())) {
391                                 work->needelection = True;
392                                 work->ElectionCount=0;
393                                 work->mst_state = lp_local_master() ? MST_POTENTIAL : MST_NONE;
394                         }
395                 }
396         }
397 }