minor patch to allow host announcements to remote subnets
[samba.git] / source3 / nameelect.c
1 /* 
2    Unix SMB/Netbios implementation.
3    Version 1.9.
4    NBT netbios routines and daemon - version 2
5    Copyright (C) Andrew Tridgell 1994-1995
6    
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11    
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16    
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20    
21    Revision History:
22
23    14 jan 96: lkcl@pires.co.uk
24    added multiple workgroup domain master support
25
26 */
27
28 #include "includes.h"
29
30 extern int ClientNMB;
31 extern int ClientDGRAM;
32
33 extern int DEBUGLEVEL;
34 extern pstring scope;
35
36 extern pstring myname;
37
38 /* machine comment for host announcements */
39 extern  pstring ServerComment;
40
41 /* here are my election parameters */
42
43 extern time_t StartupTime;
44
45 #define AM_MASTER(work) (work->ServerType & SV_TYPE_MASTER_BROWSER)
46
47 #define BROWSE_MAILSLOT "\\MAILSLOT\\BROWSE"
48
49 extern struct subnet_record *subnetlist;
50
51
52 /*******************************************************************
53   occasionally check to see if the master browser is around
54   ******************************************************************/
55 void check_master_browser(void)
56 {
57   static time_t lastrun=0;
58   time_t t = time(NULL);
59   struct subnet_record *d;
60
61   if (!lastrun) lastrun = t;
62   if (t < lastrun + CHECK_TIME_MST_BROWSE * 60) 
63     return;
64
65   lastrun = t;
66
67   dump_workgroups();
68
69   for (d = subnetlist; d; d = d->next)
70     {
71       struct work_record *work;
72
73       for (work = d->workgrouplist; work; work = work->next)
74         {
75           /* if we are not the browse master of a workgroup, and we can't
76              find a browser on the subnet, do something about it. */
77
78           if (!AM_MASTER(work))
79             {
80               queue_netbios_packet(ClientNMB,NMB_QUERY,CHECK_MASTER,
81                                    work->work_group,0x1d,0,
82                                    True,False,d->bcast_ip);
83             }
84         }
85     }
86 }
87
88
89 /*******************************************************************
90   what to do if a master browser DOESN't exist
91   ******************************************************************/
92 void browser_gone(char *work_name, struct in_addr ip)
93 {
94   struct subnet_record *d = find_domain(ip);
95   struct work_record *work = find_workgroupstruct(d, work_name, False);
96
97   if (!work || !d) return;
98
99   if (strequal(work->work_group, lp_workgroup()) &&
100       d->my_interface)
101     {
102
103       DEBUG(2,("Forcing election on %s %s\n",
104                work->work_group,inet_ntoa(d->bcast_ip)));
105
106       /* we can attempt to become master browser */
107       work->needelection = True;
108     }
109   else
110     {
111       /* XXXX note: this will delete entries that have been added in by
112          lmhosts as well. a flag to ensure that these are not deleted may
113          be considered */
114       
115       /* workgroup with no master browser is not the default workgroup:
116          it's also not on our subnet. therefore delete it: it can be
117          recreated dynamically */
118       
119       send_election(d, work->work_group, 0, 0, myname);
120       remove_workgroup(d, work);      
121     }
122 }
123
124 /****************************************************************************
125   send an election packet
126   **************************************************************************/
127 void send_election(struct subnet_record *d, char *group,uint32 criterion,
128                    int timeup,char *name)
129 {
130   pstring outbuf;
131   char *p;
132
133   if (!d) return;
134   
135   DEBUG(2,("Sending election to %s for workgroup %s\n",
136            inet_ntoa(d->bcast_ip),group));         
137
138   bzero(outbuf,sizeof(outbuf));
139   p = outbuf;
140   CVAL(p,0) = 8; /* election */
141   p++;
142
143   CVAL(p,0) = (criterion == 0 && timeup == 0) ? 0 : ELECTION_VERSION;
144   SIVAL(p,1,criterion);
145   SIVAL(p,5,timeup*1000); /* ms - despite the spec */
146   p += 13;
147   strcpy(p,name);
148   strupper(p);
149   p = skip_string(p,1);
150   
151   send_mailslot_reply(BROWSE_MAILSLOT,ClientDGRAM,outbuf,PTR_DIFF(p,outbuf),
152                       name,group,0,0x1e,d->bcast_ip,*iface_ip(d->bcast_ip));
153 }
154
155
156 /*******************************************************************
157   become the master browser
158   ******************************************************************/
159 static void become_master(struct subnet_record *d, struct work_record *work)
160 {
161   uint32 domain_type = SV_TYPE_DOMAIN_ENUM | SV_TYPE_SERVER_UNIX | 0x00400000;
162
163   if (!work) return;
164   
165   DEBUG(2,("Becoming master for %s\n",work->work_group));
166   
167   work->ServerType |= SV_TYPE_MASTER_BROWSER;
168   work->ServerType &= ~SV_TYPE_POTENTIAL_BROWSER;
169   work->ElectionCriterion |= 0x5;
170   
171   /* add browse, master and general names to database or register with WINS */
172   add_name_entry(MSBROWSE        ,0x01,NB_ACTIVE|NB_GROUP);
173   add_name_entry(work->work_group,0x1d,NB_ACTIVE         );
174   
175   if (lp_domain_master())
176     {
177       DEBUG(4,("Domain master: adding names...\n"));
178       
179       /* add domain master and domain member names or register with WINS */
180       add_name_entry(work->work_group,0x1b,NB_ACTIVE);
181       work->ServerType |= SV_TYPE_DOMAIN_MASTER;
182       
183       if (lp_domain_logons())
184         {
185           work->ServerType |= SV_TYPE_DOMAIN_CTRL;
186           work->ServerType |= SV_TYPE_DOMAIN_MEMBER;
187         }
188     }
189   
190   /* update our server status */
191   add_server_entry(d,work,work->work_group,domain_type,0,myname,True);
192   add_server_entry(d,work,myname,work->ServerType,0,ServerComment,True);
193   
194   if (d->my_interface)
195     {
196       /* ask all servers on our local net to announce to us */
197       announce_request(work, d->bcast_ip);
198     }
199 }
200
201
202 /*******************************************************************
203   unbecome the master browser
204   ******************************************************************/
205 void become_nonmaster(struct subnet_record *d, struct work_record *work)
206 {
207   DEBUG(2,("Becoming non-master for %s\n",work->work_group));
208   
209   work->ServerType &= ~SV_TYPE_MASTER_BROWSER;
210   work->ServerType &= ~SV_TYPE_DOMAIN_MASTER;
211   work->ServerType |= SV_TYPE_POTENTIAL_BROWSER;
212   
213   work->ElectionCriterion &= ~0x4;
214   
215   remove_name_entry(work->work_group,0x1b);
216   remove_name_entry(work->work_group,0x1d);
217   remove_name_entry(MSBROWSE        ,0x01);
218 }
219
220
221 /*******************************************************************
222   run the election
223   ******************************************************************/
224 void run_elections(void)
225 {
226   time_t t = time(NULL);
227   static time_t lastime = 0;
228   
229   struct subnet_record *d;
230   
231   /* send election packets once a second */
232   if (lastime && t-lastime <= 0) return;
233   
234   lastime = t;
235   
236   for (d = subnetlist; d; d = d->next)
237     {
238       struct work_record *work;
239       for (work = d->workgrouplist; work; work = work->next)
240         {
241           if (work->RunningElection)
242             {
243               send_election(d,work->work_group, work->ElectionCriterion,
244                             t-StartupTime,myname);
245               
246               if (work->ElectionCount++ >= 4)
247                 {
248                   /* I won! now what :-) */
249                   DEBUG(2,(">>> Won election on %s %s <<<\n",
250                            work->work_group,inet_ntoa(d->bcast_ip)));
251                   
252                   work->RunningElection = False;
253                   become_master(d, work);
254                 }
255             }
256         }
257     }
258 }
259
260
261 /*******************************************************************
262   work out if I win an election
263   ******************************************************************/
264 static BOOL win_election(struct work_record *work,int version,uint32 criterion,
265                          int timeup,char *name)
266 {  
267   time_t t = time(NULL);
268   uint32 mycriterion;
269   if (version > ELECTION_VERSION) return(False);
270   if (version < ELECTION_VERSION) return(True);
271   
272   mycriterion = work->ElectionCriterion;
273
274   if (criterion > mycriterion) return(False);
275   if (criterion < mycriterion) return(True);
276
277   if (timeup > (t - StartupTime)) return(False);
278   if (timeup < (t - StartupTime)) return(True);
279
280   if (strcasecmp(myname,name) > 0) return(False);
281   
282   return(True);
283 }
284
285
286 /*******************************************************************
287   process a election packet
288
289   An election dynamically decides who will be the master. 
290   ******************************************************************/
291 void process_election(struct packet_struct *p,char *buf)
292 {
293   struct dgram_packet *dgram = &p->packet.dgram;
294   struct in_addr ip = dgram->header.source_ip;
295   struct subnet_record *d = find_domain(ip);
296   int version = CVAL(buf,0);
297   uint32 criterion = IVAL(buf,1);
298   int timeup = IVAL(buf,5)/1000;
299   char *name = buf+13;
300   struct work_record *work;
301
302   if (!d) return;
303   
304   name[15] = 0;  
305
306   DEBUG(3,("Election request from %s vers=%d criterion=%08x timeup=%d\n",
307            name,version,criterion,timeup));
308   
309   if (same_context(dgram)) return;
310   
311   for (work = d->workgrouplist; work; work = work->next)
312     {
313       if (listening_name(work, &dgram->dest_name) && 
314           strequal(work->work_group, lp_workgroup()) &&
315           d->my_interface)
316         {
317           if (win_election(work, version,criterion,timeup,name))
318             {
319               if (!work->RunningElection)
320                 {
321                   work->needelection = True;
322                   work->ElectionCount=0;
323                 }
324             }
325           else
326             {
327               work->needelection = False;
328               
329               if (work->RunningElection)
330                 {
331                   work->RunningElection = False;
332                   DEBUG(3,(">>> Lost election on %s %s <<<\n",
333                            work->work_group,inet_ntoa(d->bcast_ip)));
334                   
335                   /* if we are the master then remove our masterly names */
336                   if (AM_MASTER(work))
337                     {
338                       become_nonmaster(d, work);
339                     }
340                 }
341             }
342         }
343     }
344 }
345
346
347 /****************************************************************************
348   checks whether a browser election is to be run on any workgroup
349   ***************************************************************************/
350 BOOL check_elections(void)
351 {
352   struct subnet_record *d;
353   BOOL run_any_election = False;
354
355   for (d = subnetlist; d; d = d->next)
356     {
357       struct work_record *work;
358       
359       /* we only want to run elections on our own interfaces */
360       if (!d->my_interface) continue;
361
362       for (work = d->workgrouplist; work; work = work->next)
363         {
364           run_any_election |= work->RunningElection;
365           
366           if (work->needelection && !work->RunningElection)
367             {
368               DEBUG(3,(">>> Starting election on %s %s <<<\n",
369                        work->work_group,inet_ntoa(d->bcast_ip)));
370               work->ElectionCount = 0;
371               work->RunningElection = True;
372               work->needelection = False;
373             }
374         }
375     }
376   return run_any_election;
377 }
378