docs/Support.txt: Removed consultant.
[samba.git] / source3 / nmbd / nmbd_incomingdgrams.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    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22    
23 */
24
25 #include "includes.h"
26
27 extern int DEBUGLEVEL;
28
29 extern pstring myname;
30 extern fstring myworkgroup;
31 extern BOOL found_lm_clients;
32
33 #if 0
34
35 /* XXXX note: This function is currently unsuitable for use, as it
36    does not properly check that a server is in a fit state to become
37    a backup browser before asking it to be one.
38    The code is left here to be worked on at a later date.
39 */
40
41 /****************************************************************************
42 Tell a server to become a backup browser
43 **************************************************************************/
44
45 void tell_become_backup(void)
46 {
47   struct subnet_record *subrec;
48   for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec))
49   {
50     struct work_record *work;
51     for (work = subrec->workgrouplist; work; work = work->next)
52     {
53       struct server_record *servrec;
54       int num_servers = 0;
55       int num_backups = 0;
56           
57       for (servrec = work->serverlist; servrec; servrec = servrec->next)
58       {
59         num_servers++;
60               
61         if (is_myname(servrec->serv.name))
62           continue;
63               
64         if (servrec->serv.type & SV_TYPE_BACKUP_BROWSER) 
65         {
66           num_backups++;
67           continue;
68         }
69               
70         if (servrec->serv.type & SV_TYPE_MASTER_BROWSER)
71           continue;
72               
73         if (!(servrec->serv.type & SV_TYPE_POTENTIAL_BROWSER))
74           continue;
75               
76         DEBUG(3,("num servers: %d num backups: %d\n", 
77               num_servers, num_backups));
78               
79         /* make first server a backup server. thereafter make every
80            tenth server a backup server */
81         if (num_backups != 0 && (num_servers+9) / num_backups > 10)
82           continue;
83               
84         DEBUG(2,("sending become backup to %s %s for %s\n",
85              servrec->serv.name, inet_ntoa(subrec->bcast_ip),
86              work->work_group));
87               
88         /* type 11 request from MYNAME(20) to WG(1e) for SERVER */
89         do_announce_request(servrec->serv.name, work->work_group,
90               ANN_BecomeBackup, 0x20, 0x1e, subrec->bcast_ip);
91       }
92     }
93   }
94 }
95 #endif
96
97 /*******************************************************************
98   Process an incoming host announcement packet.
99 *******************************************************************/
100
101 void process_host_announce(struct subnet_record *subrec, struct packet_struct *p, char *buf)
102 {
103   struct dgram_packet *dgram = &p->packet.dgram;
104   int ttl = IVAL(buf,1)/1000;
105   char *announce_name = buf+5;
106   uint32 servertype = IVAL(buf,23);
107   char *comment = buf+31;
108   struct work_record *work;
109   struct server_record *servrec;
110   char *work_name;
111   char *source_name = dgram->source_name.name;
112
113   comment[43] = 0;
114   
115   DEBUG(3,("process_host_announce: from %s<%02x> IP %s to \
116 %s for server %s.\n", source_name, source_name[15], inet_ntoa(p->ip),
117               namestr(&dgram->dest_name),announce_name));
118
119   DEBUG(5,("process_host_announce: ttl=%d server type=%08x comment=%s\n",
120            ttl, servertype,comment));
121
122   /* Filter servertype to remove impossible bits. */
123   servertype &= ~(SV_TYPE_LOCAL_LIST_ONLY|SV_TYPE_DOMAIN_ENUM);
124
125   /* A host announcement must be sent to the name WORKGROUP<1d>. */
126   if(dgram->dest_name.name_type != 0x1d)
127   {
128     DEBUG(2,("process_host_announce: incorrect name type for destination from IP %s \
129 (was %02x) should be 0x1d. Allowing packet anyway.\n",
130               inet_ntoa(p->ip), dgram->dest_name.name_type));
131     /* Change it so it was. */
132     dgram->dest_name.name_type = 0x1d;
133   }
134
135   /* For a host announce the workgroup name is the destination name. */
136   work_name = dgram->dest_name.name;
137
138   /*
139    * Syntax servers version 5.1 send HostAnnounce packets to
140    * *THE WRONG NAME*. They send to LOCAL_MASTER_BROWSER_NAME<00>
141    * instead of WORKGROUP<1d> name. So to fix this we check if
142    * the workgroup name is our own name, and if so change it
143    * to be our primary workgroup name.
144    */
145
146   if(strequal(work_name, myname))
147     work_name = myworkgroup;
148
149   /*
150    * We are being very agressive here in adding a workgroup
151    * name on the basis of a host announcing itself as being
152    * in that workgroup. Maybe we should wait for the workgroup
153    * announce instead ? JRA.
154    */
155
156   work = find_workgroup_on_subnet(subrec, work_name);
157
158   if(servertype != 0)
159   {
160     if (work ==NULL )
161     {
162       /* We have no record of this workgroup. Add it. */
163       if((work = create_workgroup_on_subnet(subrec, work_name, ttl))==NULL)
164         return;
165     }
166   
167     if((servrec = find_server_in_workgroup( work, announce_name))==NULL)
168     {
169       /* If this server is not already in the workgroup, add it. */
170       create_server_on_workgroup(work, announce_name, 
171                                  servertype|SV_TYPE_LOCAL_LIST_ONLY, 
172                                  ttl, comment);
173     }
174     else
175     {
176       /* Update the record. */
177       servrec->serv.type = servertype|SV_TYPE_LOCAL_LIST_ONLY;
178       update_server_ttl( servrec, ttl);
179       StrnCpy(servrec->serv.comment,comment,sizeof(servrec->serv.comment)-1);
180     }
181   }
182   else
183   {
184     /*
185      * This server is announcing it is going down. Remove it from the 
186      * workgroup.
187      */
188     if(!is_myname(announce_name) && (work != NULL) &&
189        ((servrec = find_server_in_workgroup( work, announce_name))!=NULL)
190       )
191     {
192       remove_server_from_workgroup( work, servrec);
193     }
194   }
195   subrec->work_changed = True;
196 }
197
198 /*******************************************************************
199   Process an incoming WORKGROUP announcement packet.
200 *******************************************************************/
201
202 void process_workgroup_announce(struct subnet_record *subrec, struct packet_struct *p, char *buf)
203 {
204   struct dgram_packet *dgram = &p->packet.dgram;
205   int ttl = IVAL(buf,1)/1000;
206   char *workgroup_announce_name = buf+5;
207   uint32 servertype = IVAL(buf,23);
208   char *master_name = buf+31;
209   struct work_record *work;
210   char *source_name = dgram->source_name.name;
211
212   master_name[43] = 0;
213
214   DEBUG(3,("process_workgroup_announce: from %s<%02x> IP %s to \
215 %s for workgroup %s.\n", source_name, source_name[15], inet_ntoa(p->ip),
216               namestr(&dgram->dest_name),workgroup_announce_name));
217
218   DEBUG(5,("process_workgroup_announce: ttl=%d server type=%08x master browser=%s\n",
219            ttl, servertype, master_name));
220
221   /* Workgroup announcements must only go to the MSBROWSE name. */
222   if (!strequal(dgram->dest_name.name, MSBROWSE) || (dgram->dest_name.name_type != 0x1))
223   {
224     DEBUG(0,("process_workgroup_announce: from IP %s should be to __MSBROWSE__<0x01> not %s\n",
225               inet_ntoa(p->ip), namestr(&dgram->dest_name)));
226     return;
227   }
228
229   if ((work = find_workgroup_on_subnet(subrec, workgroup_announce_name))==NULL)
230   {
231     /* We have no record of this workgroup. Add it. */
232     if((work = create_workgroup_on_subnet(subrec, workgroup_announce_name, ttl))==NULL)
233       return;
234   }
235   else
236   {
237     /* Update the workgroup death_time. */
238     update_workgroup_ttl(work, ttl);
239   }
240
241   if(*work->local_master_browser_name == '\0')
242   {
243     /* Set the master browser name. */
244     set_workgroup_local_master_browser_name( work, master_name );
245   }
246
247   subrec->work_changed = True;
248 }
249
250 /*******************************************************************
251   Process an incoming local master browser announcement packet.
252 *******************************************************************/
253
254 void process_local_master_announce(struct subnet_record *subrec, struct packet_struct *p, char *buf)
255 {
256   struct dgram_packet *dgram = &p->packet.dgram;
257   int ttl = IVAL(buf,1)/1000;
258   char *server_name = buf+5;
259   uint32 servertype = IVAL(buf,23);
260   char *comment = buf+31;
261   char *work_name;
262   struct work_record *work;
263   struct server_record *servrec;
264   char *source_name = dgram->source_name.name;
265
266   comment[43] = 0;
267
268   DEBUG(3,("process_local_master_announce: from %s<%02x> IP %s to \
269 %s for server %s.\n", source_name, source_name[15], inet_ntoa(p->ip),
270               namestr(&dgram->dest_name),server_name));
271
272   DEBUG(5,("process_local_master_announce: ttl=%d server type=%08x comment=%s\n",
273            ttl, servertype, comment));
274
275   /* A local master announcement must be sent to the name WORKGROUP<1e>. */
276   if(dgram->dest_name.name_type != 0x1e)
277   {
278     DEBUG(0,("process_local_master_announce: incorrect name type for destination from IP %s \
279 (was %02x) should be 0x1e. Ignoring packet.\n",
280               inet_ntoa(p->ip), dgram->dest_name.name_type));
281     return;
282   }
283
284   /* Filter servertype to remove impossible bits. */
285   servertype &= ~(SV_TYPE_LOCAL_LIST_ONLY|SV_TYPE_DOMAIN_ENUM);
286
287   /* For a local master announce the workgroup name is the destination name. */
288   work_name = dgram->dest_name.name;
289
290   if ((work = find_workgroup_on_subnet(subrec, work_name))==NULL)
291   {
292     /* Don't bother adding if it's a local master release announce. */
293     if(servertype == 0)
294       return;
295
296     /* We have no record of this workgroup. Add it. */
297     if((work = create_workgroup_on_subnet(subrec, work_name, ttl))==NULL)
298       return;
299   }
300
301   /* If we think we're the local master browser for this workgroup,
302      we should never have got this packet. We don't see our own
303      packets.
304    */
305   if(AM_LOCAL_MASTER_BROWSER(work))
306   {
307     DEBUG(0,("process_local_master_announce: Server %s at IP %s is announcing itself as \
308 a local master browser for workgroup %s and we think we are master. Forcing election.\n",
309       server_name, inet_ntoa(p->ip), work_name));
310
311     /* Samba nmbd versions 1.9.17 to 1.9.17p4 have a bug in that when
312        they have become a local master browser once, they will never
313        stop sending local master announcements. To fix this we send
314        them a reset browser packet, with level 0x2 on the __SAMBA__
315        name that only they should be listening to. */
316    
317     send_browser_reset( 0x2, "__SAMBA__" , 0x20, p->ip);
318
319     /* We should demote ourself and force an election. */
320
321     unbecome_local_master_browser( subrec, work);
322
323     /* The actual election requests are handled in
324        nmbd_election.c */
325
326     work->needelection = True;
327     return;
328   }  
329
330   /* Find the server record on this workgroup. If it doesn't exist, add it. */
331
332   if(servertype != 0)
333   {
334     if((servrec = find_server_in_workgroup( work, server_name))==NULL)
335     {
336       /* If this server is not already in the workgroup, add it. */
337       create_server_on_workgroup(work, server_name, 
338                                  servertype|SV_TYPE_LOCAL_LIST_ONLY, 
339                                  ttl, comment);
340     }
341     else
342     {
343       /* Update the record. */
344       servrec->serv.type = servertype|SV_TYPE_LOCAL_LIST_ONLY;
345       update_server_ttl(servrec, ttl);
346       StrnCpy(servrec->serv.comment,comment,sizeof(servrec->serv.comment)-1);
347     }
348
349     set_workgroup_local_master_browser_name( work, server_name );
350   }
351   else
352   {
353     /*
354      * This server is announcing it is going down. Remove it from the
355      * workgroup.
356      */
357     if(!is_myname(server_name) && (work != NULL) &&
358        ((servrec = find_server_in_workgroup( work, server_name))!=NULL)
359       )
360     {
361       remove_server_from_workgroup( work, servrec);
362     }
363   }
364
365   subrec->work_changed = True;
366 }
367
368 /*******************************************************************
369   Process a domain master announcement frame.
370   Domain master browsers receive these from local masters. The Domain
371   master should then issue a sync with the local master, asking for
372   that machines local server list.
373 ******************************************************************/
374
375 void process_master_browser_announce(struct subnet_record *subrec, 
376                                      struct packet_struct *p,char *buf)
377 {
378   char *local_master_name = buf;
379   struct work_record *work;
380   struct browse_cache_record *browrec;
381
382   local_master_name[15] = 0;
383   
384   DEBUG(3,("process_master_browser_announce: Local master announce from %s IP %s.\n",
385            local_master_name, inet_ntoa(p->ip)));
386   
387   if (!lp_domain_master()) 
388   {
389     DEBUG(0,("process_master_browser_announce: Not configured as domain \
390 master - ignoring master announce.\n"));
391     return;
392   }
393   
394   if((work = find_workgroup_on_subnet(subrec, myworkgroup)) == NULL)
395   {
396     DEBUG(0,("process_master_browser_announce: Cannot find workgroup %s on subnet %s\n",
397            myworkgroup, subrec->subnet_name));
398     return;
399   }
400
401   if(!AM_DOMAIN_MASTER_BROWSER(work))
402   {
403     DEBUG(0,("process_master_browser_announce: Local master announce made to us from \
404 %s IP %s and we are not a domain master browser.\n", local_master_name, inet_ntoa(p->ip)));
405     return;
406   }
407
408   /* Add this host as a local master browser entry on the browse lists.
409      This causes a sync request to be made to it at a later date.
410    */
411
412   if((browrec = find_browser_in_lmb_cache( local_master_name )) == NULL)
413   {
414     /* Add it. */
415     create_browser_in_lmb_cache( work->work_group, local_master_name, p->ip);
416   }
417   else
418     update_browser_death_time(browrec);
419 }
420
421 /*******************************************************************
422   Process an incoming LanMan host announcement packet.
423 *******************************************************************/
424
425 void process_lm_host_announce(struct subnet_record *subrec, struct packet_struct *p, char *buf)
426 {
427   struct dgram_packet *dgram = &p->packet.dgram;
428   uint32 servertype = IVAL(buf,1);
429   int osmajor=CVAL(buf,5);           /* major version of node software */
430   int osminor=CVAL(buf,6);           /* minor version of node software */
431   int ttl = SVAL(buf,7);
432   char *announce_name = buf+9;
433   struct work_record *work;
434   struct server_record *servrec;
435   char *work_name;
436   char *source_name = dgram->source_name.name;
437   pstring comment;
438   char *s = buf+9;
439
440   s = skip_string(s,1);
441   StrnCpy(comment, s, 43);
442
443   DEBUG(3,("process_lm_host_announce: LM Announcement from %s<%02x> IP %s to \
444 %s for server %s.\n", source_name, source_name[15], inet_ntoa(p->ip),
445               namestr(&dgram->dest_name),announce_name));
446
447   DEBUG(5,("process_lm_host_announce: os=(%d,%d) ttl=%d server type=%08x comment=%s\n",
448           osmajor, osminor, ttl, servertype,comment));
449
450   if ((osmajor < 36) || (osmajor > 38) || (osminor !=0))
451   {
452     DEBUG(5,("process_lm_host_announce: LM Announcement packet does not " \
453              "originate from OS/2 Warp client. Ignoring packet.\n"));
454     /* Could have been from a Windows machine (with its LM Announce enabled),
455        or a Samba server. Then don't disrupt the current browse list. */
456     return;
457   }
458
459   /* Filter servertype to remove impossible bits. */
460   servertype &= ~(SV_TYPE_LOCAL_LIST_ONLY|SV_TYPE_DOMAIN_ENUM);
461
462   /* A LanMan host announcement must be sent to the name WORKGROUP<00>. */
463   if(dgram->dest_name.name_type != 0x00)
464   {
465     DEBUG(2,("process_lm_host_announce: incorrect name type for destination from IP %s \
466 (was %02x) should be 0x00. Allowing packet anyway.\n",
467               inet_ntoa(p->ip), dgram->dest_name.name_type));
468     /* Change it so it was. */
469     dgram->dest_name.name_type = 0x00;
470   }
471
472   /* For a LanMan host announce the workgroup name is the destination name. */
473   work_name = dgram->dest_name.name;
474
475   /*
476    * Syntax servers version 5.1 send HostAnnounce packets to
477    * *THE WRONG NAME*. They send to LOCAL_MASTER_BROWSER_NAME<00>
478    * instead of WORKGROUP<1d> name. So to fix this we check if
479    * the workgroup name is our own name, and if so change it
480    * to be our primary workgroup name. This code is probably
481    * not needed in the LanMan announce code, but it won't hurt.
482    */
483
484   if(strequal(work_name, myname))
485     work_name = myworkgroup;
486
487   /*
488    * We are being very agressive here in adding a workgroup
489    * name on the basis of a host announcing itself as being
490    * in that workgroup. Maybe we should wait for the workgroup
491    * announce instead ? JRA.
492    */
493
494   work = find_workgroup_on_subnet(subrec, work_name);
495
496   if(servertype != 0)
497   {
498     if (work == NULL)
499     {
500       /* We have no record of this workgroup. Add it. */
501       if((work = create_workgroup_on_subnet(subrec, work_name, ttl))==NULL)
502         return;
503     }
504
505     if((servrec = find_server_in_workgroup( work, announce_name))==NULL)
506     {
507       /* If this server is not already in the workgroup, add it. */
508       create_server_on_workgroup(work, announce_name,
509                                  servertype|SV_TYPE_LOCAL_LIST_ONLY,
510                                  ttl, comment);
511     }
512     else
513     {
514       /* Update the record. */
515       servrec->serv.type = servertype|SV_TYPE_LOCAL_LIST_ONLY;
516       update_server_ttl( servrec, ttl);
517       StrnCpy(servrec->serv.comment,comment,sizeof(servrec->serv.comment)-1);
518     }
519   }
520   else
521   {
522     /*
523      * This server is announcing it is going down. Remove it from the
524      * workgroup.
525      */
526     if(!is_myname(announce_name) && (work != NULL) &&
527        ((servrec = find_server_in_workgroup( work, announce_name))!=NULL)
528       )
529     {
530       remove_server_from_workgroup( work, servrec);
531     }
532   }
533
534   subrec->work_changed = True;
535   found_lm_clients = True;
536 }
537
538 /****************************************************************************
539   Send a backup list response.
540 *****************************************************************************/
541
542 static void send_backup_list_response(struct subnet_record *subrec, 
543                              struct work_record *work,
544                              struct nmb_name *send_to_name,
545                              unsigned char max_number_requested,
546                              uint32 token, struct in_addr sendto_ip)
547 {                     
548   char outbuf[1024];
549   char *p, *countptr, *nameptr;
550   unsigned int count = 0;
551   int len;
552   struct server_record *servrec;
553
554   bzero(outbuf,sizeof(outbuf));
555
556   DEBUG(3,("send_backup_list_response: sending backup list for workgroup %s to %s IP %s\n",
557            work->work_group, namestr(send_to_name), inet_ntoa(sendto_ip)));
558   
559   p = outbuf;
560   
561   SCVAL(p,0,ANN_GetBackupListResp); /* Backup list response opcode. */
562   p++;
563
564   countptr = p;
565   p++;
566
567   SIVAL(p,0,token); /* The sender's unique info. */
568   p += 4;
569   
570   nameptr = p;
571
572   /* We always return at least one name - our own. */
573   count = 1;
574   StrnCpy(p,myname,15);
575   strupper(p);
576   p = skip_string(p,1);
577
578   /* Look for backup browsers in this workgroup. */
579   for (servrec = work->serverlist; servrec; servrec = servrec->next)
580   { 
581     len = PTR_DIFF(p, outbuf);
582     if((sizeof(outbuf) - len) < 16)
583       break;
584
585     if(count >= (unsigned int)max_number_requested)
586       break;
587
588     if(strnequal(servrec->serv.name, myname,15))
589       continue;
590
591     if(!(servrec->serv.type & SV_TYPE_BACKUP_BROWSER))
592       continue;
593
594     StrnCpy(p, servrec->serv.name, 15);
595     strupper(p);
596     count++;
597
598     DEBUG(5,("send_backup_list_response: Adding server %s number %d\n",
599               p, count));
600
601     p = skip_string(p,1);
602   }
603
604   SCVAL(countptr, 0, count);
605
606   len = PTR_DIFF(p, outbuf);
607
608   DEBUG(4,("send_backup_list_response: sending response to %s<00> IP %s with %d servers.\n",
609           send_to_name->name, inet_ntoa(sendto_ip), count));
610
611   send_mailslot(True, BROWSE_MAILSLOT,
612                 outbuf,PTR_DIFF(p,outbuf),
613                 myname, 0, 
614                 send_to_name->name,0,
615                 sendto_ip, subrec->myip);
616 }
617
618 /*******************************************************************
619   Process a send backup list request packet.
620
621   A client sends a backup list request to ask for a list of servers on
622   the net that maintain server lists for a domain. A server is then
623   chosen from this list to send NetServerEnum commands to to list
624   available servers.
625
626 ********************************************************************/
627
628 void process_get_backup_list_request(struct subnet_record *subrec,
629                                      struct packet_struct *p,char *buf)
630 {
631   struct dgram_packet *dgram = &p->packet.dgram;
632   struct work_record *work;
633   unsigned char max_number_requested = CVAL(buf,0);
634   uint32 token = IVAL(buf,1); /* Sender's key index for the workgroup. */
635   int name_type = dgram->dest_name.name_type;
636   char *workgroup_name = dgram->dest_name.name;
637
638   DEBUG(3,("process_get_backup_list_request: request from %s IP %s to %s.\n",
639            namestr(&dgram->source_name), inet_ntoa(p->ip),
640            namestr(&dgram->dest_name)));
641   
642   /* We have to be a master browser, or a domain master browser
643      for the requested workgroup. That means it must be our
644      workgroup. */
645
646   if(strequal(workgroup_name, myworkgroup) == False)
647   {
648     DEBUG(7,("process_get_backup_list_request: Ignoring announce request for workgroup %s.\n",
649            workgroup_name));
650     return;
651   }
652
653   if((work = find_workgroup_on_subnet(subrec, workgroup_name)) == NULL)
654   {
655     DEBUG(0,("process_get_backup_list_request: Cannot find workgroup %s on \
656 subnet %s.\n", workgroup_name, subrec->subnet_name));
657     return;
658   }
659
660   if(name_type == 0x1b)
661   {
662     /* We must be a domain master browser in order to
663        process this packet. */
664
665     if(!AM_DOMAIN_MASTER_BROWSER(work))
666     {
667       DEBUG(0,("process_get_backup_list_request: domain list requested for workgroup %s \
668 and I am not a domain master browser.\n", workgroup_name));
669       return;
670     }
671   }
672   else if (name_type == 0x1d)
673   {
674     /* We must be a local master browser in order to
675        process this packet. */
676
677     if(!AM_LOCAL_MASTER_BROWSER(work))
678     {
679       DEBUG(0,("process_get_backup_list_request: domain list requested for workgroup %s \
680 and I am not a local master browser.\n", workgroup_name));
681       return;
682     }
683   }
684   else
685   {
686     DEBUG(0,("process_get_backup_list_request: Invalid name type %x - should be 0x1b or 0x1d.\n",
687             name_type));
688     return;
689   }
690
691   send_backup_list_response(subrec, work, &dgram->source_name, 
692                             max_number_requested, token, p->ip);
693 }
694
695 /*******************************************************************
696   Process a reset browser state packet.
697
698   Diagnostic packet:
699   0x1 - Stop being a master browser and become a backup browser.
700   0x2 - Discard browse lists, stop being a master browser, try again.
701   0x4 - Stop being a master browser forever.
702          
703 ******************************************************************/
704
705 void process_reset_browser(struct subnet_record *subrec,
706                                   struct packet_struct *p,char *buf)
707 {
708   struct dgram_packet *dgram = &p->packet.dgram;
709   int state = CVAL(buf,0);
710   struct subnet_record *sr;
711
712   DEBUG(1,("process_reset_browser: received diagnostic browser reset \
713 request from %s IP %s state=0x%X\n",
714              namestr(&dgram->source_name), inet_ntoa(p->ip), state));
715
716   /* Stop being a local master browser on all our broadcast subnets. */
717   if (state & 0x1)
718   {
719     for (sr = FIRST_SUBNET; sr; sr = NEXT_SUBNET_EXCLUDING_UNICAST(sr))
720     {
721       struct work_record *work;
722       for (work = sr->workgrouplist; work; work = work->next)
723       {
724         if (AM_LOCAL_MASTER_BROWSER(work))
725         {
726           unbecome_local_master_browser(sr, work);
727           work->needelection = True;
728         }
729       }
730     }
731   }
732   
733   /* Discard our browse lists. */
734   if (state & 0x2)
735   {
736     /*
737      * Calling expire_workgroups_and_servers with a -1
738      * time causes all servers not marked with a PERMANENT_TTL
739      * on the workgroup lists to be discarded, and all 
740      * workgroups with empty server lists to be discarded.
741      * This means we keep our own server names and workgroup
742      * as these have a PERMANENT_TTL.
743      */
744
745     expire_workgroups_and_servers(-1);
746   }
747   
748   /* Request to stop browsing altogether. */
749   if (state & 0x4)
750     DEBUG(1,("process_reset_browser: ignoring request to stop being a browser.\n"));
751 }
752
753 /*******************************************************************
754   Process an announcement request packet.
755   We don't respond immediately, we just check it's a request for
756   our workgroup and then set the flag telling the announce code
757   in nmbd_sendannounce.c:announce_my_server_names that an 
758   announcement is needed soon.
759 ******************************************************************/
760
761 void process_announce_request(struct subnet_record *subrec, struct packet_struct *p, char *buf)
762 {
763   struct dgram_packet *dgram = &p->packet.dgram;
764   struct work_record *work;
765   char *workgroup_name = dgram->dest_name.name;
766  
767   DEBUG(3,("process_announce_request: Announce request from %s IP %s to %s.\n",
768            namestr(&dgram->source_name), inet_ntoa(p->ip),
769            namestr(&dgram->dest_name)));
770   
771   /* We only send announcement requests on our workgroup. */
772   if(strequal(workgroup_name, myworkgroup) == False)
773   {
774     DEBUG(7,("process_announce_request: Ignoring announce request for workgroup %s.\n",
775            workgroup_name));
776     return;
777   }
778
779   if((work = find_workgroup_on_subnet(subrec, workgroup_name)) == NULL)
780   {
781     DEBUG(0,("process_announce_request: Unable to find workgroup %s on subnet !\n",
782             workgroup_name));
783     return;
784   }
785
786   work->needannounce = True;
787 }
788
789 /*******************************************************************
790   Process a LanMan announcement request packet.
791   We don't respond immediately, we just check it's a request for
792   our workgroup and then set the flag telling that we have found
793   a LanMan client (DOS or OS/2) and that we will have to start
794   sending LanMan announcements (unless specifically disabled
795   through the "lm announce" parameter in smb.conf)
796 ******************************************************************/
797
798 void process_lm_announce_request(struct subnet_record *subrec, struct packet_struct *p, char *buf)
799 {
800   struct dgram_packet *dgram = &p->packet.dgram;
801   struct work_record *work;
802   char *workgroup_name = dgram->dest_name.name;
803
804   DEBUG(3,("process_lm_announce_request: Announce request from %s IP %s to %s.\n",
805            namestr(&dgram->source_name), inet_ntoa(p->ip),
806            namestr(&dgram->dest_name)));
807
808   /* We only send announcement requests on our workgroup. */
809   if(strequal(workgroup_name, myworkgroup) == False)
810   {
811     DEBUG(7,("process_lm_announce_request: Ignoring announce request for workgroup %s.\n",
812            workgroup_name));
813     return;
814   }
815
816   if((work = find_workgroup_on_subnet(subrec, workgroup_name)) == NULL)
817   {
818     DEBUG(0,("process_announce_request: Unable to find workgroup %s on subnet !\n",
819             workgroup_name));
820     return;
821   }
822
823   found_lm_clients = True;
824 }