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 /*******************************************************************
  56   occasionally check to see if the master browser is around
  57   ******************************************************************/
  58 void check_master_browser(time_t t)
  59 {
  60         static time_t lastrun=0;
  61         struct subnet_record *d;
  62
  63         if (!lastrun) lastrun = t;
  64         if (t < lastrun + CHECK_TIME_MST_BROWSE * 60) return;
  65
  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 (!AM_MASTER(work))
  77                         {
  78                                 if (lp_preferred_master())
  79                                 {
  80                                         /* preferred master - not a master browser.  force
  81                                            becoming a master browser, hence the log message.
  82                                          */
  83
  84                                         DEBUG(0,("%s preferred master for %s %s - force election\n",
  85                                                   timestring(), work->work_group,
  86                                                   inet_ntoa(d->bcast_ip)));
  87
  88                                         browser_gone(work->work_group, d->bcast_ip);
  89                                 }
  90                                 else
  91                                 {
  92                                         /* if we are not the browse master of a workgroup,
  93                                            and we can't find a browser on the subnet, do
  94                                            something about it.
  95                                          */
  96
  97                                         queue_netbios_packet(d,ClientNMB,NMB_QUERY,NAME_QUERY_MST_CHK,
  98                                                      work->work_group,0x1d,0,0,0,NULL,NULL,
  99                                                      True,False,d->bcast_ip,d->bcast_ip);
 100                                 }
 101                         }
 102                 }
 103         }
 104 }
 105
 106
 107 /*******************************************************************
 108   what to do if a master browser DOESN't exist
 109   ******************************************************************/
 110 void browser_gone(char *work_name, struct in_addr ip)
 111 {
 112   struct subnet_record *d = find_subnet(ip);
 113   struct work_record *work = find_workgroupstruct(d, work_name, False);
 114
 115   /* i don't know about this workgroup, therefore i don't care */
 116   if (!work || !d) return;
 117
 118   /* don't do election stuff on the WINS subnet */
 119   if (ip_equal(d->bcast_ip,ipgrp))
 120     return;
 121
 122   if (strequal(work->work_group, lp_workgroup()))
 123   {
 124
 125       DEBUG(2,("Forcing election on %s %s\n",
 126                work->work_group,inet_ntoa(d->bcast_ip)));
 127
 128       /* we can attempt to become master browser */
 129       work->needelection = True;
 130   }
 131   else
 132   {
 133      /* local interfaces: force an election */
 134     send_election(d, work->work_group, 0, 0, myname);
 135
 136      /* only removes workgroup completely on a local interface
 137         persistent lmhosts entries on a local interface _will_ be removed).
 138       */
 139      remove_workgroup(d, work,True);
 140   }
 141 }
 142
 143
 144 /****************************************************************************
 145   send an election packet
 146   **************************************************************************/
 147 void send_election(struct subnet_record *d, char *group,uint32 criterion,
 148                    int timeup,char *name)
 149 {
 150   pstring outbuf;
 151   char *p;
 152
 153   if (!d) return;
 154
 155   DEBUG(2,("Sending election to %s for workgroup %s\n",
 156            inet_ntoa(d->bcast_ip),group));
 157
 158   bzero(outbuf,sizeof(outbuf));
 159   p = outbuf;
 160   CVAL(p,0) = ANN_Election; /* election */
 161   p++;
 162
 163   CVAL(p,0) = (criterion == 0 && timeup == 0) ? 0 : ELECTION_VERSION;
 164   SIVAL(p,1,criterion);
 165   SIVAL(p,5,timeup*1000); /* ms - despite the spec */
 166   p += 13;
 167   strcpy(p,name);
 168   strupper(p);
 169   p = skip_string(p,1);
 170
 171   send_mailslot_reply(False,BROWSE_MAILSLOT,ClientDGRAM,
 172               outbuf,PTR_DIFF(p,outbuf),
 173                       name,group,0,0x1e,d->bcast_ip,*iface_ip(d->bcast_ip));
 174 }
 175
 176
 177 /****************************************************************************
 178   un-register a SELF name that got rejected.
 179
 180   if this name happens to be rejected when samba is in the process
 181   of becoming a master browser (registering __MSBROWSE__, WORKGROUP(1d)
 182   or WORKGROUP(1b)) then we must stop being a master browser. sad.
 183
 184   **************************************************************************/
 185 void name_unregister_work(struct subnet_record *d, char *name, int name_type)
 186 {
 187     struct work_record *work;
 188     int remove_type_local  = 0;
 189     int remove_type_domain = 0;
 190     int remove_type_logon  = 0;
 191
 192     remove_netbios_name(d,name,name_type,SELF,ipzero);
 193
 194     if (!(work = find_workgroupstruct(d, name, False))) return;
 195
 196     /* work out what to unbecome, from the name type being removed */
 197
 198     if (ms_browser_name(name, name_type))
 199     {
 200       remove_type_local |= SV_TYPE_MASTER_BROWSER;
 201     }
 202     if (AM_MASTER(work) && strequal(name, lp_workgroup()) == 0 &&
 203          name_type == 0x1d)
 204     {
 205       remove_type_local |= SV_TYPE_MASTER_BROWSER;
 206     }
 207     if (AM_DOMMST(work) && strequal(name, lp_workgroup()) == 0 &&
 208          name_type == 0x1b)
 209     {
 210       remove_type_domain |= SV_TYPE_DOMAIN_MASTER;
 211     }
 212     if (AM_DOMMEM(work) && strequal(name, lp_workgroup()) == 0 &&
 213          name_type == 0x1c)
 214     {
 215       remove_type_logon|= SV_TYPE_DOMAIN_MEMBER;
 216     }
 217
 218     if (remove_type_local ) unbecome_local_master (d, work, remove_type_local );
 219     if (remove_type_domain) unbecome_domain_master(d, work, remove_type_domain);
 220     if (remove_type_logon ) unbecome_logon_server (d, work, remove_type_logon );
 221 }
 222
 223
 224 /****************************************************************************
 225   registers a name.
 226
 227   if the name being added is a SELF name, we must additionally check
 228   whether to proceed to the next stage in samba becoming a master browser.
 229
 230   **************************************************************************/
 231 void name_register_work(struct subnet_record *d, char *name, int name_type,
 232                                 int nb_flags, time_t ttl, struct in_addr ip, BOOL bcast)
 233 {
 234         enum name_source source = (ismyip(ip) || ip_equal(ip, ipzero)) ?
 235                                   SELF : REGISTER;
 236
 237         if (source == SELF)
 238         {
 239                 struct work_record *work = find_workgroupstruct(d, lp_workgroup(), False);
 240
 241                 add_netbios_entry(d,name,name_type,nb_flags,ttl,source,ip,True,!bcast);
 242
 243                 if (work)
 244                 {
 245                         int add_type_local  = False;
 246                         int add_type_domain = False;
 247                         int add_type_logon  = False;
 248
 249                         /* work out what to become, from the name type being added */
 250
 251                         if (ms_browser_name(name, name_type))
 252                         {
 253                                 add_type_local = True;
 254                         }
 255                         if (strequal(name, lp_workgroup()) == 0 && name_type == 0x1d)
 256                         {
 257                                 add_type_local = True;
 258                         }
 259                         if (strequal(name, lp_workgroup()) == 0 && name_type == 0x1b)
 260                         {
 261                                 add_type_domain = True;
 262                         }
 263                         if (strequal(name, lp_workgroup()) == 0 && name_type == 0x1c)
 264                         {
 265                                 add_type_logon = True;
 266                         }
 267
 268                         if (add_type_local ) become_local_master (d, work);
 269                         if (add_type_domain) become_domain_master(d, work);
 270                         if (add_type_logon ) become_logon_server (d, work);
 271                 }
 272         }
 273 }
 274
 275
 276 /*******************************************************************
 277   become the local master browser.
 278
 279   this is done in stages. note that this could take a while,
 280   particularly on a broadcast subnet, as we have to wait for
 281   the implicit registration of each name to be accepted.
 282
 283   as each name is successfully registered, become_local_master() is
 284   called again, in order to initiate the next stage. see
 285   dead_netbios_entry() - deals with implicit name registration
 286   and response_name_reg() - deals with explicit registration
 287   with a WINS server.
 288
 289   stage 1: was MST_POTENTIAL - go to MST_POTENTIAL and register ^1^2__MSBROWSE__^2^1.
 290   stage 2: was MST_BACK  - go to MST_MSB  and register WORKGROUP(0x1d)
 291   stage 3: was MST_MSB  - go to MST_BROWSER and stay there
 292
 293   XXXX note: this code still does not cope with the distinction
 294   between different types of nodes, particularly between M and P
 295   nodes. that comes later.
 296
 297   ******************************************************************/
 298 void become_local_master(struct subnet_record *d, struct work_record *work)
 299 {
 300   /* domain type must be limited to domain enum + server type. it must
 301      not have SV_TYPE_SERVER or anything else with SERVER in it, else
 302      clients get confused and start thinking this entry is a server
 303      not a workgroup
 304    */
 305   uint32 domain_type = SV_TYPE_DOMAIN_ENUM|SV_TYPE_NT;
 306
 307   if (!work || !d) return;
 308
 309   DEBUG(2,("Becoming master for %s %s (currently at stage %d)\n",
 310                                         work->work_group,inet_ntoa(d->bcast_ip),work->mst_state));
 311
 312   switch (work->mst_state)
 313   {
 314     case MST_POTENTIAL: /* while we were nothing but a server... */
 315     {
 316       DEBUG(3,("go to first stage: register ^1^2__MSBROWSE__^2^1\n"));
 317       work->mst_state = MST_BACK; /* ... an election win was successful */
 318
 319       work->ElectionCriterion |= 0x5;
 320
 321       /* update our server status */
 322       work->ServerType &= ~SV_TYPE_POTENTIAL_BROWSER;
 323       add_server_entry(d,work,myname,work->ServerType,0,lp_serverstring(),True);
 324
 325       /* add special browser name */
 326       add_my_name_entry(d,MSBROWSE        ,0x01,nb_type|NB_ACTIVE|NB_GROUP);
 327
 328       /* DON'T do anything else after calling add_my_name_entry() */
 329       break;
 330     }
 331
 332     case MST_BACK: /* while nothing had happened except we won an election... */
 333     {
 334       DEBUG(3,("go to second stage: register as master browser\n"));
 335       work->mst_state = MST_MSB; /* ... registering MSBROWSE was successful */
 336
 337       /* add server entry on successful registration of MSBROWSE */
 338       add_server_entry(d,work,work->work_group,domain_type,0,myname,True);
 339
 340       /* add master name */
 341       add_my_name_entry(d,work->work_group,0x1d,nb_type|NB_ACTIVE);
 342
 343       /* DON'T do anything else after calling add_my_name_entry() */
 344       break;
 345     }
 346
 347     case MST_MSB: /* while we were still only registered MSBROWSE state... */
 348     {
 349       DEBUG(3,("2nd stage complete: registered as master browser\n"));
 350       work->mst_state = MST_BROWSER; /* ... registering WORKGROUP(1d) succeeded */
 351
 352       /* update our server status */
 353       work->ServerType |= SV_TYPE_MASTER_BROWSER;
 354       add_server_entry(d,work,myname,work->ServerType,0,lp_serverstring(),True);
 355
 356       if (work->serverlist == NULL) /* no servers! */
 357       {
 358         /* ask all servers on our local net to announce to us */
 359         /* XXXX OOPS! add_server_entry will always add one entry - our own. */
 360         announce_request(work, d->bcast_ip);
 361       }
 362       break;
 363     }
 364
 365     case MST_BROWSER:
 366     {
 367       /* don't have to do anything: just report success */
 368       DEBUG(3,("3rd stage: become master browser!\n"));
 369
 370       break;
 371     }
 372   }
 373 }
 374
 375
 376 /*******************************************************************
 377   become the domain master browser.
 378
 379   this is done in stages. note that this could take a while,
 380   particularly on a broadcast subnet, as we have to wait for
 381   the implicit registration of each name to be accepted.
 382
 383   as each name is successfully registered, become_domain_master() is
 384   called again, in order to initiate the next stage. see
 385   dead_netbios_entry() - deals with implicit name registration
 386   and response_name_reg() - deals with explicit registration
 387   with a WINS server.
 388
 389   stage 1: was DOMAIN_NONE - go to DOMAIN_MST
 390
 391   XXXX note: this code still does not cope with the distinction
 392   between different types of nodes, particularly between M and P
 393   nodes. that comes later.
 394
 395   ******************************************************************/
 396 void become_domain_master(struct subnet_record *d, struct work_record *work)
 397 {
 398   /* domain type must be limited to domain enum + server type. it must
 399      not have SV_TYPE_SERVER or anything else with SERVER in it, else
 400      clients get confused and start thinking this entry is a server
 401      not a workgroup
 402    */
 403
 404   if (!work || !d) return;
 405
 406   DEBUG(2,("Becoming domain master for %s %s (currently at stage %d)\n",
 407                                         work->work_group,inet_ntoa(d->bcast_ip),work->dom_state));
 408
 409   switch (work->dom_state)
 410   {
 411     case DOMAIN_NONE: /* while we were nothing but a server... */
 412     {
 413       if (lp_domain_master())
 414       {
 415                   DEBUG(3,("go to first stage: register <1b> name\n"));
 416                   work->dom_state = DOMAIN_WAIT;
 417
 418                   /* XXXX the 0x1b is domain master browser name */
 419                   add_my_name_entry(d, lp_workgroup(),0x1b,nb_type|NB_ACTIVE|NB_GROUP);
 420
 421                   /* DON'T do anything else after calling add_my_name_entry() */
 422                   break;
 423       }
 424       else
 425       {
 426         DEBUG(4,("samba not configured as a domain master.\n"));
 427       }
 428
 429       break;
 430     }
 431
 432    case DOMAIN_WAIT:
 433    {
 434       if (lp_domain_master())
 435       {
 436         work->dom_state = DOMAIN_MST; /* ... become domain master */
 437         DEBUG(3,("domain first stage: register as domain member\n"));
 438
 439         /* update our server status */
 440         work->ServerType |= SV_TYPE_NT|SV_TYPE_DOMAIN_MASTER;
 441         add_server_entry(d,work,myname,work->ServerType,0,
 442                          lp_serverstring(),True);
 443
 444         DEBUG(4,("samba is now a domain master\n"));
 445
 446         break;
 447       }
 448       else
 449       {
 450         DEBUG(4,("samba not configured as a domain master.\n"));
 451       }
 452
 453       break;
 454    }
 455
 456     case DOMAIN_MST:
 457     {
 458       /* don't have to do anything: just report success */
 459       DEBUG(3,("domain second stage: there isn't one!\n"));
 460       break;
 461     }
 462   }
 463 }
 464
 465
 466 /*******************************************************************
 467   become a logon server.
 468   ******************************************************************/
 469 void become_logon_server(struct subnet_record *d, struct work_record *work)
 470 {
 471   if (!work || !d) return;
 472
 473   DEBUG(2,("Becoming logon server for %s %s (currently at stage %d)\n",
 474                                         work->work_group,inet_ntoa(d->bcast_ip),work->log_state));
 475
 476   switch (work->log_state)
 477   {
 478     case LOGON_NONE: /* while we were nothing but a server... */
 479     {
 480       if (lp_domain_logons())
 481       {
 482                   DEBUG(3,("go to first stage: register <1c> name\n"));
 483                   work->log_state = LOGON_WAIT;
 484
 485           /* XXXX the 0x1c is apparently something to do with domain logons */
 486           add_my_name_entry(d, lp_workgroup(),0x1c,nb_type|NB_ACTIVE|NB_GROUP);
 487
 488                   /* DON'T do anything else after calling add_my_name_entry() */
 489                   break;
 490       }
 491       {
 492         DEBUG(4,("samba not configured as a logon master.\n"));
 493       }
 494
 495       break;
 496     }
 497
 498    case LOGON_WAIT:
 499    {
 500       if (lp_domain_logons())
 501       {
 502         work->log_state = LOGON_SRV; /* ... become logon server */
 503         DEBUG(3,("logon second stage: register \n"));
 504
 505         /* update our server status */
 506         work->ServerType |= SV_TYPE_NT|SV_TYPE_DOMAIN_MEMBER;
 507         add_server_entry(d,work,myname,work->ServerType,0,
 508                          lp_serverstring(),True);
 509
 510         /* DON'T do anything else after calling add_my_name_entry() */
 511         break;
 512       }
 513       else
 514       {
 515         DEBUG(4,("samba not configured as a logon server.\n"));
 516       }
 517
 518       break;
 519    }
 520
 521    case LOGON_SRV:
 522    {
 523       DEBUG(3,("logon third stage: there isn't one!\n"));
 524       break;
 525    }
 526
 527   }
 528 }
 529
 530
 531 /*******************************************************************
 532   unbecome the local master browser. initates removal of necessary netbios
 533   names, and tells the world that we are no longer a master browser.
 534
 535   XXXX this _should_ be used to demote to a backup master browser, without
 536   going straight to non-master browser.  another time.
 537
 538   ******************************************************************/
 539 void unbecome_local_master(struct subnet_record *d, struct work_record *work,
 540                                 int remove_type)
 541 {
 542   int new_server_type = work->ServerType;
 543
 544   /* can only remove master types with this function */
 545   remove_type &= SV_TYPE_MASTER_BROWSER;
 546
 547   new_server_type &= ~remove_type;
 548
 549   if (remove_type)
 550   {
 551     DEBUG(2,("Becoming local non-master for %s\n",work->work_group));
 552
 553     /* no longer a master browser of any sort */
 554
 555     work->ServerType |= SV_TYPE_POTENTIAL_BROWSER;
 556     work->ElectionCriterion &= ~0x4;
 557     work->mst_state = MST_POTENTIAL;
 558
 559         /* announce ourselves as no longer active as a master browser. */
 560     announce_server(d, work, work->work_group, myname, 0, 0);
 561     remove_name_entry(d,MSBROWSE        ,0x01);
 562     remove_name_entry(d,work->work_group,0x1d);
 563   }
 564 }
 565
 566
 567 /*******************************************************************
 568   unbecome the domain master browser. initates removal of necessary netbios
 569   names, and tells the world that we are no longer a domain browser.
 570   ******************************************************************/
 571 void unbecome_domain_master(struct subnet_record *d, struct work_record *work,
 572                                 int remove_type)
 573 {
 574   int new_server_type = work->ServerType;
 575
 576   DEBUG(2,("Becoming domain non-master for %s\n",work->work_group));
 577
 578   /* can only remove master or domain types with this function */
 579   remove_type &= SV_TYPE_DOMAIN_MASTER;
 580
 581   new_server_type &= ~remove_type;
 582
 583   if (remove_type)
 584   {
 585     /* no longer a domain master browser of any sort */
 586
 587     work->dom_state = DOMAIN_NONE;
 588
 589         /* announce ourselves as no longer active as a master browser. */
 590     announce_server(d, work, work->work_group, myname, 0, 0);
 591     remove_name_entry(d,work->work_group,0x1b);
 592   }
 593 }
 594
 595
 596 /*******************************************************************
 597   unbecome the logon server. initates removal of necessary netbios
 598   names, and tells the world that we are no longer a logon server.
 599   ******************************************************************/
 600 void unbecome_logon_server(struct subnet_record *d, struct work_record *work,
 601                                 int remove_type)
 602 {
 603   int new_server_type = work->ServerType;
 604
 605   DEBUG(2,("Becoming logon non-server for %s\n",work->work_group));
 606
 607   /* can only remove master or domain types with this function */
 608   remove_type &= SV_TYPE_DOMAIN_MEMBER;
 609
 610   new_server_type &= ~remove_type;
 611
 612   if (remove_type)
 613   {
 614     /* no longer a master browser of any sort */
 615
 616     work->log_state = LOGON_NONE;
 617
 618         /* announce ourselves as no longer active as a master browser. */
 619     announce_server(d, work, work->work_group, myname, 0, 0);
 620     remove_name_entry(d,work->work_group,0x1c);
 621   }
 622 }
 623
 624
 625 /*******************************************************************
 626   run the election
 627   ******************************************************************/
 628 void run_elections(time_t t)
 629 {
 630   static time_t lastime = 0;
 631
 632   struct subnet_record *d;
 633
 634   /* send election packets once a second */
 635   if (lastime && t-lastime <= 0) return;
 636
 637   lastime = t;
 638
 639   for (d = subnetlist; d; d = d->next)
 640   {
 641     struct work_record *work;
 642     for (work = d->workgrouplist; work; work = work->next)
 643         {
 644           if (work->RunningElection)
 645           {
 646             send_election(d,work->work_group, work->ElectionCriterion,
 647                             t-StartupTime,myname);
 648
 649             if (work->ElectionCount++ >= 4)
 650                 {
 651                   /* I won! now what :-) */
 652                   DEBUG(2,(">>> Won election on %s %s <<<\n",
 653                            work->work_group,inet_ntoa(d->bcast_ip)));
 654
 655                   work->RunningElection = False;
 656                   work->mst_state = MST_POTENTIAL;
 657
 658                   become_local_master(d, work);
 659                 }
 660           }
 661         }
 662   }
 663 }
 664
 665
 666 /*******************************************************************
 667   work out if I win an election
 668   ******************************************************************/
 669 static BOOL win_election(struct work_record *work,int version,uint32 criterion,
 670                          int timeup,char *name)
 671 {
 672   int mytimeup = time(NULL) - StartupTime;
 673   uint32 mycriterion = work->ElectionCriterion;
 674
 675   DEBUG(4,("election comparison: %x:%x %x:%x %d:%d %s:%s\n",
 676            version,ELECTION_VERSION,
 677            criterion,mycriterion,
 678            timeup,mytimeup,
 679            name,myname));
 680
 681   if (version > ELECTION_VERSION) return(False);
 682   if (version < ELECTION_VERSION) return(True);
 683
 684   if (criterion > mycriterion) return(False);
 685   if (criterion < mycriterion) return(True);
 686
 687   if (timeup > mytimeup) return(False);
 688   if (timeup < mytimeup) return(True);
 689
 690   if (strcasecmp(myname,name) > 0) return(False);
 691
 692   return(True);
 693 }
 694
 695
 696 /*******************************************************************
 697   process a election packet
 698
 699   An election dynamically decides who will be the master.
 700   ******************************************************************/
 701 void process_election(struct packet_struct *p,char *buf)
 702 {
 703   struct dgram_packet *dgram = &p->packet.dgram;
 704   struct in_addr ip = dgram->header.source_ip;
 705   struct subnet_record *d = find_subnet(ip);
 706   int version = CVAL(buf,0);
 707   uint32 criterion = IVAL(buf,1);
 708   int timeup = IVAL(buf,5)/1000;
 709   char *name = buf+13;
 710   struct work_record *work;
 711
 712   if (!d) return;
 713
 714   if (ip_equal(d->bcast_ip,ipgrp)) {
 715     DEBUG(3,("Unexpected election request from %s %s on WINS net\n",
 716              name, inet_ntoa(p->ip)));
 717     return;
 718   }
 719
 720   name[15] = 0;
 721
 722   DEBUG(3,("Election request from %s %s vers=%d criterion=%08x timeup=%d\n",
 723            name,inet_ntoa(p->ip),version,criterion,timeup));
 724
 725   if (same_context(dgram)) return;
 726
 727   for (work = d->workgrouplist; work; work = work->next)
 728     {
 729       if (!strequal(work->work_group, lp_workgroup()))
 730         continue;
 731
 732       if (win_election(work, version,criterion,timeup,name)) {
 733         if (!work->RunningElection) {
 734           work->needelection = True;
 735           work->ElectionCount=0;
 736           work->mst_state = MST_POTENTIAL;
 737         }
 738       } else {
 739         work->needelection = False;
 740
 741         if (work->RunningElection || AM_MASTER(work)) {
 742           work->RunningElection = False;
 743           DEBUG(3,(">>> Lost election on %s %s <<<\n",
 744                    work->work_group,inet_ntoa(d->bcast_ip)));
 745           if (AM_MASTER(work))
 746             unbecome_local_master(d, work, SV_TYPE_MASTER_BROWSER);
 747         }
 748       }
 749     }
 750 }
 751
 752
 753 /****************************************************************************
 754   checks whether a browser election is to be run on any workgroup
 755
 756   this function really ought to return the time between election
 757   packets (which depends on whether samba intends to be a domain
 758   master or a master browser) in milliseconds.
 759
 760   ***************************************************************************/
 761 BOOL check_elections(void)
 762 {
 763   struct subnet_record *d;
 764   BOOL run_any_election = False;
 765
 766   for (d = subnetlist; d; d = d->next)
 767     {
 768       struct work_record *work;
 769       for (work = d->workgrouplist; work; work = work->next)
 770         {
 771           run_any_election |= work->RunningElection;
 772
 773           if (work->needelection && !work->RunningElection)
 774             {
 775               DEBUG(3,(">>> Starting election on %s %s <<<\n",
 776                        work->work_group,inet_ntoa(d->bcast_ip)));
 777               work->ElectionCount = 0;
 778               work->RunningElection = True;
 779               work->needelection = False;
 780             }
 781         }
 782     }
 783   return run_any_election;
 784 }
 785