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