source3/nmbd/nmbd.c

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