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