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-1998
   6    Copyright (C) Luke Kenneth Casson Leighton 1994-1998
   7    Copyright (C) Jeremy Allison 1994-1998
   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 }