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