source3/nmbd/nmbd_elections.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    NBT netbios routines and daemon - version 2
   4    Copyright (C) Andrew Tridgell 1994-1998
   5    Copyright (C) Luke Kenneth Casson Leighton 1994-1998
   6    Copyright (C) Jeremy Allison 1994-2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 */
  22
  23 #include "includes.h"
  24 #include "nmbd/nmbd.h"
  25 #include "lib/util/string_wrappers.h"
  26
  27 /* Election parameters. */
  28 extern time_t StartupTime;
  29
  30 /****************************************************************************
  31   Send an election datagram packet.
  32 **************************************************************************/
  33
  34 static void send_election_dgram(struct subnet_record *subrec, const char *workgroup_name,
  35                                 uint32_t criterion, int timeup,const char *server_name)
  36 {
  37         char outbuf[1024];
  38         unstring srv_name;
  39         char *p;
  40
  41         DEBUG(2,("send_election_dgram: Sending election packet for workgroup %s on subnet %s\n",
  42                 workgroup_name, subrec->subnet_name ));
  43
  44         memset(outbuf,'\0',sizeof(outbuf));
  45         p = outbuf;
  46         SCVAL(p,0,ANN_Election); /* Election opcode. */
  47         p++;
  48
  49         SCVAL(p,0,((criterion == 0 && timeup == 0) ? 0 : ELECTION_VERSION));
  50         SIVAL(p,1,criterion);
  51         SIVAL(p,5,timeup*1000); /* ms - Despite what the spec says. */
  52         p += 13;
  53         unstrcpy(srv_name, server_name);
  54         if (!strupper_m(srv_name)) {
  55                 DEBUG(2,("strupper_m failed for %s\n", srv_name));
  56                 return;
  57         }
  58         /* The following call does UNIX -> DOS charset conversion. */
  59         push_ascii(p, srv_name, sizeof(outbuf)-PTR_DIFF(p,outbuf)-1, STR_TERMINATE);
  60         p = skip_string(outbuf,sizeof(outbuf),p);
  61
  62         send_mailslot(False, BROWSE_MAILSLOT, outbuf, PTR_DIFF(p,outbuf),
  63                 lp_netbios_name(), 0,
  64                 workgroup_name, 0x1e,
  65                 subrec->bcast_ip, subrec->myip, DGRAM_PORT);
  66 }
  67
  68 /*******************************************************************
  69  We found a current master browser on one of our broadcast interfaces.
  70 ******************************************************************/
  71
  72 static void check_for_master_browser_success(struct subnet_record *subrec,
  73                                  struct userdata_struct *userdata,
  74                                  struct nmb_name *answer_name,
  75                                  struct in_addr answer_ip, struct res_rec *rrec)
  76 {
  77         unstring aname;
  78         pull_ascii_nstring(aname, sizeof(aname), answer_name->name);
  79         DEBUG(3,("check_for_master_browser_success: Local master browser for workgroup %s exists at \
  80 IP %s (just checking).\n", aname, inet_ntoa(answer_ip) ));
  81 }
  82
  83 /*******************************************************************
  84  We failed to find a current master browser on one of our broadcast interfaces.
  85 ******************************************************************/
  86
  87 static void check_for_master_browser_fail( struct subnet_record *subrec,
  88                                            struct response_record *rrec,
  89                                            struct nmb_name *question_name,
  90                                            int fail_code)
  91 {
  92         unstring workgroup_name;
  93         struct work_record *work;
  94
  95         pull_ascii_nstring(workgroup_name,sizeof(workgroup_name),question_name->name);
  96
  97         work = find_workgroup_on_subnet(subrec, workgroup_name);
  98         if(work == NULL) {
  99                 DEBUG(0,("check_for_master_browser_fail: Unable to find workgroup %s on subnet %s.=\n",
 100                         workgroup_name, subrec->subnet_name ));
 101                 return;
 102         }
 103
 104         if (strequal(work->work_group, lp_workgroup())) {
 105
 106                 if (lp_local_master()) {
 107                         /* We have discovered that there is no local master
 108                                 browser, and we are configured to initiate
 109                                 an election that we will participate in.
 110                         */
 111                         DEBUG(2,("check_for_master_browser_fail: Forcing election on workgroup %s subnet %s\n",
 112                                 work->work_group, subrec->subnet_name ));
 113
 114                         /* Setting this means we will participate when the
 115                                 election is run in run_elections(). */
 116                         work->needelection = True;
 117                 } else {
 118                         /* We need to force an election, because we are configured
 119                                 not to become the local master, but we still need one,
 120                                 having detected that one doesn't exist.
 121                         */
 122                         send_election_dgram(subrec, work->work_group, 0, 0, "");
 123                 }
 124         }
 125 }
 126
 127 /*******************************************************************
 128   Ensure there is a local master browser for a workgroup on our
 129   broadcast interfaces.
 130 ******************************************************************/
 131
 132 void check_master_browser_exists(time_t t)
 133 {
 134         static time_t lastrun=0;
 135         struct subnet_record *subrec;
 136         const char *workgroup_name = lp_workgroup();
 137
 138         if (t < (lastrun + (CHECK_TIME_MST_BROWSE * 60)))
 139                 return;
 140
 141         lastrun = t;
 142
 143         dump_workgroups(False);
 144
 145         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
 146                 struct work_record *work;
 147
 148                 for (work = subrec->workgrouplist; work; work = work->next) {
 149                         if (strequal(work->work_group, workgroup_name) && !AM_LOCAL_MASTER_BROWSER(work)) {
 150                                 /* Do a name query for the local master browser on this net. */
 151                                 query_name( subrec, work->work_group, 0x1d,
 152                                         check_for_master_browser_success,
 153                                         check_for_master_browser_fail,
 154                                         NULL);
 155                         }
 156                 }
 157         }
 158 }
 159
 160 /*******************************************************************
 161   Run an election.
 162 ******************************************************************/
 163
 164 void run_elections(time_t t)
 165 {
 166         static time_t lastime = 0;
 167
 168         struct subnet_record *subrec;
 169
 170         /* Send election packets once every 2 seconds - note */
 171         if (lastime && (t - lastime < 2)) {
 172                 return;
 173         }
 174
 175         lastime = t;
 176
 177         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
 178                 struct work_record *work;
 179
 180                 for (work = subrec->workgrouplist; work; work = work->next) {
 181                         if (work->RunningElection) {
 182                                 /*
 183                                  * We can only run an election for a workgroup if we have
 184                                  * registered the WORKGROUP<1e> name, as that's the name
 185                                  * we must listen to.
 186                                  */
 187                                 struct nmb_name nmbname;
 188
 189                                 make_nmb_name(&nmbname, work->work_group, 0x1e);
 190                                 if(find_name_on_subnet( subrec, &nmbname, FIND_SELF_NAME)==NULL) {
 191                                         DEBUG(8,("run_elections: Cannot send election packet yet as name %s not \
 192 yet registered on subnet %s\n", nmb_namestr(&nmbname), subrec->subnet_name ));
 193                                         continue;
 194                                 }
 195
 196                                 send_election_dgram(subrec, work->work_group, work->ElectionCriterion,
 197                                                 t - StartupTime, lp_netbios_name());
 198
 199                                 if (work->ElectionCount++ >= 4) {
 200                                         /* Won election (4 packets were sent out uncontested. */
 201                                         DEBUG(2,("run_elections: >>> Won election for workgroup %s on subnet %s <<<\n",
 202                                                 work->work_group, subrec->subnet_name ));
 203
 204                                         work->RunningElection = False;
 205
 206                                         become_local_master_browser(subrec, work);
 207                                 }
 208                         }
 209                 }
 210         }
 211 }
 212
 213 /*******************************************************************
 214   Determine if I win an election.
 215 ******************************************************************/
 216
 217 static bool win_election(struct work_record *work, int version,
 218                          uint32_t criterion, int timeup, const char *server_name)
 219 {
 220         int mytimeup = time(NULL) - StartupTime;
 221         uint32_t mycriterion = work->ElectionCriterion;
 222
 223         /* If local master is false then never win in election broadcasts. */
 224         if(!lp_local_master()) {
 225                 DEBUG(3,("win_election: Losing election as local master == False\n"));
 226                 return False;
 227         }
 228
 229         DEBUG(4,("win_election: election comparison: %x:%x %x:%x %d:%d %s:%s\n",
 230                         version, ELECTION_VERSION,
 231                         criterion, mycriterion,
 232                         timeup, mytimeup,
 233                         server_name, lp_netbios_name()));
 234
 235         if (version > ELECTION_VERSION)
 236                 return(False);
 237         if (version < ELECTION_VERSION)
 238                 return(True);
 239
 240         if (criterion > mycriterion)
 241                 return(False);
 242         if (criterion < mycriterion)
 243                 return(True);
 244
 245         if (timeup > mytimeup)
 246                 return(False);
 247         if (timeup < mytimeup)
 248                 return(True);
 249
 250         if (strcasecmp_m(lp_netbios_name(), server_name) > 0)
 251                 return(False);
 252
 253         return(True);
 254 }
 255
 256 /*******************************************************************
 257   Process an incoming election datagram packet.
 258 ******************************************************************/
 259
 260 void process_election(struct subnet_record *subrec, struct packet_struct *p, const char *buf)
 261 {
 262         struct dgram_packet *dgram = &p->packet.dgram;
 263         int version = CVAL(buf,0);
 264         uint32_t criterion = IVAL(buf,1);
 265         int timeup = IVAL(buf,5)/1000;
 266         unstring server_name;
 267         struct work_record *work;
 268         unstring workgroup_name;
 269
 270         pull_ascii_nstring(server_name, sizeof(server_name), buf+13);
 271         pull_ascii_nstring(workgroup_name, sizeof(workgroup_name), dgram->dest_name.name);
 272
 273         server_name[15] = 0;
 274
 275         DEBUG(3,("process_election: Election request from %s at IP %s on subnet %s for workgroup %s.\n",
 276                 server_name,inet_ntoa(p->ip), subrec->subnet_name, workgroup_name ));
 277
 278         DEBUG(5,("process_election: vers=%d criterion=%08x timeup=%d\n", version,criterion,timeup));
 279
 280         if(( work = find_workgroup_on_subnet(subrec, workgroup_name)) == NULL) {
 281                 DEBUG(0,("process_election: Cannot find workgroup %s on subnet %s.\n",
 282                         workgroup_name, subrec->subnet_name ));
 283                 goto done;
 284         }
 285
 286         if (!strequal(work->work_group, lp_workgroup())) {
 287                 DEBUG(3,("process_election: ignoring election request for workgroup %s on subnet %s as this \
 288 is not my workgroup.\n", work->work_group, subrec->subnet_name ));
 289                 goto done;
 290         }
 291
 292         if (win_election(work, version,criterion,timeup,server_name)) {
 293                 /* We take precedence over the requesting server. */
 294                 if (!work->RunningElection) {
 295                         /* We weren't running an election - start running one. */
 296
 297                         work->needelection = True;
 298                         work->ElectionCount=0;
 299                 }
 300
 301                 /* Note that if we were running an election for this workgroup on this
 302                         subnet already, we just ignore the server we take precedence over. */
 303         } else {
 304                 /* We lost. Stop participating. */
 305                 work->needelection = False;
 306
 307                 if (work->RunningElection || AM_LOCAL_MASTER_BROWSER(work)) {
 308                         work->RunningElection = False;
 309                         DEBUG(3,("process_election: >>> Lost election for workgroup %s on subnet %s <<<\n",
 310                                 work->work_group, subrec->subnet_name ));
 311                         if (AM_LOCAL_MASTER_BROWSER(work))
 312                                 unbecome_local_master_browser(subrec, work, False);
 313                 }
 314         }
 315 done:
 316         return;
 317 }
 318
 319 /****************************************************************************
 320   This function looks over all the workgroups known on all the broadcast
 321   subnets and decides if a browser election is to be run on that workgroup.
 322   It returns True if any election packets need to be sent (this will then
 323   be done by run_elections().
 324 ***************************************************************************/
 325
 326 bool check_elections(void)
 327 {
 328         struct subnet_record *subrec;
 329         bool run_any_election = False;
 330
 331         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
 332                 struct work_record *work;
 333                 for (work = subrec->workgrouplist; work; work = work->next) {
 334                         if (work->RunningElection) {
 335                                 run_any_election = work->RunningElection;
 336                         }
 337
 338                         /*
 339                          * Start an election if we have any chance of winning.
 340                          * Note this is a change to the previous code, that would
 341                          * only run an election if nmbd was in the potential browser
 342                          * state. We need to run elections in any state if we're told
 343                          * to. JRA.
 344                          */
 345
 346                         if (work->needelection && !work->RunningElection && lp_local_master()) {
 347                                 /*
 348                                  * We can only run an election for a workgroup if we have
 349                                  * registered the WORKGROUP<1e> name, as that's the name
 350                                  * we must listen to.
 351                                  */
 352                                 struct nmb_name nmbname;
 353
 354                                 make_nmb_name(&nmbname, work->work_group, 0x1e);
 355                                 if(find_name_on_subnet( subrec, &nmbname, FIND_SELF_NAME)==NULL) {
 356                                         DEBUG(8,("check_elections: Cannot send election packet yet as name %s not \
 357 yet registered on subnet %s\n", nmb_namestr(&nmbname), subrec->subnet_name ));
 358                                         continue;
 359                                 }
 360
 361                                 DEBUG(3,("check_elections: >>> Starting election for workgroup %s on subnet %s <<<\n",
 362                                         work->work_group, subrec->subnet_name ));
 363
 364                                 work->ElectionCount = 0;
 365                                 work->RunningElection = True;
 366                                 work->needelection = False;
 367                         }
 368                 }
 369         }
 370         return run_any_election;
 371 }
 372
 373 /****************************************************************************
 374  Process a internal Samba message forcing an election.
 375 ***************************************************************************/
 376
 377 void nmbd_message_election(struct messaging_context *msg,
 378                            void *private_data,
 379                            uint32_t msg_type,
 380                            struct server_id server_id,
 381                            DATA_BLOB *data)
 382 {
 383         struct subnet_record *subrec;
 384
 385         for (subrec = FIRST_SUBNET; subrec; subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
 386                 struct work_record *work;
 387                 for (work = subrec->workgrouplist; work; work = work->next) {
 388                         if (strequal(work->work_group, lp_workgroup())) {
 389                                 work->needelection = True;
 390                                 work->ElectionCount=0;
 391                                 work->mst_state = lp_local_master() ? MST_POTENTIAL : MST_NONE;
 392                         }
 393                 }
 394         }
 395 }