source/namework.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-1996
   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 #define TEST_CODE /* want to debug unknown browse packets */
  34
  35 extern int DEBUGLEVEL;
  36 extern pstring scope;
  37 extern BOOL CanRecurse;
  38
  39 extern pstring myname;
  40
  41 extern int ClientNMB;
  42 extern int ClientDGRAM;
  43
  44 extern struct in_addr ipzero;
  45
  46 extern int workgroup_count; /* total number of workgroups we know about */
  47
  48 /* this is our domain/workgroup/server database */
  49 extern struct subnet_record *subnetlist;
  50
  51 /* machine comment for host announcements */
  52 extern  pstring ServerComment;
  53
  54 extern int  updatecount;
  55
  56 /* what server type are we currently */
  57 #define DFLT_SERVER_TYPE (SV_TYPE_WORKSTATION | SV_TYPE_SERVER | \
  58                 SV_TYPE_TIME_SOURCE | SV_TYPE_SERVER_UNIX |\
  59                 SV_TYPE_PRINTQ_SERVER | SV_TYPE_POTENTIAL_BROWSER)
  60
  61 /* backup request types: which servers are to be included */
  62 #define MASTER_TYPE (SV_TYPE_MASTER_BROWSER)
  63 #define DOMCTL_TYPE (SV_TYPE_DOMAIN_CTRL   )
  64
  65 extern time_t StartupTime;
  66
  67
  68 /****************************************************************************
  69 tell a server to become a backup browser
  70 state - 0x01 become backup instead of master
  71       - 0x02 remove all entries in browse list and become non-master
  72       - 0x04 stop master browser service altogether. NT ignores this
  73 **************************************************************************/
  74 void reset_server(char *name, int state, struct in_addr ip)
  75 {
  76   char outbuf[20];
  77   char *p;
  78
  79   bzero(outbuf,sizeof(outbuf));
  80   p = outbuf;
  81
  82   CVAL(p,0) = ANN_ResetBrowserState;
  83   CVAL(p,2) = state;
  84   p += 2;
  85
  86   DEBUG(2,("sending reset to %s %s of state %d\n",
  87            name,inet_ntoa(ip),state));
  88
  89   send_mailslot_reply(BROWSE_MAILSLOT,ClientDGRAM,outbuf,PTR_DIFF(p,outbuf),
  90                       myname,name,0x20,0x1d,ip,*iface_ip(ip));
  91 }
  92
  93
  94 /****************************************************************************
  95 tell a server to become a backup browser
  96 **************************************************************************/
  97 void tell_become_backup(void)
  98 {
  99   /* XXXX note: this function is currently unsuitable for use, as it
 100      does not properly check that a server is in a fit state to become
 101      a backup browser before asking it to be one.
 102    */
 103
 104   struct subnet_record *d;
 105   for (d = subnetlist; d; d = d->next)
 106     {
 107       struct work_record *work;
 108       for (work = d->workgrouplist; work; work = work->next)
 109         {
 110           struct server_record *s;
 111           int num_servers = 0;
 112           int num_backups = 0;
 113
 114           for (s = work->serverlist; s; s = s->next)
 115             {
 116               if (s->serv.type & SV_TYPE_DOMAIN_ENUM) continue;
 117
 118               num_servers++;
 119
 120               if (strequal(myname, s->serv.name)) continue;
 121
 122               if (s->serv.type & SV_TYPE_BACKUP_BROWSER) {
 123                 num_backups++;
 124                 continue;
 125               }
 126
 127               if (s->serv.type & SV_TYPE_MASTER_BROWSER) continue;
 128
 129               if (!(s->serv.type & SV_TYPE_POTENTIAL_BROWSER)) continue;
 130
 131               DEBUG(3,("num servers: %d num backups: %d\n",
 132                        num_servers, num_backups));
 133
 134               /* make first server a backup server. thereafter make every
 135                  tenth server a backup server */
 136               if (num_backups != 0 && (num_servers+9) / num_backups > 10)
 137                 {
 138                   continue;
 139                 }
 140
 141               DEBUG(2,("sending become backup to %s %s for %s\n",
 142                        s->serv.name, inet_ntoa(d->bcast_ip),
 143                        work->work_group));
 144
 145               /* type 11 request from MYNAME(20) to WG(1e) for SERVER */
 146               do_announce_request(s->serv.name, work->work_group,
 147                                   ANN_BecomeBackup, 0x20, 0x1e, d->bcast_ip);
 148             }
 149         }
 150     }
 151 }
 152
 153
 154 /*******************************************************************
 155   same context: scope. should check name_type as well, and makes sure
 156   we don't process messages from ourselves
 157   ******************************************************************/
 158 BOOL same_context(struct dgram_packet *dgram)
 159 {
 160   if (!strequal(dgram->dest_name  .scope,scope )) return(True);
 161   if ( strequal(dgram->source_name.name ,myname)) return(True);
 162
 163   return(False);
 164 }
 165
 166
 167 /*******************************************************************
 168   am I listening on a name. XXXX check the type of name as well.
 169   ******************************************************************/
 170 BOOL listening_name(struct work_record *work, struct nmb_name *n)
 171 {
 172   if (strequal(n->name,myname) ||
 173       strequal(n->name,work->work_group) ||
 174       strequal(n->name,MSBROWSE))
 175     {
 176       return(True);
 177     }
 178
 179   return(False);
 180 }
 181
 182
 183 /*******************************************************************
 184   process a domain announcement frame
 185
 186   Announce frames come in 3 types. Servers send host announcements
 187   (command=1) to let the master browswer know they are
 188   available. Master browsers send local master announcements
 189   (command=15) to let other masters and backups that they are the
 190   master. They also send domain announcements (command=12) to register
 191   the domain
 192
 193   The comment field of domain announcements contains the master
 194   browser name. The servertype is used by NetServerEnum to select
 195   resources. We just have to pass it to smbd (via browser.dat) and let
 196   the client choose using bit masks.
 197   ******************************************************************/
 198 static void process_announce(struct packet_struct *p,int command,char *buf)
 199 {
 200   struct dgram_packet *dgram = &p->packet.dgram;
 201   struct in_addr ip = dgram->header.source_ip;
 202   struct subnet_record *d = find_subnet(ip);
 203   int update_count = CVAL(buf,0);
 204   int ttl = IVAL(buf,1)/1000;
 205   char *name = buf+5;
 206   int osmajor=CVAL(buf,21);
 207   int osminor=CVAL(buf,22);
 208   uint32 servertype = IVAL(buf,23);
 209   char *comment = buf+31;
 210   struct work_record *work;
 211   char *work_name;
 212   char *serv_name = dgram->source_name.name;
 213   BOOL add = False;
 214
 215   comment[43] = 0;
 216
 217   DEBUG(4,("Announce(%d) %s(%x)",command,name,name[15]));
 218   DEBUG(4,("%s count=%d ttl=%d OS=(%d,%d) type=%08x comment=%s\n",
 219            namestr(&dgram->dest_name),update_count,ttl,osmajor,osminor,
 220            servertype,comment));
 221
 222   name[15] = 0;
 223
 224   if (dgram->dest_name.name_type == 0 && command == ANN_HostAnnouncement)
 225     {
 226       DEBUG(2,("Announce to nametype(0) not supported yet\n"));
 227       return;
 228     }
 229
 230   if (command == ANN_DomainAnnouncement &&
 231       ((!strequal(dgram->dest_name.name, MSBROWSE)) ||
 232        dgram->dest_name.name_type != 0x1))
 233     {
 234       DEBUG(0,("Announce(%d) from %s should be __MSBROWSE__(1) not %s\n",
 235                 command, inet_ntoa(ip), namestr(&dgram->dest_name)));
 236       return;
 237     }
 238
 239   if (same_context(dgram)) return;
 240
 241   if (command == ANN_DomainAnnouncement) {
 242     /* XXXX if we are a master browser for the workgroup work_name,
 243        then there is a local subnet configuration problem. only
 244        we should be sending out such domain announcements, because
 245        as the master browser, that is our job.
 246
 247        stop being a master browser, and force an election. this will
 248        sort out the network problem. hopefully.
 249      */
 250
 251     work_name = name;
 252   } else {
 253     work_name = dgram->dest_name.name;
 254   }
 255
 256   /* we need some way of finding out about new workgroups
 257      that appear to be sending packets to us. The name_type checks make
 258      sure we don't add host names as workgroups */
 259   if (command == ANN_HostAnnouncement &&
 260       (dgram->dest_name.name_type == 0x1d ||
 261        dgram->dest_name.name_type == 0x1e))
 262     add = True;
 263
 264   if (!(work = find_workgroupstruct(d, work_name,add)))
 265     return;
 266
 267   DEBUG(4, ("workgroup %s on %s\n", work->work_group, serv_name));
 268
 269   ttl = GET_TTL(ttl);
 270
 271   /* add them to our browse list */
 272   add_server_entry(d,work,name,servertype,ttl,comment,True);
 273
 274 #if 0
 275   /* the tell become backup code is broken, no great harm is done by
 276      disabling it */
 277   tell_become_backup();
 278 #endif
 279
 280   /* XXXX over-kill: i don't think we should really be doing this,
 281      but it doesn't do much harm other than to add extra network
 282      traffic. to be more precise, we should (possibly) only
 283      sync browse lists with a host that sends an
 284      ANN_LocalMasterAnnouncement or an ANN_DomainAnnouncement.
 285      possibly.
 286    */
 287
 288   /* get their browse list from them and add it to ours. */
 289   add_browser_entry(serv_name,dgram->dest_name.name_type,
 290                     work->work_group,30,ip);
 291 }
 292
 293 /*******************************************************************
 294   process a master announcement frame
 295   ******************************************************************/
 296 static void process_master_announce(struct packet_struct *p,char *buf)
 297 {
 298   struct dgram_packet *dgram = &p->packet.dgram;
 299   struct in_addr ip = dgram->header.source_ip;
 300   struct subnet_record *d = find_subnet(ip);
 301   struct subnet_record *mydomain = find_subnet(*iface_bcast(ip));
 302   char *name = buf;
 303   struct work_record *work;
 304   name[15] = 0;
 305
 306   DEBUG(3,("Master Announce from %s (%s)\n",name,inet_ntoa(ip)));
 307
 308   if (same_context(dgram)) return;
 309
 310   if (!d || !mydomain) return;
 311
 312   if (!lp_domain_master()) return;
 313
 314   for (work = mydomain->workgrouplist; work; work = work->next)
 315     {
 316       if (AM_MASTER(work))
 317         {
 318           /* merge browse lists with them */
 319           add_browser_entry(name,0x1b, work->work_group,30,ip);
 320         }
 321     }
 322 }
 323
 324 /*******************************************************************
 325   process a receive backup list request
 326
 327   we receive a list of servers, and we attempt to locate them all on
 328   our local subnet, and sync browse lists with them on the workgroup
 329   they are said to be in.
 330
 331   XXXX NOTE: this function is in overdrive. it should not really do
 332   half of what it actually does (it should pick _one_ name from the
 333   list received and sync with it at regular intervals, rather than
 334   sync with them all only once!)
 335
 336   ******************************************************************/
 337 static void process_rcv_backup_list(struct packet_struct *p,char *buf)
 338 {
 339   struct dgram_packet *dgram = &p->packet.dgram;
 340   struct in_addr ip = dgram->header.source_ip;
 341   int count = CVAL(buf,0);
 342   int Index = IVAL(buf,1); /* caller's index representing workgroup */
 343   char *buf1;
 344
 345   DEBUG(3,("Receive Backup ack for %s from %s total=%d index=%d\n",
 346            namestr(&dgram->dest_name), inet_ntoa(ip),
 347            count, Index));
 348
 349   if (same_context(dgram)) return;
 350
 351   if (count <= 0) return;
 352
 353   /* go through the list of servers attempting to sync browse lists */
 354   for (buf1 = buf+5; *buf1 && count; buf1 = skip_string(buf1, 1), --count)
 355     {
 356       struct in_addr back_ip;
 357       struct subnet_record *d;
 358
 359       DEBUG(4,("Searching for backup browser %s at %s...\n",
 360                buf1, inet_ntoa(ip)));
 361
 362       /* XXXX assume name is a DNS name NOT a netbios name. a more complete
 363              approach is to use reply_name_query functionality to find the name */
 364       back_ip = *interpret_addr2(buf1);
 365
 366       if (zero_ip(back_ip))
 367         {
 368           DEBUG(4,("Failed to find backup browser server using DNS\n"));
 369           continue;
 370         }
 371
 372       DEBUG(4,("Found browser server at %s\n", inet_ntoa(back_ip)));
 373
 374       if ((d = find_subnet(back_ip)))
 375         {
 376           struct subnet_record *d1;
 377           for (d1 = subnetlist; d1; d1 = d1->next)
 378             {
 379               struct work_record *work;
 380               for (work = d1->workgrouplist; work; work = work->next)
 381                 {
 382                   if (work->token == Index)
 383                     {
 384                       queue_netbios_packet(d1,ClientNMB,NMB_QUERY,NAME_QUERY_SRV_CHK,
 385                                            work->work_group,0x1d,0,0,
 386                                            False,False,back_ip,back_ip);
 387                       return;
 388                     }
 389                 }
 390             }
 391         }
 392     }
 393 }
 394
 395
 396 /****************************************************************************
 397   send a backup list response.
 398   **************************************************************************/
 399 static void send_backup_list(char *work_name, struct nmb_name *src_name,
 400                              int info_count, int token, int info,
 401                              int name_type, struct in_addr ip)
 402 {
 403   struct subnet_record *d;
 404   char outbuf[1024];
 405   char *p, *countptr, *nameptr;
 406   int count = 0;
 407   int i, j;
 408   char *theirname = src_name->name;
 409
 410   DEBUG(3,("sending backup list of %s to %s: %s(%x) %s(%x)\n",
 411            work_name, inet_ntoa(ip),
 412            myname,0x20,theirname,0x0));
 413
 414   if (name_type == 0x1d)
 415     {
 416       DEBUG(4,("master browsers: "));
 417     }
 418   else if (name_type == 0x1b)
 419     {
 420       DEBUG(4,("domain controllers: "));
 421     }
 422   else
 423     {
 424       DEBUG(0,("backup request for unknown type %0x\n", name_type));
 425       return;
 426     }
 427
 428   bzero(outbuf,sizeof(outbuf));
 429   p = outbuf;
 430
 431   CVAL(p,0) = ANN_GetBackupListResp;    /* backup list response */
 432   p++;
 433
 434   countptr = p; /* count pointer */
 435
 436   SSVAL(p,1,token); /* sender's workgroup index representation */
 437   SSVAL(p,3,info); /* XXXX clueless: info, usually zero */
 438   p += 5;
 439
 440   nameptr = p;
 441
 442   for (d = subnetlist; d; d = d->next)
 443     {
 444       struct work_record *work;
 445
 446       for (work = d->workgrouplist; work; work = work->next)
 447         {
 448           struct server_record *s;
 449
 450           if (!strequal(work->work_group, work_name)) continue;
 451
 452           for (s = work->serverlist; s; s = s->next)
 453             {
 454               BOOL found = False;
 455               char *n;
 456
 457               if (s->serv.type & SV_TYPE_DOMAIN_ENUM) continue;
 458
 459               for (n = nameptr; n < p; n = skip_string(n, 1))
 460                 {
 461                   if (strequal(n, s->serv.name)) found = True;
 462                 }
 463
 464               if (found) continue; /* exclude names already added */
 465
 466               /* workgroup request: include all backup browsers in the list */
 467               /* domain request: include all domain members in the list */
 468
 469               if ((name_type == 0x1d && (s->serv.type & MASTER_TYPE)) ||
 470                   (name_type == 0x1b && (s->serv.type & DOMCTL_TYPE)))
 471                 {
 472                   DEBUG(4, ("%s ", s->serv.name));
 473
 474                   count++;
 475                   strcpy(p,s->serv.name);
 476                   strupper(p);
 477                   p = skip_string(p,1);
 478                 }
 479             }
 480         }
 481     }
 482
 483   if (count == 0)
 484     {
 485       DEBUG(4, ("none\n"));
 486       return;
 487     }
 488   else
 489     {
 490       DEBUG(4, (" - count %d\n", count));
 491     }
 492
 493   CVAL(countptr,0) = count; /* total number of backup browsers found */
 494
 495   {
 496     int len = PTR_DIFF(p, outbuf);
 497
 498     for (i = 0; i < len; i+= 16)
 499       {
 500         DEBUG(4, ("%3x char ", i));
 501
 502         for (j = 0; j < 16; j++)
 503           {
 504             unsigned char x = outbuf[i+j];
 505             if (x < 32 || x > 127) x = '.';
 506
 507             if (i+j >= len) break;
 508             DEBUG(4, ("%c", x));
 509           }
 510
 511         DEBUG(4, (" hex ", i));
 512
 513         for (j = 0; j < 16; j++)
 514           {
 515             if (i+j >= len) break;
 516             DEBUG(4, (" %02x", outbuf[i+j]));
 517           }
 518
 519         DEBUG(4, ("\n"));
 520       }
 521
 522   }
 523   send_mailslot_reply(BROWSE_MAILSLOT,ClientDGRAM,outbuf,PTR_DIFF(p,outbuf),
 524                       myname,theirname,0x20,0x0,ip,*iface_ip(ip));
 525 }
 526
 527
 528 /*******************************************************************
 529   process a send backup list request
 530
 531   A client sends a backup list request to ask for a list of servers on
 532   the net that maintain server lists for a domain. A server is then
 533   chosen from this list to send NetServerEnum commands to to list
 534   available servers.
 535
 536   Currently samba only sends back one name in the backup list, its
 537   own. For larger nets we'll have to add backups and send "become
 538   backup" requests occasionally.
 539   ******************************************************************/
 540 static void process_send_backup_list(struct packet_struct *p,char *buf)
 541 {
 542   struct dgram_packet *dgram = &p->packet.dgram;
 543   struct in_addr ip = dgram->header.source_ip;
 544   struct subnet_record *d;
 545   struct work_record *work;
 546
 547   int count = CVAL(buf,0);
 548   int token = SVAL(buf,1); /* sender's key index for the workgroup? */
 549   int info  = SVAL(buf,3); /* XXXX don't know: some sort of info */
 550   int name_type = dgram->dest_name.name_type;
 551
 552   if (same_context(dgram)) return;
 553
 554   if (count <= 0) return;
 555
 556   if (name_type != 0x1b && name_type != 0x1d) {
 557     DEBUG(0,("backup request to wrong type %d from %s\n",
 558               name_type,inet_ntoa(ip)));
 559     return;
 560   }
 561
 562   for (d = subnetlist; d; d = d->next)
 563     {
 564       for (work = d->workgrouplist; work; work = work->next)
 565         {
 566           if (strequal(work->work_group, dgram->dest_name.name))
 567             {
 568               DEBUG(2,("sending backup list to %s %s count=%d\n",
 569                        namestr(&dgram->dest_name),inet_ntoa(ip),count));
 570
 571               send_backup_list(work->work_group,&dgram->source_name,
 572                                count,token,info,name_type,ip);
 573               return;
 574             }
 575         }
 576     }
 577 }
 578
 579
 580 /*******************************************************************
 581   process a reset browser state
 582
 583   diagnostic packet:
 584   0x1 - stop being a master browser and become a backup browser.
 585   0x2 - discard browse lists, stop being a master browser, try again.
 586   0x4 - stop being a master browser forever. no way. ain't gonna.
 587
 588   ******************************************************************/
 589 static void process_reset_browser(struct packet_struct *p,char *buf)
 590 {
 591   struct dgram_packet *dgram = &p->packet.dgram;
 592   int state = CVAL(buf,0);
 593
 594   DEBUG(1,("received diagnostic browser reset request to %s state=0x%X\n",
 595            namestr(&dgram->dest_name), state));
 596
 597   /* stop being a master but still deal with being a backup browser */
 598   if (state & 0x1)
 599     {
 600       struct subnet_record *d;
 601       for (d = subnetlist; d; d = d->next)
 602         {
 603           struct work_record *work;
 604           for (work = d->workgrouplist; work; work = work->next)
 605             {
 606               if (AM_MASTER(work))
 607                 {
 608                   become_nonmaster(d,work,SV_TYPE_DOMAIN_MASTER|SV_TYPE_MASTER_BROWSER);
 609                 }
 610             }
 611         }
 612     }
 613
 614   /* XXXX documentation inconsistency: the above description does not
 615      exactly tally with what is implemented for state & 0x2
 616    */
 617
 618   /* totally delete all servers and start afresh */
 619   if (state & 0x2)
 620     {
 621       struct subnet_record *d;
 622       for (d = subnetlist; d; d = d->next)
 623         {
 624           struct work_record *work;
 625           for (work=d->workgrouplist;work;work=remove_workgroup(d,work,True));
 626         }
 627       add_my_subnets(lp_workgroup());
 628     }
 629
 630   /* stop browsing altogether. i don't think this is a good idea! */
 631   if (state & 0x4)
 632     {
 633       DEBUG(1,("ignoring request to stop being a browser. sorry!\n"));
 634     }
 635 }
 636
 637
 638 /*******************************************************************
 639   process a announcement request
 640
 641   clients send these when they want everyone to send an announcement
 642   immediately. This can cause quite a storm of packets!
 643   ******************************************************************/
 644 static void process_announce_request(struct packet_struct *p,char *buf)
 645 {
 646   struct dgram_packet *dgram = &p->packet.dgram;
 647   struct work_record *work;
 648   struct in_addr ip = dgram->header.source_ip;
 649   struct subnet_record *d = find_subnet(ip);
 650   int token = CVAL(buf,0);
 651   char *name = buf+1;
 652
 653   name[15] = 0;
 654
 655   DEBUG(3,("Announce request from %s to %s token=0x%X\n",
 656            name,namestr(&dgram->dest_name), token));
 657
 658   if (strequal(dgram->source_name.name,myname)) return;
 659
 660   /* XXXX BUG or FEATURE?: need to ensure that we are a member of
 661      this workgroup before announcing, particularly as we only
 662      respond on local interfaces anyway.
 663
 664      if (strequal(dgram->dest_name, lp_workgroup()) return; ???
 665    */
 666
 667   if (!d) return;
 668
 669   if (!d->my_interface) return;
 670
 671   for (work = d->workgrouplist; work; work = work->next)
 672     {
 673      /* XXXX BUG: the destination name type should also be checked,
 674         not just the name. e.g if the name is WORKGROUP(0x1d) then
 675         we should only respond if we own that name */
 676
 677       if (strequal(dgram->dest_name.name,work->work_group))
 678         {
 679           work->needannounce = True;
 680         }
 681     }
 682 }
 683
 684
 685 /****************************************************************************
 686 depending on what announce has been made, we are only going to
 687 accept certain types of name announce. XXXX untested code
 688
 689 check listening name type
 690 ****************************************************************************/
 691 BOOL listening_type(struct packet_struct *p, int command)
 692 {
 693   struct dgram_packet *dgram = &p->packet.dgram;
 694   int type = dgram->dest_name.name_type;
 695
 696   switch (command)
 697     {
 698     case ANN_HostAnnouncement:
 699       {
 700         if (type != 0x0 || type != 0x20) return (False);
 701         break;
 702       }
 703
 704     case ANN_AnnouncementRequest:
 705       {
 706         return (True);
 707         break;
 708       }
 709
 710     case ANN_Election:
 711       {
 712         return (True);
 713         break;
 714       }
 715
 716     case ANN_GetBackupListReq:
 717       {
 718         return (True);
 719         break;
 720       }
 721
 722     case ANN_GetBackupListResp:
 723       {
 724         return (True);
 725         break;
 726       }
 727
 728     case ANN_DomainAnnouncement:
 729       {
 730         if (type != 0x1b || type != 0x1c) return (False);
 731         break;
 732       }
 733
 734     case ANN_MasterAnnouncement:
 735       {
 736         if (type != 0x1d) return (False);
 737         break;
 738       }
 739
 740     case ANN_LocalMasterAnnouncement:
 741       {
 742         if (type != 0x1c || type != 0x1d) return (False);
 743         break;
 744       }
 745     }
 746   return (True); /* we're not dealing with unknown packet types */
 747 }
 748
 749
 750 /****************************************************************************
 751 process a browse frame
 752 ****************************************************************************/
 753 void process_browse_packet(struct packet_struct *p,char *buf,int len)
 754 {
 755   int command = CVAL(buf,0);
 756   switch (command)
 757     {
 758     case ANN_HostAnnouncement:
 759     case ANN_DomainAnnouncement:
 760     case ANN_LocalMasterAnnouncement:
 761       {
 762         process_announce(p,command,buf+1);
 763         break;
 764       }
 765
 766     case ANN_AnnouncementRequest:
 767       {
 768         process_announce_request(p,buf+1);
 769         break;
 770       }
 771
 772     case ANN_Election:
 773       {
 774         process_election(p,buf+1);
 775         break;
 776       }
 777
 778     case ANN_GetBackupListReq:
 779       {
 780         process_send_backup_list(p,buf+1);
 781         break;
 782       }
 783
 784     case ANN_GetBackupListResp:
 785       {
 786         process_rcv_backup_list(p, buf+1);
 787         break;
 788       }
 789
 790     case ANN_ResetBrowserState:
 791       {
 792         process_reset_browser(p, buf+1);
 793         break;
 794       }
 795
 796     case ANN_MasterAnnouncement:
 797       {
 798         process_master_announce(p,buf+1);
 799         break;
 800       }
 801
 802     default:
 803       {
 804         struct dgram_packet *dgram = &p->packet.dgram;
 805         DEBUG(4,("ignoring browse packet %d from %s %s to %s\n",
 806                  command, namestr(&dgram->source_name),
 807                  inet_ntoa(p->ip), namestr(&dgram->dest_name)));
 808       }
 809     }
 810 }
 811
 812