source3/nmbd/nmbd.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) Jeremy Allison 1997-2002
   6    Copyright (C) Jelmer Vernooij 2002,2003 (Conversion to popt)
   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
  25 int ClientNMB       = -1;
  26 int ClientDGRAM     = -1;
  27 int global_nmb_port = -1;
  28
  29 extern bool rescan_listen_set;
  30 extern bool global_in_nmbd;
  31
  32 extern bool override_logfile;
  33
  34 /* have we found LanMan clients yet? */
  35 bool found_lm_clients = False;
  36
  37 /* what server type are we currently */
  38
  39 time_t StartupTime = 0;
  40
  41 struct event_context *nmbd_event_context(void)
  42 {
  43         static struct event_context *ctx;
  44
  45         if (!ctx && !(ctx = event_context_init(NULL))) {
  46                 smb_panic("Could not init nmbd event context");
  47         }
  48         return ctx;
  49 }
  50
  51 struct messaging_context *nmbd_messaging_context(void)
  52 {
  53         static struct messaging_context *ctx;
  54
  55         if (ctx == NULL) {
  56                 ctx = messaging_init(NULL, server_id_self(),
  57                                      nmbd_event_context());
  58         }
  59         if (ctx == NULL) {
  60                 DEBUG(0, ("Could not init nmbd messaging context.\n"));
  61         }
  62         return ctx;
  63 }
  64
  65 /**************************************************************************** **
  66  Handle a SIGTERM in band.
  67  **************************************************************************** */
  68
  69 static void terminate(void)
  70 {
  71         DEBUG(0,("Got SIGTERM: going down...\n"));
  72
  73         /* Write out wins.dat file if samba is a WINS server */
  74         wins_write_database(0,False);
  75
  76         /* Remove all SELF registered names from WINS */
  77         release_wins_names();
  78
  79         /* Announce all server entries as 0 time-to-live, 0 type. */
  80         announce_my_servers_removed();
  81
  82         /* If there was an async dns child - kill it. */
  83         kill_async_dns_child();
  84
  85         exit(0);
  86 }
  87
  88 /**************************************************************************** **
  89  Handle a SHUTDOWN message from smbcontrol.
  90  **************************************************************************** */
  91
  92 static void nmbd_terminate(struct messaging_context *msg,
  93                            void *private_data,
  94                            uint32_t msg_type,
  95                            struct server_id server_id,
  96                            DATA_BLOB *data)
  97 {
  98         terminate();
  99 }
 100
 101 /**************************************************************************** **
 102  Catch a SIGTERM signal.
 103  **************************************************************************** */
 104
 105 static SIG_ATOMIC_T got_sig_term;
 106
 107 static void sig_term(int sig)
 108 {
 109         got_sig_term = 1;
 110         sys_select_signal(SIGTERM);
 111 }
 112
 113 /**************************************************************************** **
 114  Catch a SIGHUP signal.
 115  **************************************************************************** */
 116
 117 static SIG_ATOMIC_T reload_after_sighup;
 118
 119 static void sig_hup(int sig)
 120 {
 121         reload_after_sighup = 1;
 122         sys_select_signal(SIGHUP);
 123 }
 124
 125 /**************************************************************************** **
 126  Possibly continue after a fault.
 127  **************************************************************************** */
 128
 129 static void fault_continue(void)
 130 {
 131         dump_core();
 132 }
 133
 134 /**************************************************************************** **
 135  Expire old names from the namelist and server list.
 136  **************************************************************************** */
 137
 138 static void expire_names_and_servers(time_t t)
 139 {
 140         static time_t lastrun = 0;
 141
 142         if ( !lastrun )
 143                 lastrun = t;
 144         if ( t < (lastrun + 5) )
 145                 return;
 146         lastrun = t;
 147
 148         /*
 149          * Expire any timed out names on all the broadcast
 150          * subnets and those registered with the WINS server.
 151          * (nmbd_namelistdb.c)
 152          */
 153
 154         expire_names(t);
 155
 156         /*
 157          * Go through all the broadcast subnets and for each
 158          * workgroup known on that subnet remove any expired
 159          * server names. If a workgroup has an empty serverlist
 160          * and has itself timed out then remove the workgroup.
 161          * (nmbd_workgroupdb.c)
 162          */
 163
 164         expire_workgroups_and_servers(t);
 165 }
 166
 167 /************************************************************************** **
 168  Reload the list of network interfaces.
 169  Doesn't return until a network interface is up.
 170  ************************************************************************** */
 171
 172 static void reload_interfaces(time_t t)
 173 {
 174         static time_t lastt;
 175         int n;
 176         bool print_waiting_msg = true;
 177         struct subnet_record *subrec;
 178
 179         if (t && ((t - lastt) < NMBD_INTERFACES_RELOAD)) {
 180                 return;
 181         }
 182
 183         lastt = t;
 184
 185         if (!interfaces_changed()) {
 186                 return;
 187         }
 188
 189   try_again:
 190
 191         /* the list of probed interfaces has changed, we may need to add/remove
 192            some subnets */
 193         load_interfaces();
 194
 195         /* find any interfaces that need adding */
 196         for (n=iface_count() - 1; n >= 0; n--) {
 197                 char str[INET6_ADDRSTRLEN];
 198                 const struct interface *iface = get_interface(n);
 199                 struct in_addr ip, nmask;
 200
 201                 if (!iface) {
 202                         DEBUG(2,("reload_interfaces: failed to get interface %d\n", n));
 203                         continue;
 204                 }
 205
 206                 /* Ensure we're only dealing with IPv4 here. */
 207                 if (iface->ip.ss_family != AF_INET) {
 208                         DEBUG(2,("reload_interfaces: "
 209                                 "ignoring non IPv4 interface.\n"));
 210                         continue;
 211                 }
 212
 213                 ip = ((struct sockaddr_in *)&iface->ip)->sin_addr;
 214                 nmask = ((struct sockaddr_in *)&iface->netmask)->sin_addr;
 215
 216                 /*
 217                  * We don't want to add a loopback interface, in case
 218                  * someone has added 127.0.0.1 for smbd, nmbd needs to
 219                  * ignore it here. JRA.
 220                  */
 221
 222                 if (is_loopback_addr((struct sockaddr *)&iface->ip)) {
 223                         DEBUG(2,("reload_interfaces: Ignoring loopback "
 224                                 "interface %s\n",
 225                                 print_sockaddr(str, sizeof(str), &iface->ip) ));
 226                         continue;
 227                 }
 228
 229                 for (subrec=subnetlist; subrec; subrec=subrec->next) {
 230                         if (ip_equal_v4(ip, subrec->myip) &&
 231                             ip_equal_v4(nmask, subrec->mask_ip)) {
 232                                 break;
 233                         }
 234                 }
 235
 236                 if (!subrec) {
 237                         /* it wasn't found! add it */
 238                         DEBUG(2,("Found new interface %s\n",
 239                                  print_sockaddr(str,
 240                                          sizeof(str), &iface->ip) ));
 241                         subrec = make_normal_subnet(iface);
 242                         if (subrec)
 243                                 register_my_workgroup_one_subnet(subrec);
 244                 }
 245         }
 246
 247         /* find any interfaces that need deleting */
 248         for (subrec=subnetlist; subrec; subrec=subrec->next) {
 249                 for (n=iface_count() - 1; n >= 0; n--) {
 250                         struct interface *iface = get_interface(n);
 251                         struct in_addr ip, nmask;
 252                         if (!iface) {
 253                                 continue;
 254                         }
 255                         /* Ensure we're only dealing with IPv4 here. */
 256                         if (iface->ip.ss_family != AF_INET) {
 257                                 DEBUG(2,("reload_interfaces: "
 258                                         "ignoring non IPv4 interface.\n"));
 259                                 continue;
 260                         }
 261                         ip = ((struct sockaddr_in *)&iface->ip)->sin_addr;
 262                         nmask = ((struct sockaddr_in *)&iface->netmask)->sin_addr;
 263                         if (ip_equal_v4(ip, subrec->myip) &&
 264                             ip_equal_v4(nmask, subrec->mask_ip)) {
 265                                 break;
 266                         }
 267                 }
 268                 if (n == -1) {
 269                         /* oops, an interface has disapeared. This is
 270                          tricky, we don't dare actually free the
 271                          interface as it could be being used, so
 272                          instead we just wear the memory leak and
 273                          remove it from the list of interfaces without
 274                          freeing it */
 275                         DEBUG(2,("Deleting dead interface %s\n",
 276                                  inet_ntoa(subrec->myip)));
 277                         close_subnet(subrec);
 278                 }
 279         }
 280
 281         rescan_listen_set = True;
 282
 283         /* We need to wait if there are no subnets... */
 284         if (FIRST_SUBNET == NULL) {
 285
 286                 if (print_waiting_msg) {
 287                         DEBUG(0,("reload_interfaces: "
 288                                 "No subnets to listen to. Waiting..\n"));
 289                         print_waiting_msg = false;
 290                 }
 291
 292                 /*
 293                  * Whilst we're waiting for an interface, allow SIGTERM to
 294                  * cause us to exit.
 295                  */
 296
 297                 BlockSignals(false, SIGTERM);
 298
 299                 /* We only count IPv4, non-loopback interfaces here. */
 300                 while (iface_count_v4_nl() == 0 && !got_sig_term) {
 301                         sleep(5);
 302                         load_interfaces();
 303                 }
 304
 305                 /*
 306                  * Handle termination inband.
 307                  */
 308
 309                 if (got_sig_term) {
 310                         got_sig_term = 0;
 311                         terminate();
 312                 }
 313
 314                 /*
 315                  * We got an interface, go back to blocking term.
 316                  */
 317
 318                 BlockSignals(true, SIGTERM);
 319                 goto try_again;
 320         }
 321 }
 322
 323 /**************************************************************************** **
 324  Reload the services file.
 325  **************************************************************************** */
 326
 327 static bool reload_nmbd_services(bool test)
 328 {
 329         bool ret;
 330
 331         set_remote_machine_name("nmbd", False);
 332
 333         if ( lp_loaded() ) {
 334                 const char *fname = lp_configfile();
 335                 if (file_exist(fname) && !strcsequal(fname,get_dyn_CONFIGFILE())) {
 336                         set_dyn_CONFIGFILE(fname);
 337                         test = False;
 338                 }
 339         }
 340
 341         if ( test && !lp_file_list_changed() )
 342                 return(True);
 343
 344         ret = lp_load(get_dyn_CONFIGFILE(), True , False, False, True);
 345
 346         /* perhaps the config filename is now set */
 347         if ( !test ) {
 348                 DEBUG( 3, ( "services not loaded\n" ) );
 349                 reload_nmbd_services( True );
 350         }
 351
 352         return(ret);
 353 }
 354
 355 /**************************************************************************** **
 356  * React on 'smbcontrol nmbd reload-config' in the same way as to SIGHUP
 357  **************************************************************************** */
 358
 359 static void msg_reload_nmbd_services(struct messaging_context *msg,
 360                                      void *private_data,
 361                                      uint32_t msg_type,
 362                                      struct server_id server_id,
 363                                      DATA_BLOB *data)
 364 {
 365         write_browse_list( 0, True );
 366         dump_all_namelists();
 367         reload_nmbd_services( True );
 368         reopen_logs();
 369         reload_interfaces(0);
 370 }
 371
 372 static void msg_nmbd_send_packet(struct messaging_context *msg,
 373                                  void *private_data,
 374                                  uint32_t msg_type,
 375                                  struct server_id src,
 376                                  DATA_BLOB *data)
 377 {
 378         struct packet_struct *p = (struct packet_struct *)data->data;
 379         struct subnet_record *subrec;
 380         struct sockaddr_storage ss;
 381         const struct sockaddr_storage *pss;
 382         const struct in_addr *local_ip;
 383
 384         DEBUG(10, ("Received send_packet from %d\n", procid_to_pid(&src)));
 385
 386         if (data->length != sizeof(struct packet_struct)) {
 387                 DEBUG(2, ("Discarding invalid packet length from %d\n",
 388                           procid_to_pid(&src)));
 389                 return;
 390         }
 391
 392         if ((p->packet_type != NMB_PACKET) &&
 393             (p->packet_type != DGRAM_PACKET)) {
 394                 DEBUG(2, ("Discarding invalid packet type from %d: %d\n",
 395                           procid_to_pid(&src), p->packet_type));
 396                 return;
 397         }
 398
 399         in_addr_to_sockaddr_storage(&ss, p->ip);
 400         pss = iface_ip((struct sockaddr *)&ss);
 401
 402         if (pss == NULL) {
 403                 DEBUG(2, ("Could not find ip for packet from %d\n",
 404                           procid_to_pid(&src)));
 405                 return;
 406         }
 407
 408         local_ip = &((const struct sockaddr_in *)pss)->sin_addr;
 409         subrec = FIRST_SUBNET;
 410
 411         p->fd = (p->packet_type == NMB_PACKET) ?
 412                 subrec->nmb_sock : subrec->dgram_sock;
 413
 414         for (subrec = FIRST_SUBNET; subrec != NULL;
 415              subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
 416                 if (ip_equal_v4(*local_ip, subrec->myip)) {
 417                         p->fd = (p->packet_type == NMB_PACKET) ?
 418                                 subrec->nmb_sock : subrec->dgram_sock;
 419                         break;
 420                 }
 421         }
 422
 423         if (p->packet_type == DGRAM_PACKET) {
 424                 p->port = 138;
 425                 p->packet.dgram.header.source_ip.s_addr = local_ip->s_addr;
 426                 p->packet.dgram.header.source_port = 138;
 427         }
 428
 429         send_packet(p);
 430 }
 431
 432 /**************************************************************************** **
 433  The main select loop.
 434  **************************************************************************** */
 435
 436 static void process(void)
 437 {
 438         bool run_election;
 439
 440         while( True ) {
 441                 time_t t = time(NULL);
 442                 TALLOC_CTX *frame = talloc_stackframe();
 443
 444                 /*
 445                  * Check all broadcast subnets to see if
 446                  * we need to run an election on any of them.
 447                  * (nmbd_elections.c)
 448                  */
 449
 450                 run_election = check_elections();
 451
 452                 /*
 453                  * Read incoming UDP packets.
 454                  * (nmbd_packets.c)
 455                  */
 456
 457                 if(listen_for_packets(run_election)) {
 458                         TALLOC_FREE(frame);
 459                         return;
 460                 }
 461
 462                 /*
 463                  * Handle termination inband.
 464                  */
 465
 466                 if (got_sig_term) {
 467                         got_sig_term = 0;
 468                         terminate();
 469                 }
 470
 471                 /*
 472                  * Process all incoming packets
 473                  * read above. This calls the success and
 474                  * failure functions registered when response
 475                  * packets arrrive, and also deals with request
 476                  * packets from other sources.
 477                  * (nmbd_packets.c)
 478                  */
 479
 480                 run_packet_queue();
 481
 482                 /*
 483                  * Run any elections - initiate becoming
 484                  * a local master browser if we have won.
 485                  * (nmbd_elections.c)
 486                  */
 487
 488                 run_elections(t);
 489
 490                 /*
 491                  * Send out any broadcast announcements
 492                  * of our server names. This also announces
 493                  * the workgroup name if we are a local
 494                  * master browser.
 495                  * (nmbd_sendannounce.c)
 496                  */
 497
 498                 announce_my_server_names(t);
 499
 500                 /*
 501                  * Send out any LanMan broadcast announcements
 502                  * of our server names.
 503                  * (nmbd_sendannounce.c)
 504                  */
 505
 506                 announce_my_lm_server_names(t);
 507
 508                 /*
 509                  * If we are a local master browser, periodically
 510                  * announce ourselves to the domain master browser.
 511                  * This also deals with syncronising the domain master
 512                  * browser server lists with ourselves as a local
 513                  * master browser.
 514                  * (nmbd_sendannounce.c)
 515                  */
 516
 517                 announce_myself_to_domain_master_browser(t);
 518
 519                 /*
 520                  * Fullfill any remote announce requests.
 521                  * (nmbd_sendannounce.c)
 522                  */
 523
 524                 announce_remote(t);
 525
 526                 /*
 527                  * Fullfill any remote browse sync announce requests.
 528                  * (nmbd_sendannounce.c)
 529                  */
 530
 531                 browse_sync_remote(t);
 532
 533                 /*
 534                  * Scan the broadcast subnets, and WINS client
 535                  * namelists and refresh any that need refreshing.
 536                  * (nmbd_mynames.c)
 537                  */
 538
 539                 refresh_my_names(t);
 540
 541                 /*
 542                  * Scan the subnet namelists and server lists and
 543                  * expire thos that have timed out.
 544                  * (nmbd.c)
 545                  */
 546
 547                 expire_names_and_servers(t);
 548
 549                 /*
 550                  * Write out a snapshot of our current browse list into
 551                  * the browse.dat file. This is used by smbd to service
 552                  * incoming NetServerEnum calls - used to synchronise
 553                  * browse lists over subnets.
 554                  * (nmbd_serverlistdb.c)
 555                  */
 556
 557                 write_browse_list(t, False);
 558
 559                 /*
 560                  * If we are a domain master browser, we have a list of
 561                  * local master browsers we should synchronise browse
 562                  * lists with (these are added by an incoming local
 563                  * master browser announcement packet). Expire any of
 564                  * these that are no longer current, and pull the server
 565                  * lists from each of these known local master browsers.
 566                  * (nmbd_browsesync.c)
 567                  */
 568
 569                 dmb_expire_and_sync_browser_lists(t);
 570
 571                 /*
 572                  * Check that there is a local master browser for our
 573                  * workgroup for all our broadcast subnets. If one
 574                  * is not found, start an election (which we ourselves
 575                  * may or may not participate in, depending on the
 576                  * setting of the 'local master' parameter.
 577                  * (nmbd_elections.c)
 578                  */
 579
 580                 check_master_browser_exists(t);
 581
 582                 /*
 583                  * If we are configured as a logon server, attempt to
 584                  * register the special NetBIOS names to become such
 585                  * (WORKGROUP<1c> name) on all broadcast subnets and
 586                  * with the WINS server (if used). If we are configured
 587                  * to become a domain master browser, attempt to register
 588                  * the special NetBIOS name (WORKGROUP<1b> name) to
 589                  * become such.
 590                  * (nmbd_become_dmb.c)
 591                  */
 592
 593                 add_domain_names(t);
 594
 595                 /*
 596                  * If we are a WINS server, do any timer dependent
 597                  * processing required.
 598                  * (nmbd_winsserver.c)
 599                  */
 600
 601                 initiate_wins_processing(t);
 602
 603                 /*
 604                  * If we are a domain master browser, attempt to contact the
 605                  * WINS server to get a list of all known WORKGROUPS/DOMAINS.
 606                  * This will only work to a Samba WINS server.
 607                  * (nmbd_browsesync.c)
 608                  */
 609
 610                 if (lp_enhanced_browsing())
 611                         collect_all_workgroup_names_from_wins_server(t);
 612
 613                 /*
 614                  * Go through the response record queue and time out or re-transmit
 615                  * and expired entries.
 616                  * (nmbd_packets.c)
 617                  */
 618
 619                 retransmit_or_expire_response_records(t);
 620
 621                 /*
 622                  * check to see if any remote browse sync child processes have completed
 623                  */
 624
 625                 sync_check_completion();
 626
 627                 /*
 628                  * regularly sync with any other DMBs we know about
 629                  */
 630
 631                 if (lp_enhanced_browsing())
 632                         sync_all_dmbs(t);
 633
 634                 /*
 635                  * clear the unexpected packet queue
 636                  */
 637
 638                 clear_unexpected(t);
 639
 640                 /*
 641                  * Reload the services file if we got a sighup.
 642                  */
 643
 644                 if(reload_after_sighup) {
 645                         DEBUG( 0, ( "Got SIGHUP dumping debug info.\n" ) );
 646                         msg_reload_nmbd_services(nmbd_messaging_context(),
 647                                                  NULL, MSG_SMB_CONF_UPDATED,
 648                                                  procid_self(), NULL);
 649
 650                         reload_after_sighup = 0;
 651                 }
 652
 653                 /* check for new network interfaces */
 654
 655                 reload_interfaces(t);
 656
 657                 /* free up temp memory */
 658                 TALLOC_FREE(frame);
 659         }
 660 }
 661
 662 /**************************************************************************** **
 663  Open the socket communication.
 664  **************************************************************************** */
 665
 666 static bool open_sockets(bool isdaemon, int port)
 667 {
 668         struct sockaddr_storage ss;
 669         const char *sock_addr = lp_socket_address();
 670
 671         /*
 672          * The sockets opened here will be used to receive broadcast
 673          * packets *only*. Interface specific sockets are opened in
 674          * make_subnet() in namedbsubnet.c. Thus we bind to the
 675          * address "0.0.0.0". The parameter 'socket address' is
 676          * now deprecated.
 677          */
 678
 679         if (!interpret_string_addr(&ss, sock_addr,
 680                                 AI_NUMERICHOST|AI_PASSIVE)) {
 681                 DEBUG(0,("open_sockets: unable to get socket address "
 682                         "from string %s", sock_addr));
 683                 return false;
 684         }
 685         if (ss.ss_family != AF_INET) {
 686                 DEBUG(0,("open_sockets: unable to use IPv6 socket"
 687                         "%s in nmbd\n",
 688                         sock_addr));
 689                 return false;
 690         }
 691
 692         if (isdaemon) {
 693                 ClientNMB = open_socket_in(SOCK_DGRAM, port,
 694                                            0, &ss,
 695                                            true);
 696         } else {
 697                 ClientNMB = 0;
 698         }
 699
 700         if (ClientNMB == -1) {
 701                 return false;
 702         }
 703
 704         ClientDGRAM = open_socket_in(SOCK_DGRAM, DGRAM_PORT,
 705                                            3, &ss,
 706                                            true);
 707
 708         if (ClientDGRAM == -1) {
 709                 if (ClientNMB != 0) {
 710                         close(ClientNMB);
 711                 }
 712                 return false;
 713         }
 714
 715         /* we are never interested in SIGPIPE */
 716         BlockSignals(True,SIGPIPE);
 717
 718         set_socket_options( ClientNMB,   "SO_BROADCAST" );
 719         set_socket_options( ClientDGRAM, "SO_BROADCAST" );
 720
 721         /* Ensure we're non-blocking. */
 722         set_blocking( ClientNMB, False);
 723         set_blocking( ClientDGRAM, False);
 724
 725         DEBUG( 3, ( "open_sockets: Broadcast sockets opened.\n" ) );
 726         return( True );
 727 }
 728
 729 /**************************************************************************** **
 730  main program
 731  **************************************************************************** */
 732
 733  int main(int argc, const char *argv[])
 734 {
 735         static bool is_daemon;
 736         static bool opt_interactive;
 737         static bool Fork = true;
 738         static bool no_process_group;
 739         static bool log_stdout;
 740         poptContext pc;
 741         char *p_lmhosts = NULL;
 742         int opt;
 743         enum {
 744                 OPT_DAEMON = 1000,
 745                 OPT_INTERACTIVE,
 746                 OPT_FORK,
 747                 OPT_NO_PROCESS_GROUP,
 748                 OPT_LOG_STDOUT
 749         };
 750         struct poptOption long_options[] = {
 751         POPT_AUTOHELP
 752         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon(default)" },
 753         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)" },
 754         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools & etc)" },
 755         {"no-process-group", 0, POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
 756         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
 757         {"hosts", 'H', POPT_ARG_STRING, &p_lmhosts, 'H', "Load a netbios hosts file"},
 758         {"port", 'p', POPT_ARG_INT, &global_nmb_port, NMB_PORT, "Listen on the specified port" },
 759         POPT_COMMON_SAMBA
 760         { NULL }
 761         };
 762         TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
 763
 764         load_case_tables();
 765
 766         global_nmb_port = NMB_PORT;
 767
 768         pc = poptGetContext("nmbd", argc, argv, long_options, 0);
 769         while ((opt = poptGetNextOpt(pc)) != -1) {
 770                 switch (opt) {
 771                 case OPT_DAEMON:
 772                         is_daemon = true;
 773                         break;
 774                 case OPT_INTERACTIVE:
 775                         opt_interactive = true;
 776                         break;
 777                 case OPT_FORK:
 778                         Fork = false;
 779                         break;
 780                 case OPT_NO_PROCESS_GROUP:
 781                         no_process_group = true;
 782                         break;
 783                 case OPT_LOG_STDOUT:
 784                         log_stdout = true;
 785                         break;
 786                 default:
 787                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
 788                                   poptBadOption(pc, 0), poptStrerror(opt));
 789                         poptPrintUsage(pc, stderr, 0);
 790                         exit(1);
 791                 }
 792         };
 793         poptFreeContext(pc);
 794
 795         global_in_nmbd = true;
 796
 797         StartupTime = time(NULL);
 798
 799         sys_srandom(time(NULL) ^ sys_getpid());
 800
 801         if (!override_logfile) {
 802                 char *lfile = NULL;
 803                 if (asprintf(&lfile, "%s/log.nmbd", get_dyn_LOGFILEBASE()) < 0) {
 804                         exit(1);
 805                 }
 806                 lp_set_logfile(lfile);
 807                 SAFE_FREE(lfile);
 808         }
 809
 810         fault_setup((void (*)(void *))fault_continue );
 811         dump_core_setup("nmbd");
 812
 813         /* POSIX demands that signals are inherited. If the invoking process has
 814          * these signals masked, we will have problems, as we won't receive them. */
 815         BlockSignals(False, SIGHUP);
 816         BlockSignals(False, SIGUSR1);
 817         BlockSignals(False, SIGTERM);
 818
 819         CatchSignal( SIGHUP,  SIGNAL_CAST sig_hup );
 820         CatchSignal( SIGTERM, SIGNAL_CAST sig_term );
 821
 822 #if defined(SIGFPE)
 823         /* we are never interested in SIGFPE */
 824         BlockSignals(True,SIGFPE);
 825 #endif
 826
 827         /* We no longer use USR2... */
 828 #if defined(SIGUSR2)
 829         BlockSignals(True, SIGUSR2);
 830 #endif
 831
 832         if ( opt_interactive ) {
 833                 Fork = False;
 834                 log_stdout = True;
 835         }
 836
 837         if ( log_stdout && Fork ) {
 838                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 839                 exit(1);
 840         }
 841
 842         setup_logging( argv[0], log_stdout );
 843
 844         reopen_logs();
 845
 846         DEBUG(0,("nmbd version %s started.\n", samba_version_string()));
 847         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
 848
 849         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
 850                 DEBUG(0, ("error opening config file\n"));
 851                 exit(1);
 852         }
 853
 854         if (nmbd_messaging_context() == NULL) {
 855                 return 1;
 856         }
 857
 858         if ( !reload_nmbd_services(False) )
 859                 return(-1);
 860
 861         if(!init_names())
 862                 return -1;
 863
 864         reload_nmbd_services( True );
 865
 866         if (strequal(lp_workgroup(),"*")) {
 867                 DEBUG(0,("ERROR: a workgroup name of * is no longer supported\n"));
 868                 exit(1);
 869         }
 870
 871         set_samba_nb_type();
 872
 873         if (!is_daemon && !is_a_socket(0)) {
 874                 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
 875                 is_daemon = True;
 876         }
 877
 878         if (is_daemon && !opt_interactive) {
 879                 DEBUG( 2, ( "Becoming a daemon.\n" ) );
 880                 become_daemon(Fork, no_process_group);
 881         }
 882
 883 #if HAVE_SETPGID
 884         /*
 885          * If we're interactive we want to set our own process group for
 886          * signal management.
 887          */
 888         if (opt_interactive && !no_process_group)
 889                 setpgid( (pid_t)0, (pid_t)0 );
 890 #endif
 891
 892         if (nmbd_messaging_context() == NULL) {
 893                 return 1;
 894         }
 895
 896 #ifndef SYNC_DNS
 897         /* Setup the async dns. We do it here so it doesn't have all the other
 898                 stuff initialised and thus chewing memory and sockets */
 899         if(lp_we_are_a_wins_server() && lp_dns_proxy()) {
 900                 start_async_dns();
 901         }
 902 #endif
 903
 904         if (!directory_exist(lp_lockdir())) {
 905                 mkdir(lp_lockdir(), 0755);
 906         }
 907
 908         pidfile_create("nmbd");
 909
 910         if (!reinit_after_fork(nmbd_messaging_context(),
 911                                nmbd_event_context(), false)) {
 912                 DEBUG(0,("reinit_after_fork() failed\n"));
 913                 exit(1);
 914         }
 915
 916         /* get broadcast messages */
 917         claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_DBWRAP);
 918
 919         messaging_register(nmbd_messaging_context(), NULL,
 920                            MSG_FORCE_ELECTION, nmbd_message_election);
 921 #if 0
 922         /* Until winsrepl is done. */
 923         messaging_register(nmbd_messaging_context(), NULL,
 924                            MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry);
 925 #endif
 926         messaging_register(nmbd_messaging_context(), NULL,
 927                            MSG_SHUTDOWN, nmbd_terminate);
 928         messaging_register(nmbd_messaging_context(), NULL,
 929                            MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services);
 930         messaging_register(nmbd_messaging_context(), NULL,
 931                            MSG_SEND_PACKET, msg_nmbd_send_packet);
 932
 933         TimeInit();
 934
 935         DEBUG( 3, ( "Opening sockets %d\n", global_nmb_port ) );
 936
 937         if ( !open_sockets( is_daemon, global_nmb_port ) ) {
 938                 kill_async_dns_child();
 939                 return 1;
 940         }
 941
 942         /* Determine all the IP addresses we have. */
 943         load_interfaces();
 944
 945         /* Create an nmbd subnet record for each of the above. */
 946         if( False == create_subnets() ) {
 947                 DEBUG(0,("ERROR: Failed when creating subnet lists. Exiting.\n"));
 948                 kill_async_dns_child();
 949                 exit(1);
 950         }
 951
 952         /* Load in any static local names. */
 953         if (p_lmhosts) {
 954                 set_dyn_LMHOSTSFILE(p_lmhosts);
 955         }
 956         load_lmhosts_file(get_dyn_LMHOSTSFILE());
 957         DEBUG(3,("Loaded hosts file %s\n", get_dyn_LMHOSTSFILE()));
 958
 959         /* If we are acting as a WINS server, initialise data structures. */
 960         if( !initialise_wins() ) {
 961                 DEBUG( 0, ( "nmbd: Failed when initialising WINS server.\n" ) );
 962                 kill_async_dns_child();
 963                 exit(1);
 964         }
 965
 966         /*
 967          * Register nmbd primary workgroup and nmbd names on all
 968          * the broadcast subnets, and on the WINS server (if specified).
 969          * Also initiate the startup of our primary workgroup (start
 970          * elections if we are setup as being able to be a local
 971          * master browser.
 972          */
 973
 974         if( False == register_my_workgroup_and_names() ) {
 975                 DEBUG(0,("ERROR: Failed when creating my my workgroup. Exiting.\n"));
 976                 kill_async_dns_child();
 977                 exit(1);
 978         }
 979
 980         /* We can only take signals in the select. */
 981         BlockSignals( True, SIGTERM );
 982
 983         TALLOC_FREE(frame);
 984         process();
 985
 986         if (dbf)
 987                 x_fclose(dbf);
 988         kill_async_dns_child();
 989         return(0);
 990 }