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 && !(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         struct subnet_record *subrec;
 174
 175         if (t && ((t - lastt) < NMBD_INTERFACES_RELOAD)) {
 176                 return;
 177         }
 178
 179         lastt = t;
 180
 181         if (!interfaces_changed()) {
 182                 return;
 183         }
 184
 185   try_again:
 186
 187         /* the list of probed interfaces has changed, we may need to add/remove
 188            some subnets */
 189         load_interfaces();
 190
 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                 DEBUG(0,("reload_interfaces: "
 284                         "No subnets to listen to. Waiting..\n"));
 285
 286                 /*
 287                  * Whilst we're waiting for an interface, allow SIGTERM to
 288                  * cause us to exit.
 289                  */
 290
 291                 BlockSignals(false, SIGTERM);
 292
 293                 /* We only count IPv4 interfaces here. */
 294                 while (iface_count_v4() == 0 && !got_sig_term) {
 295                         sleep(5);
 296                         load_interfaces();
 297                 }
 298
 299                 /*
 300                  * Handle termination inband.
 301                  */
 302
 303                 if (got_sig_term) {
 304                         got_sig_term = 0;
 305                         terminate();
 306                 }
 307
 308                 /*
 309                  * We got an interface, go back to blocking term.
 310                  */
 311
 312                 BlockSignals(true, SIGTERM);
 313                 goto try_again;
 314         }
 315 }
 316
 317 /**************************************************************************** **
 318  Reload the services file.
 319  **************************************************************************** */
 320
 321 static bool reload_nmbd_services(bool test)
 322 {
 323         bool ret;
 324
 325         set_remote_machine_name("nmbd", False);
 326
 327         if ( lp_loaded() ) {
 328                 const char *fname = lp_configfile();
 329                 if (file_exist(fname,NULL) && !strcsequal(fname,get_dyn_CONFIGFILE())) {
 330                         set_dyn_CONFIGFILE(fname);
 331                         test = False;
 332                 }
 333         }
 334
 335         if ( test && !lp_file_list_changed() )
 336                 return(True);
 337
 338         ret = lp_load(get_dyn_CONFIGFILE(), True , False, False, True);
 339
 340         /* perhaps the config filename is now set */
 341         if ( !test ) {
 342                 DEBUG( 3, ( "services not loaded\n" ) );
 343                 reload_nmbd_services( True );
 344         }
 345
 346         return(ret);
 347 }
 348
 349 /**************************************************************************** **
 350  * React on 'smbcontrol nmbd reload-config' in the same way as to SIGHUP
 351  **************************************************************************** */
 352
 353 static void msg_reload_nmbd_services(struct messaging_context *msg,
 354                                      void *private_data,
 355                                      uint32_t msg_type,
 356                                      struct server_id server_id,
 357                                      DATA_BLOB *data)
 358 {
 359         write_browse_list( 0, True );
 360         dump_all_namelists();
 361         reload_nmbd_services( True );
 362         reopen_logs();
 363         reload_interfaces(0);
 364 }
 365
 366 static void msg_nmbd_send_packet(struct messaging_context *msg,
 367                                  void *private_data,
 368                                  uint32_t msg_type,
 369                                  struct server_id src,
 370                                  DATA_BLOB *data)
 371 {
 372         struct packet_struct *p = (struct packet_struct *)data->data;
 373         struct subnet_record *subrec;
 374         struct sockaddr_storage ss;
 375         const struct sockaddr_storage *pss;
 376         const struct in_addr *local_ip;
 377
 378         DEBUG(10, ("Received send_packet from %d\n", procid_to_pid(&src)));
 379
 380         if (data->length != sizeof(struct packet_struct)) {
 381                 DEBUG(2, ("Discarding invalid packet length from %d\n",
 382                           procid_to_pid(&src)));
 383                 return;
 384         }
 385
 386         if ((p->packet_type != NMB_PACKET) &&
 387             (p->packet_type != DGRAM_PACKET)) {
 388                 DEBUG(2, ("Discarding invalid packet type from %d: %d\n",
 389                           procid_to_pid(&src), p->packet_type));
 390                 return;
 391         }
 392
 393         in_addr_to_sockaddr_storage(&ss, p->ip);
 394         pss = iface_ip(&ss);
 395
 396         if (pss == NULL) {
 397                 DEBUG(2, ("Could not find ip for packet from %d\n",
 398                           procid_to_pid(&src)));
 399                 return;
 400         }
 401
 402         local_ip = &((const struct sockaddr_in *)pss)->sin_addr;
 403         subrec = FIRST_SUBNET;
 404
 405         p->fd = (p->packet_type == NMB_PACKET) ?
 406                 subrec->nmb_sock : subrec->dgram_sock;
 407
 408         for (subrec = FIRST_SUBNET; subrec != NULL;
 409              subrec = NEXT_SUBNET_EXCLUDING_UNICAST(subrec)) {
 410                 if (ip_equal_v4(*local_ip, subrec->myip)) {
 411                         p->fd = (p->packet_type == NMB_PACKET) ?
 412                                 subrec->nmb_sock : subrec->dgram_sock;
 413                         break;
 414                 }
 415         }
 416
 417         if (p->packet_type == DGRAM_PACKET) {
 418                 p->port = 138;
 419                 p->packet.dgram.header.source_ip.s_addr = local_ip->s_addr;
 420                 p->packet.dgram.header.source_port = 138;
 421         }
 422
 423         send_packet(p);
 424 }
 425
 426 /**************************************************************************** **
 427  The main select loop.
 428  **************************************************************************** */
 429
 430 static void process(void)
 431 {
 432         bool run_election;
 433
 434         while( True ) {
 435                 time_t t = time(NULL);
 436                 TALLOC_CTX *frame = talloc_stackframe();
 437
 438                 /* Check for internal messages */
 439
 440                 message_dispatch(nmbd_messaging_context());
 441
 442                 /*
 443                  * Check all broadcast subnets to see if
 444                  * we need to run an election on any of them.
 445                  * (nmbd_elections.c)
 446                  */
 447
 448                 run_election = check_elections();
 449
 450                 /*
 451                  * Read incoming UDP packets.
 452                  * (nmbd_packets.c)
 453                  */
 454
 455                 if(listen_for_packets(run_election)) {
 456                         TALLOC_FREE(frame);
 457                         return;
 458                 }
 459
 460                 /*
 461                  * Handle termination inband.
 462                  */
 463
 464                 if (got_sig_term) {
 465                         got_sig_term = 0;
 466                         terminate();
 467                 }
 468
 469                 /*
 470                  * Process all incoming packets
 471                  * read above. This calls the success and
 472                  * failure functions registered when response
 473                  * packets arrrive, and also deals with request
 474                  * packets from other sources.
 475                  * (nmbd_packets.c)
 476                  */
 477
 478                 run_packet_queue();
 479
 480                 /*
 481                  * Run any elections - initiate becoming
 482                  * a local master browser if we have won.
 483                  * (nmbd_elections.c)
 484                  */
 485
 486                 run_elections(t);
 487
 488                 /*
 489                  * Send out any broadcast announcements
 490                  * of our server names. This also announces
 491                  * the workgroup name if we are a local
 492                  * master browser.
 493                  * (nmbd_sendannounce.c)
 494                  */
 495
 496                 announce_my_server_names(t);
 497
 498                 /*
 499                  * Send out any LanMan broadcast announcements
 500                  * of our server names.
 501                  * (nmbd_sendannounce.c)
 502                  */
 503
 504                 announce_my_lm_server_names(t);
 505
 506                 /*
 507                  * If we are a local master browser, periodically
 508                  * announce ourselves to the domain master browser.
 509                  * This also deals with syncronising the domain master
 510                  * browser server lists with ourselves as a local
 511                  * master browser.
 512                  * (nmbd_sendannounce.c)
 513                  */
 514
 515                 announce_myself_to_domain_master_browser(t);
 516
 517                 /*
 518                  * Fullfill any remote announce requests.
 519                  * (nmbd_sendannounce.c)
 520                  */
 521
 522                 announce_remote(t);
 523
 524                 /*
 525                  * Fullfill any remote browse sync announce requests.
 526                  * (nmbd_sendannounce.c)
 527                  */
 528
 529                 browse_sync_remote(t);
 530
 531                 /*
 532                  * Scan the broadcast subnets, and WINS client
 533                  * namelists and refresh any that need refreshing.
 534                  * (nmbd_mynames.c)
 535                  */
 536
 537                 refresh_my_names(t);
 538
 539                 /*
 540                  * Scan the subnet namelists and server lists and
 541                  * expire thos that have timed out.
 542                  * (nmbd.c)
 543                  */
 544
 545                 expire_names_and_servers(t);
 546
 547                 /*
 548                  * Write out a snapshot of our current browse list into
 549                  * the browse.dat file. This is used by smbd to service
 550                  * incoming NetServerEnum calls - used to synchronise
 551                  * browse lists over subnets.
 552                  * (nmbd_serverlistdb.c)
 553                  */
 554
 555                 write_browse_list(t, False);
 556
 557                 /*
 558                  * If we are a domain master browser, we have a list of
 559                  * local master browsers we should synchronise browse
 560                  * lists with (these are added by an incoming local
 561                  * master browser announcement packet). Expire any of
 562                  * these that are no longer current, and pull the server
 563                  * lists from each of these known local master browsers.
 564                  * (nmbd_browsesync.c)
 565                  */
 566
 567                 dmb_expire_and_sync_browser_lists(t);
 568
 569                 /*
 570                  * Check that there is a local master browser for our
 571                  * workgroup for all our broadcast subnets. If one
 572                  * is not found, start an election (which we ourselves
 573                  * may or may not participate in, depending on the
 574                  * setting of the 'local master' parameter.
 575                  * (nmbd_elections.c)
 576                  */
 577
 578                 check_master_browser_exists(t);
 579
 580                 /*
 581                  * If we are configured as a logon server, attempt to
 582                  * register the special NetBIOS names to become such
 583                  * (WORKGROUP<1c> name) on all broadcast subnets and
 584                  * with the WINS server (if used). If we are configured
 585                  * to become a domain master browser, attempt to register
 586                  * the special NetBIOS name (WORKGROUP<1b> name) to
 587                  * become such.
 588                  * (nmbd_become_dmb.c)
 589                  */
 590
 591                 add_domain_names(t);
 592
 593                 /*
 594                  * If we are a WINS server, do any timer dependent
 595                  * processing required.
 596                  * (nmbd_winsserver.c)
 597                  */
 598
 599                 initiate_wins_processing(t);
 600
 601                 /*
 602                  * If we are a domain master browser, attempt to contact the
 603                  * WINS server to get a list of all known WORKGROUPS/DOMAINS.
 604                  * This will only work to a Samba WINS server.
 605                  * (nmbd_browsesync.c)
 606                  */
 607
 608                 if (lp_enhanced_browsing())
 609                         collect_all_workgroup_names_from_wins_server(t);
 610
 611                 /*
 612                  * Go through the response record queue and time out or re-transmit
 613                  * and expired entries.
 614                  * (nmbd_packets.c)
 615                  */
 616
 617                 retransmit_or_expire_response_records(t);
 618
 619                 /*
 620                  * check to see if any remote browse sync child processes have completed
 621                  */
 622
 623                 sync_check_completion();
 624
 625                 /*
 626                  * regularly sync with any other DMBs we know about
 627                  */
 628
 629                 if (lp_enhanced_browsing())
 630                         sync_all_dmbs(t);
 631
 632                 /*
 633                  * clear the unexpected packet queue
 634                  */
 635
 636                 clear_unexpected(t);
 637
 638                 /*
 639                  * Reload the services file if we got a sighup.
 640                  */
 641
 642                 if(reload_after_sighup) {
 643                         DEBUG( 0, ( "Got SIGHUP dumping debug info.\n" ) );
 644                         msg_reload_nmbd_services(nmbd_messaging_context(),
 645                                                  NULL, MSG_SMB_CONF_UPDATED,
 646                                                  procid_self(), NULL);
 647
 648                         reload_after_sighup = 0;
 649                 }
 650
 651                 /* check for new network interfaces */
 652
 653                 reload_interfaces(t);
 654
 655                 /* free up temp memory */
 656                 TALLOC_FREE(frame);
 657         }
 658 }
 659
 660 /**************************************************************************** **
 661  Open the socket communication.
 662  **************************************************************************** */
 663
 664 static bool open_sockets(bool isdaemon, int port)
 665 {
 666         struct sockaddr_storage ss;
 667         const char *sock_addr = lp_socket_address();
 668
 669         /*
 670          * The sockets opened here will be used to receive broadcast
 671          * packets *only*. Interface specific sockets are opened in
 672          * make_subnet() in namedbsubnet.c. Thus we bind to the
 673          * address "0.0.0.0". The parameter 'socket address' is
 674          * now deprecated.
 675          */
 676
 677         if (!interpret_string_addr(&ss, sock_addr,
 678                                 AI_NUMERICHOST|AI_PASSIVE)) {
 679                 DEBUG(0,("open_sockets: unable to get socket address "
 680                         "from string %s", sock_addr));
 681                 return false;
 682         }
 683         if (ss.ss_family != AF_INET) {
 684                 DEBUG(0,("open_sockets: unable to use IPv6 socket"
 685                         "%s in nmbd\n",
 686                         sock_addr));
 687                 return false;
 688         }
 689
 690         if (isdaemon) {
 691                 ClientNMB = open_socket_in(SOCK_DGRAM, port,
 692                                            0, &ss,
 693                                            true);
 694         } else {
 695                 ClientNMB = 0;
 696         }
 697
 698         if (ClientNMB == -1) {
 699                 return false;
 700         }
 701
 702         ClientDGRAM = open_socket_in(SOCK_DGRAM, DGRAM_PORT,
 703                                            3, &ss,
 704                                            true);
 705
 706         if (ClientDGRAM == -1) {
 707                 if (ClientNMB != 0) {
 708                         close(ClientNMB);
 709                 }
 710                 return false;
 711         }
 712
 713         /* we are never interested in SIGPIPE */
 714         BlockSignals(True,SIGPIPE);
 715
 716         set_socket_options( ClientNMB,   "SO_BROADCAST" );
 717         set_socket_options( ClientDGRAM, "SO_BROADCAST" );
 718
 719         /* Ensure we're non-blocking. */
 720         set_blocking( ClientNMB, False);
 721         set_blocking( ClientDGRAM, False);
 722
 723         DEBUG( 3, ( "open_sockets: Broadcast sockets opened.\n" ) );
 724         return( True );
 725 }
 726
 727 /**************************************************************************** **
 728  main program
 729  **************************************************************************** */
 730
 731  int main(int argc, const char *argv[])
 732 {
 733         static bool is_daemon;
 734         static bool opt_interactive;
 735         static bool Fork = true;
 736         static bool no_process_group;
 737         static bool log_stdout;
 738         poptContext pc;
 739         char *p_lmhosts = NULL;
 740         int opt;
 741         enum {
 742                 OPT_DAEMON = 1000,
 743                 OPT_INTERACTIVE,
 744                 OPT_FORK,
 745                 OPT_NO_PROCESS_GROUP,
 746                 OPT_LOG_STDOUT
 747         };
 748         struct poptOption long_options[] = {
 749         POPT_AUTOHELP
 750         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon(default)" },
 751         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)" },
 752         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools & etc)" },
 753         {"no-process-group", 0, POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
 754         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
 755         {"hosts", 'H', POPT_ARG_STRING, &p_lmhosts, 'H', "Load a netbios hosts file"},
 756         {"port", 'p', POPT_ARG_INT, &global_nmb_port, NMB_PORT, "Listen on the specified port" },
 757         POPT_COMMON_SAMBA
 758         { NULL }
 759         };
 760         TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
 761
 762         load_case_tables();
 763
 764         global_nmb_port = NMB_PORT;
 765
 766         pc = poptGetContext("nmbd", argc, argv, long_options, 0);
 767         while ((opt = poptGetNextOpt(pc)) != -1) {
 768                 switch (opt) {
 769                 case OPT_DAEMON:
 770                         is_daemon = true;
 771                         break;
 772                 case OPT_INTERACTIVE:
 773                         opt_interactive = true;
 774                         break;
 775                 case OPT_FORK:
 776                         Fork = false;
 777                         break;
 778                 case OPT_NO_PROCESS_GROUP:
 779                         no_process_group = true;
 780                         break;
 781                 case OPT_LOG_STDOUT:
 782                         log_stdout = true;
 783                         break;
 784                 default:
 785                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
 786                                   poptBadOption(pc, 0), poptStrerror(opt));
 787                         poptPrintUsage(pc, stderr, 0);
 788                         exit(1);
 789                 }
 790         };
 791         poptFreeContext(pc);
 792
 793         global_in_nmbd = true;
 794
 795         StartupTime = time(NULL);
 796
 797         sys_srandom(time(NULL) ^ sys_getpid());
 798
 799         if (!override_logfile) {
 800                 char *logfile = NULL;
 801                 if (asprintf(&logfile, "%s/log.nmbd", get_dyn_LOGFILEBASE()) < 0) {
 802                         exit(1);
 803                 }
 804                 lp_set_logfile(logfile);
 805                 SAFE_FREE(logfile);
 806         }
 807
 808         fault_setup((void (*)(void *))fault_continue );
 809         dump_core_setup("nmbd");
 810
 811         /* POSIX demands that signals are inherited. If the invoking process has
 812          * these signals masked, we will have problems, as we won't receive them. */
 813         BlockSignals(False, SIGHUP);
 814         BlockSignals(False, SIGUSR1);
 815         BlockSignals(False, SIGTERM);
 816
 817         CatchSignal( SIGHUP,  SIGNAL_CAST sig_hup );
 818         CatchSignal( SIGTERM, SIGNAL_CAST sig_term );
 819
 820 #if defined(SIGFPE)
 821         /* we are never interested in SIGFPE */
 822         BlockSignals(True,SIGFPE);
 823 #endif
 824
 825         /* We no longer use USR2... */
 826 #if defined(SIGUSR2)
 827         BlockSignals(True, SIGUSR2);
 828 #endif
 829
 830         if ( opt_interactive ) {
 831                 Fork = False;
 832                 log_stdout = True;
 833         }
 834
 835         if ( log_stdout && Fork ) {
 836                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 837                 exit(1);
 838         }
 839
 840         setup_logging( argv[0], log_stdout );
 841
 842         reopen_logs();
 843
 844         DEBUG(0,("nmbd version %s started.\n", SAMBA_VERSION_STRING));
 845         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
 846
 847         if ( !reload_nmbd_services(False) )
 848                 return(-1);
 849
 850         if(!init_names())
 851                 return -1;
 852
 853         reload_nmbd_services( True );
 854
 855         if (strequal(lp_workgroup(),"*")) {
 856                 DEBUG(0,("ERROR: a workgroup name of * is no longer supported\n"));
 857                 exit(1);
 858         }
 859
 860         set_samba_nb_type();
 861
 862         if (!is_daemon && !is_a_socket(0)) {
 863                 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
 864                 is_daemon = True;
 865         }
 866
 867         if (is_daemon && !opt_interactive) {
 868                 DEBUG( 2, ( "Becoming a daemon.\n" ) );
 869                 become_daemon(Fork, no_process_group);
 870         }
 871
 872 #if HAVE_SETPGID
 873         /*
 874          * If we're interactive we want to set our own process group for
 875          * signal management.
 876          */
 877         if (opt_interactive && !no_process_group)
 878                 setpgid( (pid_t)0, (pid_t)0 );
 879 #endif
 880
 881         if (nmbd_messaging_context() == NULL) {
 882                 return 1;
 883         }
 884
 885 #ifndef SYNC_DNS
 886         /* Setup the async dns. We do it here so it doesn't have all the other
 887                 stuff initialised and thus chewing memory and sockets */
 888         if(lp_we_are_a_wins_server() && lp_dns_proxy()) {
 889                 start_async_dns();
 890         }
 891 #endif
 892
 893         if (!directory_exist(lp_lockdir(), NULL)) {
 894                 mkdir(lp_lockdir(), 0755);
 895         }
 896
 897         pidfile_create("nmbd");
 898         messaging_register(nmbd_messaging_context(), NULL,
 899                            MSG_FORCE_ELECTION, nmbd_message_election);
 900 #if 0
 901         /* Until winsrepl is done. */
 902         messaging_register(nmbd_messaging_context(), NULL,
 903                            MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry);
 904 #endif
 905         messaging_register(nmbd_messaging_context(), NULL,
 906                            MSG_SHUTDOWN, nmbd_terminate);
 907         messaging_register(nmbd_messaging_context(), NULL,
 908                            MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services);
 909         messaging_register(nmbd_messaging_context(), NULL,
 910                            MSG_SEND_PACKET, msg_nmbd_send_packet);
 911
 912         TimeInit();
 913
 914         DEBUG( 3, ( "Opening sockets %d\n", global_nmb_port ) );
 915
 916         if ( !open_sockets( is_daemon, global_nmb_port ) ) {
 917                 kill_async_dns_child();
 918                 return 1;
 919         }
 920
 921         /* Determine all the IP addresses we have. */
 922         load_interfaces();
 923
 924         /* Create an nmbd subnet record for each of the above. */
 925         if( False == create_subnets() ) {
 926                 DEBUG(0,("ERROR: Failed when creating subnet lists. Exiting.\n"));
 927                 kill_async_dns_child();
 928                 exit(1);
 929         }
 930
 931         /* Load in any static local names. */
 932         if (p_lmhosts) {
 933                 set_dyn_LMHOSTSFILE(p_lmhosts);
 934         }
 935         load_lmhosts_file(get_dyn_LMHOSTSFILE());
 936         DEBUG(3,("Loaded hosts file %s\n", get_dyn_LMHOSTSFILE()));
 937
 938         /* If we are acting as a WINS server, initialise data structures. */
 939         if( !initialise_wins() ) {
 940                 DEBUG( 0, ( "nmbd: Failed when initialising WINS server.\n" ) );
 941                 kill_async_dns_child();
 942                 exit(1);
 943         }
 944
 945         /*
 946          * Register nmbd primary workgroup and nmbd names on all
 947          * the broadcast subnets, and on the WINS server (if specified).
 948          * Also initiate the startup of our primary workgroup (start
 949          * elections if we are setup as being able to be a local
 950          * master browser.
 951          */
 952
 953         if( False == register_my_workgroup_and_names() ) {
 954                 DEBUG(0,("ERROR: Failed when creating my my workgroup. Exiting.\n"));
 955                 kill_async_dns_child();
 956                 exit(1);
 957         }
 958
 959         /* We can only take signals in the select. */
 960         BlockSignals( True, SIGTERM );
 961
 962         TALLOC_FREE(frame);
 963         process();
 964
 965         if (dbf)
 966                 x_fclose(dbf);
 967         kill_async_dns_child();
 968         return(0);
 969 }