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