source/nameelect.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    NBT netbios routines and daemon - version 2
   5    Copyright (C) Andrew Tridgell 1994-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    Module name: nameelect.c
  22
  23    Revision History:
  24
  25    14 jan 96: lkcl@pires.co.uk
  26    added multiple workgroup domain master support
  27
  28    04 jul 96: lkcl@pires.co.uk
  29    added system to become a master browser by stages.
  30
  31
  32 */
  33
  34 #include "includes.h"
  35
  36 extern int ClientNMB;
  37 extern int ClientDGRAM;
  38
  39 extern int DEBUGLEVEL;
  40 extern pstring scope;
  41
  42 extern pstring myname;
  43 extern struct in_addr ipzero;
  44 extern struct in_addr ipgrp;
  45
  46 /* here are my election parameters */
  47
  48 extern time_t StartupTime;
  49
  50 extern struct subnet_record *subnetlist;
  51
  52 extern uint16 nb_type; /* samba's NetBIOS name type */
  53
  54 /*******************************************************************
  55   occasionally check to see if the master browser is around
  56   ******************************************************************/
  57 void check_master_browser(time_t t)
  58 {
  59   static time_t lastrun=0;
  60   struct subnet_record *d;
  61
  62   if (!lastrun) lastrun = t;
  63   if (t < lastrun + CHECK_TIME_MST_BROWSE * 60)
  64     return;
  65   lastrun = t;
  66
  67   dump_workgroups();
  68
  69   for (d = subnetlist; d; d = d->next)
  70     {
  71       struct work_record *work;
  72
  73       for (work = d->workgrouplist; work; work = work->next)
  74         {
  75           /* if we are not the browse master of a workgroup, and we can't
  76              find a browser on the subnet, do something about it. */
  77
  78           if (!AM_MASTER(work))
  79             {
  80               queue_netbios_packet(d,ClientNMB,NMB_QUERY,NAME_QUERY_MST_CHK,
  81                                    work->work_group,0x1d,0,0,0,NULL,NULL,
  82                                    True,False,d->bcast_ip,d->bcast_ip);
  83             }
  84         }
  85     }
  86 }
  87
  88
  89 /*******************************************************************
  90   what to do if a master browser DOESN't exist
  91   ******************************************************************/
  92 void browser_gone(char *work_name, struct in_addr ip)
  93 {
  94   struct subnet_record *d = find_subnet(ip);
  95   struct work_record *work = find_workgroupstruct(d, work_name, False);
  96
  97   /* i don't know about this workgroup, therefore i don't care */
  98   if (!work || !d) return;
  99
 100   /* don't do election stuff on the WINS subnet */
 101   if (ip_equal(d->bcast_ip,ipgrp))
 102     return;
 103
 104   if (strequal(work->work_group, lp_workgroup()))
 105   {
 106
 107       DEBUG(2,("Forcing election on %s %s\n",
 108                work->work_group,inet_ntoa(d->bcast_ip)));
 109
 110       /* we can attempt to become master browser */
 111       work->needelection = True;
 112   }
 113   else
 114   {
 115      /* local interfaces: force an election */
 116     send_election(d, work->work_group, 0, 0, myname);
 117
 118      /* only removes workgroup completely on a local interface
 119         persistent lmhosts entries on a local interface _will_ be removed).
 120       */
 121      remove_workgroup(d, work,True);
 122   }
 123 }
 124
 125
 126 /****************************************************************************
 127   send an election packet
 128   **************************************************************************/
 129 void send_election(struct subnet_record *d, char *group,uint32 criterion,
 130                    int timeup,char *name)
 131 {
 132   pstring outbuf;
 133   char *p;
 134
 135   if (!d) return;
 136
 137   DEBUG(2,("Sending election to %s for workgroup %s\n",
 138            inet_ntoa(d->bcast_ip),group));
 139
 140   bzero(outbuf,sizeof(outbuf));
 141   p = outbuf;
 142   CVAL(p,0) = ANN_Election; /* election */
 143   p++;
 144
 145   CVAL(p,0) = (criterion == 0 && timeup == 0) ? 0 : ELECTION_VERSION;
 146   SIVAL(p,1,criterion);
 147   SIVAL(p,5,timeup*1000); /* ms - despite the spec */
 148   p += 13;
 149   strcpy(p,name);
 150   strupper(p);
 151   p = skip_string(p,1);
 152
 153   send_mailslot_reply(BROWSE_MAILSLOT,ClientDGRAM,outbuf,PTR_DIFF(p,outbuf),
 154                       name,group,0,0x1e,d->bcast_ip,*iface_ip(d->bcast_ip));
 155 }
 156
 157
 158 /****************************************************************************
 159   un-register a SELF name that got rejected.
 160
 161   if this name happens to be rejected when samba is in the process
 162   of becoming a master browser (registering __MSBROWSE__, WORKGROUP(1d)
 163   or WORKGROUP(1b)) then we must stop being a master browser. sad.
 164
 165   **************************************************************************/
 166 void name_unregister_work(struct subnet_record *d, char *name, int name_type)
 167 {
 168     struct work_record *work;
 169
 170     remove_netbios_name(d,name,name_type,SELF,ipzero);
 171
 172     if (!(work = find_workgroupstruct(d, name, False))) return;
 173
 174     if (ms_browser_name(name, name_type) ||
 175         (AM_MASTER(work) && strequal(name, lp_workgroup()) == 0 &&
 176          (name_type == 0x1d || name_type == 0x1b)))
 177     {
 178       int remove_type = 0;
 179
 180       if (ms_browser_name(name, name_type))
 181         remove_type = SV_TYPE_MASTER_BROWSER|SV_TYPE_DOMAIN_MASTER;
 182       if (name_type == 0x1d)
 183         remove_type = SV_TYPE_MASTER_BROWSER;
 184       if (name_type == 0x1b)
 185         remove_type = SV_TYPE_DOMAIN_MASTER;
 186
 187       become_nonmaster(d, work, remove_type);
 188     }
 189 }
 190
 191
 192 /****************************************************************************
 193   registers a name.
 194
 195   if the name being added is a SELF name, we must additionally check
 196   whether to proceed to the next stage in samba becoming a master browser.
 197
 198   **************************************************************************/
 199 void name_register_work(struct subnet_record *d, char *name, int name_type,
 200                                 int nb_flags, time_t ttl, struct in_addr ip, BOOL bcast)
 201 {
 202   enum name_source source = (ismyip(ip) || ip_equal(ip, ipzero)) ?
 203                                                                 SELF : REGISTER;
 204
 205   if (source == SELF)
 206   {
 207     struct work_record *work = find_workgroupstruct(d, lp_workgroup(), False);
 208
 209     add_netbios_entry(d,name,name_type,nb_flags,ttl,source,ip,True,!bcast);
 210
 211     if (work)
 212     {
 213       if (work->state != MST_NONE)
 214       {
 215         /* samba is in the process of working towards master browser-ness.
 216            initiate the next stage.
 217          */
 218         become_master(d, work);
 219         return;
 220       }
 221     }
 222   }
 223 }
 224
 225
 226 /*******************************************************************
 227   become the master browser.
 228
 229   this is done in stages. note that this could take a while,
 230   particularly on a broadcast subnet, as we have to wait for
 231   the implicit registration of each name to be accepted.
 232
 233   as each name is successfully registered, become_master() is
 234   called again, in order to initiate the next stage. see
 235   dead_netbios_entry() - deals with implicit name registration
 236   and response_name_reg() - deals with explicit registration
 237   with a WINS server.
 238
 239   stage 1: was MST_NONE - go to MST_NONE and register ^1^2__MSBROWSE__^2^1.
 240   stage 2: was MST_WON  - go to MST_MSB  and register WORKGROUP(0x1d)
 241   stage 3: was MST_MSB  - go to MST_BROWSER and register WORKGROUP(0x1b)
 242   stage 4: was MST_BROWSER - go to MST_DOMAIN (do not pass GO, do not...)
 243
 244   XXXX note: this code still does not cope with the distinction
 245   between different types of nodes, particularly between M and P
 246   nodes. that comes later.
 247
 248   ******************************************************************/
 249 void become_master(struct subnet_record *d, struct work_record *work)
 250 {
 251   /* domain type must be limited to domain enum + server type. it must
 252      not have SV_TYPE_SERVER or anything else with SERVER in it, else
 253      clients get confused and start thinking this entry is a server
 254      not a workgroup
 255    */
 256   uint32 domain_type = SV_TYPE_DOMAIN_ENUM|SV_TYPE_NT;
 257
 258   if (!work) return;
 259
 260   DEBUG(2,("Becoming master for %s %s (currently at stage %d)\n",
 261                                         work->work_group,inet_ntoa(d->bcast_ip),work->state));
 262
 263   switch (work->state)
 264   {
 265     case MST_NONE: /* while we were nothing but a server... */
 266     {
 267       DEBUG(3,("go to first stage: register ^1^2__MSBROWSE__^2^1\n"));
 268       work->state = MST_WON; /* ... an election win was successful */
 269
 270       work->ElectionCriterion |= 0x5;
 271
 272       /* update our server status */
 273       work->ServerType &= ~SV_TYPE_POTENTIAL_BROWSER;
 274       add_server_entry(d,work,myname,work->ServerType,0,lp_serverstring(),True);
 275
 276       /* add special browser name */
 277       add_my_name_entry(d,MSBROWSE        ,0x01,nb_type|NB_ACTIVE|NB_GROUP);
 278
 279       /* DON'T do anything else after calling add_my_name_entry() */
 280       return;
 281     }
 282     case MST_WON: /* while nothing had happened except we won an election... */
 283     {
 284       DEBUG(3,("go to second stage: register as master browser\n"));
 285       work->state = MST_MSB; /* ... registering MSBROWSE was successful */
 286
 287       /* add server entry on successful registration of MSBROWSE */
 288       add_server_entry(d,work,work->work_group,domain_type,0,myname,True);
 289
 290       /* add master name */
 291       add_my_name_entry(d,work->work_group,0x1d,nb_type|NB_ACTIVE);
 292
 293       /* DON'T do anything else after calling add_my_name_entry() */
 294       return;
 295     }
 296     case MST_MSB: /* while we were still only registered MSBROWSE state... */
 297     {
 298       DEBUG(3,("2nd stage complete: registered as master browser\n"));
 299       work->state = MST_BROWSER; /* ... registering WORKGROUP(1d) succeeded */
 300
 301       /* update our server status */
 302       work->ServerType |= SV_TYPE_MASTER_BROWSER;
 303       add_server_entry(d,work,myname,work->ServerType,0,lp_serverstring(),True);
 304
 305       if (work->serverlist == NULL) /* no servers! */
 306       {
 307         /* ask all servers on our local net to announce to us */
 308         announce_request(work, d->bcast_ip);
 309       }
 310       break;
 311    }
 312
 313    case MST_BROWSER:
 314    {
 315       /* don't have to do anything: just report success */
 316       DEBUG(3,("3rd stage: become master browser!\n"));
 317
 318       break;
 319    }
 320
 321    case MST_DOMAIN_NONE:
 322    {
 323       if (lp_domain_master())
 324       {
 325         work->state = MST_DOMAIN_MEM; /* ... become domain member */
 326         DEBUG(3,("domain first stage: register as domain member\n"));
 327
 328         /* add domain member name */
 329         add_my_name_entry(d,work->work_group,0x1e,nb_type|NB_ACTIVE|NB_GROUP);
 330
 331         /* DON'T do anything else after calling add_my_name_entry() */
 332         return;
 333       }
 334       else
 335       {
 336         DEBUG(4,("samba not configured as a domain master.\n"));
 337       }
 338
 339       break;
 340    }
 341
 342    case MST_DOMAIN_MEM:
 343    {
 344       if (lp_domain_master())
 345       {
 346         work->state = MST_DOMAIN_TST; /* ... possibly become domain master */
 347         DEBUG(3,("domain second stage: register as domain master\n"));
 348
 349         if (lp_domain_logons())
 350             {
 351           work->ServerType |= SV_TYPE_DOMAIN_MEMBER;
 352           add_server_entry(d,work,myname,work->ServerType,0,lp_serverstring(),True);
 353         }
 354
 355         /* add domain master name */
 356         add_my_name_entry(d,work->work_group,0x1b,nb_type|NB_ACTIVE         );
 357
 358         /* DON'T do anything else after calling add_my_name_entry() */
 359         return;
 360       }
 361       else
 362       {
 363         DEBUG(4,("samba not configured as a domain master.\n"));
 364       }
 365
 366       break;
 367     }
 368
 369     case MST_DOMAIN_TST: /* while we were still a master browser... */
 370     {
 371       /* update our server status */
 372       if (lp_domain_master())
 373       {
 374         struct subnet_record *d1;
 375                 uint32 update_type = 0;
 376
 377         DEBUG(3,("domain third stage: samba is now a domain master.\n"));
 378         work->state = MST_DOMAIN; /* ... registering WORKGROUP(1b) succeeded */
 379
 380         update_type |= DFLT_SERVER_TYPE | SV_TYPE_DOMAIN_MASTER |
 381           SV_TYPE_POTENTIAL_BROWSER;
 382
 383                 work->ServerType |= update_type;
 384                 add_server_entry(d,work,myname,work->ServerType,0,lp_serverstring(),True);
 385
 386                 for (d1 = subnetlist; d1; d1 = d1->next)
 387                 {
 388                 struct work_record *w;
 389                         if (ip_equal(d1->bcast_ip, d->bcast_ip)) continue;
 390
 391                 for (w = d1->workgrouplist; w; w = w->next)
 392                         {
 393                                 struct server_record *s = find_server(w, myname);
 394                                 if (strequal(w->work_group, work->work_group))
 395                                 {
 396                                         w->ServerType |= update_type;
 397                                 }
 398                                 if (s)
 399                                 {
 400                                         s->serv.type |= update_type;
 401                                         DEBUG(4,("found server %s on %s: update to %8x\n",
 402                                                                         s->serv.name, inet_ntoa(d1->bcast_ip),
 403                                                                         s->serv.type));
 404                                 }
 405                         }
 406                 }
 407       }
 408
 409       break;
 410     }
 411
 412     case MST_DOMAIN:
 413     {
 414       /* don't have to do anything: just report success */
 415       DEBUG(3,("fifth stage: there isn't one yet!\n"));
 416       break;
 417     }
 418   }
 419 }
 420
 421
 422 /*******************************************************************
 423   unbecome the master browser. initates removal of necessary netbios
 424   names, and tells the world that we are no longer a master browser.
 425   ******************************************************************/
 426 void become_nonmaster(struct subnet_record *d, struct work_record *work,
 427                                 int remove_type)
 428 {
 429   int new_server_type = work->ServerType;
 430
 431   DEBUG(2,("Becoming non-master for %s\n",work->work_group));
 432
 433   /* can only remove master or domain types with this function */
 434   remove_type &= SV_TYPE_MASTER_BROWSER|SV_TYPE_DOMAIN_MASTER;
 435
 436   /* unbecome a master browser; unbecome a domain master, too :-( */
 437   if (remove_type & SV_TYPE_MASTER_BROWSER)
 438     remove_type |= SV_TYPE_DOMAIN_MASTER;
 439
 440   new_server_type &= ~remove_type;
 441
 442   if (!(new_server_type & (SV_TYPE_MASTER_BROWSER|SV_TYPE_DOMAIN_MASTER)))
 443   {
 444     /* no longer a master browser of any sort */
 445
 446     work->ServerType |= SV_TYPE_POTENTIAL_BROWSER;
 447     work->ElectionCriterion &= ~0x4;
 448     work->state = MST_NONE;
 449
 450         /* announce ourselves as no longer active as a master browser. */
 451     announce_server(d, work, work->work_group, myname, 0, 0);
 452     remove_name_entry(d,MSBROWSE        ,0x01);
 453   }
 454
 455   work->ServerType = new_server_type;
 456
 457   if (!(work->ServerType & SV_TYPE_DOMAIN_MASTER))
 458   {
 459     if (work->state == MST_DOMAIN)
 460       work->state = MST_BROWSER;
 461     remove_name_entry(d,work->work_group,0x1b);
 462   }
 463
 464   if (!(work->ServerType & SV_TYPE_MASTER_BROWSER))
 465   {
 466     if (work->state >= MST_BROWSER)
 467       work->state = MST_NONE;
 468     remove_name_entry(d,work->work_group,0x1d);
 469   }
 470 }
 471
 472
 473 /*******************************************************************
 474   run the election
 475   ******************************************************************/
 476 void run_elections(time_t t)
 477 {
 478   static time_t lastime = 0;
 479
 480   struct subnet_record *d;
 481
 482   /* send election packets once a second */
 483   if (lastime && t-lastime <= 0) return;
 484
 485   lastime = t;
 486
 487   for (d = subnetlist; d; d = d->next)
 488   {
 489     struct work_record *work;
 490     for (work = d->workgrouplist; work; work = work->next)
 491         {
 492           if (work->RunningElection)
 493           {
 494             send_election(d,work->work_group, work->ElectionCriterion,
 495                             t-StartupTime,myname);
 496
 497             if (work->ElectionCount++ >= 4)
 498                 {
 499                   /* I won! now what :-) */
 500                   DEBUG(2,(">>> Won election on %s %s <<<\n",
 501                            work->work_group,inet_ntoa(d->bcast_ip)));
 502
 503                   work->RunningElection = False;
 504                   work->state = MST_NONE;
 505
 506                   become_master(d, work);
 507                 }
 508           }
 509         }
 510   }
 511 }
 512
 513
 514 /*******************************************************************
 515   work out if I win an election
 516   ******************************************************************/
 517 static BOOL win_election(struct work_record *work,int version,uint32 criterion,
 518                          int timeup,char *name)
 519 {
 520   int mytimeup = time(NULL) - StartupTime;
 521   uint32 mycriterion = work->ElectionCriterion;
 522
 523   DEBUG(4,("election comparison: %x:%x %x:%x %d:%d %s:%s\n",
 524            version,ELECTION_VERSION,
 525            criterion,mycriterion,
 526            timeup,mytimeup,
 527            name,myname));
 528
 529   if (version > ELECTION_VERSION) return(False);
 530   if (version < ELECTION_VERSION) return(True);
 531
 532   if (criterion > mycriterion) return(False);
 533   if (criterion < mycriterion) return(True);
 534
 535   if (timeup > mytimeup) return(False);
 536   if (timeup < mytimeup) return(True);
 537
 538   if (strcasecmp(myname,name) > 0) return(False);
 539
 540   return(True);
 541 }
 542
 543
 544 /*******************************************************************
 545   process a election packet
 546
 547   An election dynamically decides who will be the master.
 548   ******************************************************************/
 549 void process_election(struct packet_struct *p,char *buf)
 550 {
 551   struct dgram_packet *dgram = &p->packet.dgram;
 552   struct in_addr ip = dgram->header.source_ip;
 553   struct subnet_record *d = find_subnet(ip);
 554   int version = CVAL(buf,0);
 555   uint32 criterion = IVAL(buf,1);
 556   int timeup = IVAL(buf,5)/1000;
 557   char *name = buf+13;
 558   struct work_record *work;
 559
 560   if (!d) return;
 561
 562   if (ip_equal(d->bcast_ip,ipgrp)) {
 563     DEBUG(3,("Unexpected election request from %s %s on WINS net\n",
 564              name, inet_ntoa(p->ip)));
 565     return;
 566   }
 567
 568   name[15] = 0;
 569
 570   DEBUG(3,("Election request from %s %s vers=%d criterion=%08x timeup=%d\n",
 571            name,inet_ntoa(p->ip),version,criterion,timeup));
 572
 573   if (same_context(dgram)) return;
 574
 575   for (work = d->workgrouplist; work; work = work->next)
 576     {
 577       if (!strequal(work->work_group, lp_workgroup()))
 578         continue;
 579
 580       if (win_election(work, version,criterion,timeup,name)) {
 581         if (!work->RunningElection) {
 582           work->needelection = True;
 583           work->ElectionCount=0;
 584           work->state = MST_NONE;
 585         }
 586       } else {
 587         work->needelection = False;
 588
 589         if (work->RunningElection || AM_MASTER(work)) {
 590           work->RunningElection = False;
 591           DEBUG(3,(">>> Lost election on %s %s <<<\n",
 592                    work->work_group,inet_ntoa(d->bcast_ip)));
 593           if (AM_MASTER(work))
 594             become_nonmaster(d, work,
 595                              SV_TYPE_MASTER_BROWSER|
 596                              SV_TYPE_DOMAIN_MASTER);
 597         }
 598       }
 599     }
 600 }
 601
 602
 603 /****************************************************************************
 604   checks whether a browser election is to be run on any workgroup
 605
 606   this function really ought to return the time between election
 607   packets (which depends on whether samba intends to be a domain
 608   master or a master browser) in milliseconds.
 609
 610   ***************************************************************************/
 611 BOOL check_elections(void)
 612 {
 613   struct subnet_record *d;
 614   BOOL run_any_election = False;
 615
 616   for (d = subnetlist; d; d = d->next)
 617     {
 618       struct work_record *work;
 619       for (work = d->workgrouplist; work; work = work->next)
 620         {
 621           run_any_election |= work->RunningElection;
 622
 623           if (work->needelection && !work->RunningElection)
 624             {
 625               DEBUG(3,(">>> Starting election on %s %s <<<\n",
 626                        work->work_group,inet_ntoa(d->bcast_ip)));
 627               work->ElectionCount = 0;
 628               work->RunningElection = True;
 629               work->needelection = False;
 630             }
 631         }
 632     }
 633   return run_any_election;
 634 }
 635