This is actually Jeremy, working as Herb :-).
[samba.git] / source / nmbd / nmbd_sendannounce.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-1997
6    Copyright (C) Luke Kenneth Casson Leighton 1994-1997 
7    Copyright (C) Jeremy Allison 1994-1997
8
9    SMB Version handling
10    Copyright (C) John H Terpstra 1995-1997
11    
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 2 of the License, or
15    (at your option) any later version.
16    
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21    
22    You should have received a copy of the GNU General Public License
23    along with this program; if not, write to the Free Software
24    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25    
26 */
27
28 #include "includes.h"
29
30 extern int DEBUGLEVEL;
31 extern pstring myname;
32 extern fstring myworkgroup;
33 extern char **my_netbios_names;
34 extern int  updatecount;
35 extern BOOL found_lm_clients;
36
37 /****************************************************************************
38  Send a browser reset packet.
39 **************************************************************************/
40
41 void send_browser_reset(int reset_type, char *to_name, int to_type, struct in_addr to_ip)
42 {
43   pstring outbuf;
44   char *p;
45
46   DEBUG(3,("send_browser_reset: sending reset request type %d to %s<%02x> IP %s.\n",
47        reset_type, to_name, to_type, inet_ntoa(to_ip) ));
48
49   bzero(outbuf,sizeof(outbuf));
50   p = outbuf;
51   CVAL(p,0) = ANN_ResetBrowserState;
52   p++;
53   CVAL(p,0) = reset_type;
54   p++;
55
56   send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
57                 myname, 0x0, to_name, to_type, to_ip, FIRST_SUBNET->myip);
58 }
59
60 /****************************************************************************
61   Broadcast a packet to the local net requesting that all servers in this
62   workgroup announce themselves to us.
63   **************************************************************************/
64
65 void broadcast_announce_request(struct subnet_record *subrec, struct work_record *work)
66 {
67   pstring outbuf;
68   char *p;
69
70   work->needannounce = True;
71
72   DEBUG(3,("broadcast_announce_request: sending announce request for workgroup %s \
73 to subnet %s\n", work->work_group, subrec->subnet_name));
74
75   bzero(outbuf,sizeof(outbuf));
76   p = outbuf;
77   CVAL(p,0) = ANN_AnnouncementRequest;
78   p++;
79
80   CVAL(p,0) = work->token; /* (local) Unique workgroup token id. */
81   p++;
82   StrnCpy(p,myname,15);
83   strupper(p);
84   p = skip_string(p,1);
85   
86   send_mailslot(False, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
87                 myname, 0x0, work->work_group,0x1e, subrec->bcast_ip, subrec->myip);
88 }
89
90 /****************************************************************************
91   Broadcast an announcement.
92   **************************************************************************/
93
94 static void send_announcement(struct subnet_record *subrec, int announce_type,
95                               char *from_name, char *to_name, int to_type, struct in_addr to_ip,
96                               time_t announce_interval,
97                               char *server_name, int server_type, char *server_comment)
98 {
99   pstring outbuf;
100   char *p;
101
102   bzero(outbuf,sizeof(outbuf));
103   p = outbuf+1;
104
105   CVAL(outbuf,0) = announce_type;
106
107   /* Announcement parameters. */
108   CVAL(p,0) = updatecount;
109   SIVAL(p,1,announce_interval*1000); /* Milliseconds - despite the spec. */
110
111   StrnCpy(p+5,server_name,15);
112   strupper(p+5);
113
114   CVAL(p,21) = lp_major_announce_version(); /* Major version. */
115   CVAL(p,22) = lp_minor_announce_version(); /* Minor version. */
116
117   SIVAL(p,23,server_type & ~SV_TYPE_LOCAL_LIST_ONLY);
118   /* Browse version: got from NT/AS 4.00  - Value defined in smb.h (JHT). */
119   SSVAL(p,27,BROWSER_ELECTION_VERSION);
120   SSVAL(p,29,BROWSER_CONSTANT); /* Browse signature. */
121
122   pstrcpy(p+31,server_comment);
123   p += 31;
124   p = skip_string(p,1);
125
126   send_mailslot(False,BROWSE_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
127                 from_name, 0x0, to_name, to_type, to_ip, subrec->myip);
128 }
129
130 /****************************************************************************
131   Broadcast a LanMan announcement.
132 **************************************************************************/
133
134 static void send_lm_announcement(struct subnet_record *subrec, int announce_type,
135                               char *from_name, char *to_name, int to_type, struct in_addr to_ip,
136                               time_t announce_interval,
137                               char *server_name, int server_type, char *server_comment)
138 {
139   pstring outbuf;
140   char *p=outbuf;
141
142   bzero(outbuf,sizeof(outbuf));
143
144   SSVAL(p,0,announce_type);
145   SIVAL(p,2,server_type & ~SV_TYPE_LOCAL_LIST_ONLY);
146   CVAL(p,6) = lp_major_announce_version(); /* Major version. */
147   CVAL(p,7) = lp_minor_announce_version(); /* Minor version. */
148   SSVAL(p,8,announce_interval);            /* In seconds - according to spec. */
149
150   p += 10;
151   StrnCpy(p,server_name,15);
152   strupper(p);
153   p = skip_string(p,1);
154   pstrcpy(p,server_comment);
155   p = skip_string(p,1);
156
157   send_mailslot(False,LANMAN_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
158                 from_name, 0x0, to_name, to_type, to_ip, subrec->myip);
159 }
160
161 /****************************************************************************
162  We are a local master browser. Announce this to WORKGROUP<1e>.
163 ****************************************************************************/
164
165 static void send_local_master_announcement(struct subnet_record *subrec, struct work_record *work,
166                                            struct server_record *servrec)
167 {
168   /* Ensure we don't have the prohibited bit set. */
169   uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
170
171   DEBUG(3,("send_local_master_announcement: type %x for name %s on subnet %s for workgroup %s\n",
172             type, myname, subrec->subnet_name, work->work_group));
173
174   send_announcement(subrec, ANN_LocalMasterAnnouncement,
175                     myname,                          /* From nbt name. */
176                     work->work_group, 0x1e,          /* To nbt name. */
177                     subrec->bcast_ip,                /* To ip. */
178                     work->announce_interval,         /* Time until next announce. */
179                     myname,                          /* Name to announce. */
180                     type,                            /* Type field. */
181                     servrec->serv.comment);
182 }
183
184 /****************************************************************************
185  Announce the workgroup WORKGROUP to MSBROWSE<01>.
186 ****************************************************************************/
187
188 static void send_workgroup_announcement(struct subnet_record *subrec, struct work_record *work)
189 {
190   DEBUG(3,("send_workgroup_announcement: on subnet %s for workgroup %s\n",
191             subrec->subnet_name, work->work_group));
192
193   send_announcement(subrec, ANN_DomainAnnouncement,
194                     myname,                          /* From nbt name. */
195                     MSBROWSE, 0x1,                   /* To nbt name. */
196                     subrec->bcast_ip,                /* To ip. */
197                     work->announce_interval,         /* Time until next announce. */
198                     work->work_group,                /* Name to announce. */
199                     SV_TYPE_DOMAIN_ENUM|SV_TYPE_NT,  /* workgroup announce flags. */
200                     myname);                         /* From name as comment. */
201 }
202
203 /****************************************************************************
204  Announce the given host to WORKGROUP<1d>.
205 ****************************************************************************/
206
207 static void send_host_announcement(struct subnet_record *subrec, struct work_record *work,
208                                    struct server_record *servrec)
209 {
210   /* Ensure we don't have the prohibited bits set. */
211   uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
212
213   DEBUG(3,("send_host_announcement: type %x for host %s on subnet %s for workgroup %s\n",
214             type, servrec->serv.name, subrec->subnet_name, work->work_group));
215
216   send_announcement(subrec, ANN_HostAnnouncement,
217                     servrec->serv.name,              /* From nbt name. */
218                     work->work_group, 0x1d,          /* To nbt name. */
219                     subrec->bcast_ip,                /* To ip. */
220                     work->announce_interval,         /* Time until next announce. */
221                     servrec->serv.name,              /* Name to announce. */
222                     type,                            /* Type field. */
223                     servrec->serv.comment);
224 }
225
226 /****************************************************************************
227  Announce the given LanMan host
228 ****************************************************************************/
229
230 static void send_lm_host_announcement(struct subnet_record *subrec, struct work_record *work,
231                                    struct server_record *servrec, int lm_interval)
232 {
233   /* Ensure we don't have the prohibited bits set. */
234   uint32 type = servrec->serv.type & ~SV_TYPE_LOCAL_LIST_ONLY;
235
236   DEBUG(3,("send_lm_host_announcement: type %x for host %s on subnet %s for workgroup %s, ttl: %d\n",
237             type, servrec->serv.name, subrec->subnet_name, work->work_group, lm_interval));
238
239   send_lm_announcement(subrec, ANN_HostAnnouncement,
240                     servrec->serv.name,              /* From nbt name. */
241                     work->work_group, 0x00,          /* To nbt name. */
242                     subrec->bcast_ip,                /* To ip. */
243                     lm_interval,                     /* Time until next announce. */
244                     servrec->serv.name,              /* Name to announce. */
245                     type,                            /* Type field. */
246                     servrec->serv.comment);
247 }
248
249 /****************************************************************************
250   Announce a server record.
251   ****************************************************************************/
252
253 static void announce_server(struct subnet_record *subrec, struct work_record *work,
254                      struct server_record *servrec)
255 {
256   /* Only do domain announcements if we are a master and it's
257      our primary name we're being asked to announce. */
258
259   if (AM_LOCAL_MASTER_BROWSER(work) && strequal(myname,servrec->serv.name))
260   {
261     send_local_master_announcement(subrec, work, servrec);
262     send_workgroup_announcement(subrec, work);
263   }
264   else
265   {
266     send_host_announcement(subrec, work, servrec);
267   }
268 }
269
270 /****************************************************************************
271   Go through all my registered names on all broadcast subnets and announce
272   them if the timeout requires it.
273   **************************************************************************/
274
275 void announce_my_server_names(time_t t)
276 {
277   struct subnet_record *subrec;
278
279   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
280   {
281     struct work_record *work = find_workgroup_on_subnet(subrec, myworkgroup);
282
283     if(work)
284     {
285       struct server_record *servrec;
286
287       if (work->needannounce)
288       {
289         /* Drop back to a max 3 minute announce. This is to prevent a
290            single lost packet from breaking things for too long. */
291
292         work->announce_interval = MIN(work->announce_interval,
293                                     CHECK_TIME_MIN_HOST_ANNCE*60);
294         work->lastannounce_time = t - (work->announce_interval+1);
295         work->needannounce = False;
296       }
297
298       /* Announce every minute at first then progress to every 12 mins */
299       if ((t - work->lastannounce_time) < work->announce_interval)
300         continue;
301
302       if (work->announce_interval < (CHECK_TIME_MAX_HOST_ANNCE * 60))
303         work->announce_interval += 60;
304
305       work->lastannounce_time = t;
306
307       for (servrec = work->serverlist; servrec; servrec = servrec->next)
308       {
309         if (is_myname(servrec->serv.name))
310           announce_server(subrec, work, servrec);
311       }
312     } /* if work */
313   } /* for subrec */
314 }
315
316 /****************************************************************************
317   Go through all my registered names on all broadcast subnets and announce
318   them as a LanMan server if the timeout requires it.
319 **************************************************************************/
320
321 void announce_my_lm_server_names(time_t t)
322 {
323   struct subnet_record *subrec;
324   static time_t last_lm_announce_time=0;
325   int announce_interval = lp_lm_interval();
326   int lm_announce = lp_lm_announce();
327
328   if ((announce_interval <= 0) || (lm_announce <= 0))
329   {
330     /* user absolutely does not want LM announcements to be sent. */
331     return;
332   }
333
334   if ((lm_announce >= 2) && (!found_lm_clients))
335   {
336     /* has been set to 2 (Auto) but no LM clients detected (yet). */
337     return;
338   }
339
340   /* Otherwise: must have been set to 1 (Yes), or LM clients *have*
341      been detected. */
342
343   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
344   {
345     struct work_record *work = find_workgroup_on_subnet(subrec, myworkgroup);
346
347     if(work)
348     {
349       struct server_record *servrec;
350
351       if (last_lm_announce_time && ((t - last_lm_announce_time) < announce_interval ))
352         continue;
353
354       last_lm_announce_time = t;
355
356       for (servrec = work->serverlist; servrec; servrec = servrec->next)
357       {
358         if (is_myname(servrec->serv.name))
359           /* skipping equivalent of announce_server() */
360           send_lm_host_announcement(subrec, work, servrec, announce_interval);
361       }
362     } /* if work */
363   } /* for subrec */
364 }
365
366 /* Announce timer. Moved into global static so it can be reset
367    when a machine becomes a local master browser. */
368 static time_t announce_timer_last=0;
369
370 /****************************************************************************
371  Reset the announce_timer so that a local master browser announce will be done
372  immediately.
373  ****************************************************************************/
374
375 void reset_announce_timer()
376 {
377   announce_timer_last = time(NULL) - (CHECK_TIME_MST_ANNOUNCE * 60);
378 }
379
380 /****************************************************************************
381   Announce myself as a local master browser to a domain master browser.
382   **************************************************************************/
383
384 void announce_myself_to_domain_master_browser(time_t t)
385 {
386   struct subnet_record *subrec;
387   struct work_record *work;
388
389   if(!we_are_a_wins_client())
390   {
391     DEBUG(10,("announce_myself_to_domain_master_browser: no unicast subnet, ignoring.\n"));
392     return;
393   }
394
395   if (!announce_timer_last)
396     announce_timer_last = t;
397
398   if ((t-announce_timer_last) < (CHECK_TIME_MST_ANNOUNCE * 60))
399   {
400     DEBUG(10,("announce_myself_to_domain_master_browser: t (%d) - last(%d) < %d\n",
401                t, announce_timer_last, CHECK_TIME_MST_ANNOUNCE * 60 ));
402     return;
403   }
404
405   announce_timer_last = t;
406
407   /* Look over all our broadcast subnets to see if any of them
408      has the state set as local master browser. */
409
410   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
411   {
412     for (work = subrec->workgrouplist; work; work = work->next)
413     {
414       if (AM_LOCAL_MASTER_BROWSER(work))
415       {
416         DEBUG(4,( "announce_myself_to_domain_master_browser: I am a local master browser for \
417 workgroup %s on subnet %s\n", work->work_group, subrec->subnet_name));
418
419         /* Look in nmbd_browsersync.c for the rest of this code. */
420         announce_and_sync_with_domain_master_browser(subrec, work);
421       }
422     }
423   }
424 }
425
426 /****************************************************************************
427 Announce all samba's server entries as 'gone'.
428 This must *only* be called on shutdown.
429 ****************************************************************************/
430
431 void announce_my_servers_removed(void)
432 {
433   int announce_interval = lp_lm_interval();
434   int lm_announce = lp_lm_announce();
435   struct subnet_record *subrec; 
436
437   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
438   {
439     struct work_record *work;
440     for (work = subrec->workgrouplist; work; work = work->next)
441     {
442       struct server_record *servrec;
443
444       work->announce_interval = 0;
445       for (servrec = work->serverlist; servrec; servrec = servrec->next)
446       {
447         if (!is_myname(servrec->serv.name))
448           continue;
449         servrec->serv.type = 0;
450         if(AM_LOCAL_MASTER_BROWSER(work))
451           send_local_master_announcement(subrec, work, servrec);
452         send_host_announcement(subrec, work, servrec);
453
454
455         if ((announce_interval <= 0) || (lm_announce <= 0))
456         {
457           /* user absolutely does not want LM announcements to be sent. */
458           continue;
459         }
460
461         if ((lm_announce >= 2) && (!found_lm_clients))
462         {
463           /* has been set to 2 (Auto) but no LM clients detected (yet). */
464           continue;
465         }
466
467         /* 
468          * lm announce was set or we have seen lm announcements, so do
469          * a lm announcement of host removed.
470          */
471
472         send_lm_host_announcement(subrec, work, servrec, 0);
473       }
474     }
475   }
476 }
477
478 /****************************************************************************
479   Do all the "remote" announcements. These are used to put ourselves
480   on a remote browse list. They are done blind, no checking is done to
481   see if there is actually a local master browser at the other end.
482   **************************************************************************/
483
484 void announce_remote(time_t t)
485 {
486   char *s,*ptr;
487   static time_t last_time = 0;
488   pstring s2;
489   struct in_addr addr;
490   char *comment;
491   int stype = lp_default_server_announce();
492
493   if (last_time && (t < (last_time + REMOTE_ANNOUNCE_INTERVAL)))
494     return;
495
496   last_time = t;
497
498   s = lp_remote_announce();
499   if (!*s)
500     return;
501
502   comment = lp_serverstring();
503
504   for (ptr=s; next_token(&ptr,s2,NULL); ) 
505   {
506     /* The entries are of the form a.b.c.d/WORKGROUP with 
507        WORKGROUP being optional */
508     char *wgroup;
509     int i;
510
511     wgroup = strchr(s2,'/');
512     if (wgroup)
513       *wgroup++ = 0;
514     if (!wgroup || !*wgroup)
515       wgroup = myworkgroup;
516
517     addr = *interpret_addr2(s2);
518     
519     /* Announce all our names including aliases */
520     /* Give the ip address as the address of our first
521        broadcast subnet. */
522
523     for(i=0; my_netbios_names[i]; i++) 
524     {
525       char *name = my_netbios_names[i];
526
527       DEBUG(5,("announce_remote: Doing remote announce for server %s to IP %s.\n",
528                  name, inet_ntoa(addr) ));
529
530       send_announcement(FIRST_SUBNET, ANN_HostAnnouncement,
531                     name,                      /* From nbt name. */
532                     wgroup, 0x1e,              /* To nbt name. */
533                     addr,                      /* To ip. */
534                     REMOTE_ANNOUNCE_INTERVAL,  /* Time until next announce. */
535                     name,                      /* Name to announce. */
536                     stype,                     /* Type field. */
537                     comment);
538     }
539   }
540 }
541
542 /****************************************************************************
543   Implement the 'remote browse sync' feature Andrew added.
544   These are used to put our browse lists into remote browse lists.
545   **************************************************************************/
546
547 void browse_sync_remote(time_t t)
548 {  
549   char *s,*ptr;
550   static time_t last_time = 0; 
551   pstring s2;
552   struct in_addr addr;
553   struct work_record *work;
554   pstring outbuf;
555   char *p;
556  
557   if (last_time && (t < (last_time + REMOTE_ANNOUNCE_INTERVAL)))
558     return;
559    
560   last_time = t;
561
562   s = lp_remote_browse_sync();
563   if (!*s)
564     return;
565
566   /*
567    * We only do this if we are the local master browser
568    * for our workgroup on the firsst subnet.
569    */
570
571   if((work = find_workgroup_on_subnet(FIRST_SUBNET, myworkgroup)) == NULL)
572   {   
573     DEBUG(0,("browse_sync_remote: Cannot find workgroup %s on subnet %s\n",
574            myworkgroup, FIRST_SUBNET->subnet_name ));
575     return;
576   }   
577          
578   if(!AM_LOCAL_MASTER_BROWSER(work))
579   {
580     DEBUG(5,("browse_sync_remote: We can only do this if we are a local master browser \
581 for workgroup %s on subnet %s.\n", myworkgroup, FIRST_SUBNET->subnet_name ));
582     return;
583   } 
584
585   bzero(outbuf,sizeof(outbuf));
586   p = outbuf;
587   CVAL(p,0) = ANN_MasterAnnouncement;
588   p++;
589
590   StrnCpy(p,myname,15);
591   strupper(p);
592   p = skip_string(p,1);
593
594   for (ptr=s; next_token(&ptr,s2,NULL); ) 
595   {
596     /* The entries are of the form a.b.c.d */
597     addr = *interpret_addr2(s2);
598
599     DEBUG(5,("announce_remote: Doing remote browse sync announce for server %s to IP %s.\n",
600                  myname, inet_ntoa(addr) ));
601
602     send_mailslot(True, BROWSE_MAILSLOT, outbuf,PTR_DIFF(p,outbuf),
603           myname, 0x0, "*", 0x0, addr, FIRST_SUBNET->myip);
604   }
605 }