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 "system/filesys.h"
  24 #include "popt_common.h"
  25 #include "nmbd/nmbd.h"
  26 #include "serverid.h"
  27 #include "messages.h"
  28
  29 int ClientNMB       = -1;
  30 int ClientDGRAM     = -1;
  31 int global_nmb_port = -1;
  32
  33 extern bool rescan_listen_set;
  34 extern bool global_in_nmbd;
  35
  36 extern bool override_logfile;
  37
  38 /* have we found LanMan clients yet? */
  39 bool found_lm_clients = False;
  40
  41 /* what server type are we currently */
  42
  43 time_t StartupTime = 0;
  44
  45 struct event_context *nmbd_event_context(void)
  46 {
  47         return server_event_context();
  48 }
  49
  50 static struct messaging_context *nmbd_messaging_context(void)
  51 {
  52         struct messaging_context *msg_ctx = server_messaging_context();
  53         if (likely(msg_ctx != NULL)) {
  54                 return msg_ctx;
  55         }
  56         smb_panic("Could not init nmbd's messaging context.\n");
  57         return NULL;
  58 }
  59
  60 /**************************************************************************** **
  61  Handle a SIGTERM in band.
  62  **************************************************************************** */
  63
  64 static void terminate(struct messaging_context *msg)
  65 {
  66         DEBUG(0,("Got SIGTERM: going down...\n"));
  67
  68         /* Write out wins.dat file if samba is a WINS server */
  69         wins_write_database(0,False);
  70
  71         /* Remove all SELF registered names from WINS */
  72         release_wins_names();
  73
  74         /* Announce all server entries as 0 time-to-live, 0 type. */
  75         announce_my_servers_removed();
  76
  77         /* If there was an async dns child - kill it. */
  78         kill_async_dns_child();
  79
  80         gencache_stabilize();
  81         serverid_deregister(messaging_server_id(msg));
  82
  83         pidfile_unlink();
  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         struct messaging_context *msg = talloc_get_type_abort(
  96                 private_data, struct messaging_context);
  97
  98         terminate(msg);
  99 }
 100
 101 static bool nmbd_setup_sig_term_handler(struct messaging_context *msg)
 102 {
 103         struct tevent_signal *se;
 104
 105         se = tevent_add_signal(nmbd_event_context(),
 106                                nmbd_event_context(),
 107                                SIGTERM, 0,
 108                                nmbd_sig_term_handler,
 109                                msg);
 110         if (!se) {
 111                 DEBUG(0,("failed to setup SIGTERM handler"));
 112                 return false;
 113         }
 114
 115         return true;
 116 }
 117
 118 static void msg_reload_nmbd_services(struct messaging_context *msg,
 119                                      void *private_data,
 120                                      uint32_t msg_type,
 121                                      struct server_id server_id,
 122                                      DATA_BLOB *data);
 123
 124 static void nmbd_sig_hup_handler(struct tevent_context *ev,
 125                                  struct tevent_signal *se,
 126                                  int signum,
 127                                  int count,
 128                                  void *siginfo,
 129                                  void *private_data)
 130 {
 131         struct messaging_context *msg = talloc_get_type_abort(
 132                 private_data, struct messaging_context);
 133
 134         DEBUG(0,("Got SIGHUP dumping debug info.\n"));
 135         msg_reload_nmbd_services(msg, NULL, MSG_SMB_CONF_UPDATED,
 136                                  messaging_server_id(msg), NULL);
 137 }
 138
 139 static bool nmbd_setup_sig_hup_handler(struct messaging_context *msg)
 140 {
 141         struct tevent_signal *se;
 142
 143         se = tevent_add_signal(nmbd_event_context(),
 144                                nmbd_event_context(),
 145                                SIGHUP, 0,
 146                                nmbd_sig_hup_handler,
 147                                msg);
 148         if (!se) {
 149                 DEBUG(0,("failed to setup SIGHUP handler"));
 150                 return false;
 151         }
 152
 153         return true;
 154 }
 155
 156 /**************************************************************************** **
 157  Handle a SHUTDOWN message from smbcontrol.
 158  **************************************************************************** */
 159
 160 static void nmbd_terminate(struct messaging_context *msg,
 161                            void *private_data,
 162                            uint32_t msg_type,
 163                            struct server_id server_id,
 164                            DATA_BLOB *data)
 165 {
 166         terminate(msg);
 167 }
 168
 169 /**************************************************************************** **
 170  Expire old names from the namelist and server list.
 171  **************************************************************************** */
 172
 173 static void expire_names_and_servers(time_t t)
 174 {
 175         static time_t lastrun = 0;
 176
 177         if ( !lastrun )
 178                 lastrun = t;
 179         if ( t < (lastrun + 5) )
 180                 return;
 181         lastrun = t;
 182
 183         /*
 184          * Expire any timed out names on all the broadcast
 185          * subnets and those registered with the WINS server.
 186          * (nmbd_namelistdb.c)
 187          */
 188
 189         expire_names(t);
 190
 191         /*
 192          * Go through all the broadcast subnets and for each
 193          * workgroup known on that subnet remove any expired
 194          * server names. If a workgroup has an empty serverlist
 195          * and has itself timed out then remove the workgroup.
 196          * (nmbd_workgroupdb.c)
 197          */
 198
 199         expire_workgroups_and_servers(t);
 200 }
 201
 202 /************************************************************************** **
 203  Reload the list of network interfaces.
 204  Doesn't return until a network interface is up.
 205  ************************************************************************** */
 206
 207 static void reload_interfaces(time_t t)
 208 {
 209         static time_t lastt;
 210         int n;
 211         bool print_waiting_msg = true;
 212         struct subnet_record *subrec;
 213
 214         if (t && ((t - lastt) < NMBD_INTERFACES_RELOAD)) {
 215                 return;
 216         }
 217
 218         lastt = t;
 219
 220         if (!interfaces_changed()) {
 221                 return;
 222         }
 223
 224   try_again:
 225
 226         /* the list of probed interfaces has changed, we may need to add/remove
 227            some subnets */
 228         load_interfaces();
 229
 230         /* find any interfaces that need adding */
 231         for (n=iface_count() - 1; n >= 0; n--) {
 232                 char str[INET6_ADDRSTRLEN];
 233                 const struct interface *iface = get_interface(n);
 234                 struct in_addr ip, nmask;
 235
 236                 if (!iface) {
 237                         DEBUG(2,("reload_interfaces: failed to get interface %d\n", n));
 238                         continue;
 239                 }
 240
 241                 /* Ensure we're only dealing with IPv4 here. */
 242                 if (iface->ip.ss_family != AF_INET) {
 243                         DEBUG(2,("reload_interfaces: "
 244                                 "ignoring non IPv4 interface.\n"));
 245                         continue;
 246                 }
 247
 248                 ip = ((const struct sockaddr_in *)(const void *)&iface->ip)->sin_addr;
 249                 nmask = ((const struct sockaddr_in *)(const void *)
 250                          &iface->netmask)->sin_addr;
 251
 252                 /*
 253                  * We don't want to add a loopback interface, in case
 254                  * someone has added 127.0.0.1 for smbd, nmbd needs to
 255                  * ignore it here. JRA.
 256                  */
 257
 258                 if (is_loopback_addr((const struct sockaddr *)(const void *)&iface->ip)) {
 259                         DEBUG(2,("reload_interfaces: Ignoring loopback "
 260                                 "interface %s\n",
 261                                 print_sockaddr(str, sizeof(str), &iface->ip) ));
 262                         continue;
 263                 }
 264
 265                 for (subrec=subnetlist; subrec; subrec=subrec->next) {
 266                         if (ip_equal_v4(ip, subrec->myip) &&
 267                             ip_equal_v4(nmask, subrec->mask_ip)) {
 268                                 break;
 269                         }
 270                 }
 271
 272                 if (!subrec) {
 273                         /* it wasn't found! add it */
 274                         DEBUG(2,("Found new interface %s\n",
 275                                  print_sockaddr(str,
 276                                          sizeof(str), &iface->ip) ));
 277                         subrec = make_normal_subnet(iface);
 278                         if (subrec)
 279                                 register_my_workgroup_one_subnet(subrec);
 280                 }
 281         }
 282
 283         /* find any interfaces that need deleting */
 284         for (subrec=subnetlist; subrec; subrec=subrec->next) {
 285                 for (n=iface_count() - 1; n >= 0; n--) {
 286                         struct interface *iface = get_interface(n);
 287                         struct in_addr ip, nmask;
 288                         if (!iface) {
 289                                 continue;
 290                         }
 291                         /* Ensure we're only dealing with IPv4 here. */
 292                         if (iface->ip.ss_family != AF_INET) {
 293                                 DEBUG(2,("reload_interfaces: "
 294                                         "ignoring non IPv4 interface.\n"));
 295                                 continue;
 296                         }
 297                         ip = ((struct sockaddr_in *)(void *)
 298                               &iface->ip)->sin_addr;
 299                         nmask = ((struct sockaddr_in *)(void *)
 300                                  &iface->netmask)->sin_addr;
 301                         if (ip_equal_v4(ip, subrec->myip) &&
 302                             ip_equal_v4(nmask, subrec->mask_ip)) {
 303                                 break;
 304                         }
 305                 }
 306                 if (n == -1) {
 307                         /* oops, an interface has disapeared. This is
 308                          tricky, we don't dare actually free the
 309                          interface as it could be being used, so
 310                          instead we just wear the memory leak and
 311                          remove it from the list of interfaces without
 312                          freeing it */
 313                         DEBUG(2,("Deleting dead interface %s\n",
 314                                  inet_ntoa(subrec->myip)));
 315                         close_subnet(subrec);
 316                 }
 317         }
 318
 319         rescan_listen_set = True;
 320
 321         /* We need to wait if there are no subnets... */
 322         if (FIRST_SUBNET == NULL) {
 323                 void (*saved_handler)(int);
 324
 325                 if (print_waiting_msg) {
 326                         DEBUG(0,("reload_interfaces: "
 327                                 "No subnets to listen to. Waiting..\n"));
 328                         print_waiting_msg = false;
 329                 }
 330
 331                 /*
 332                  * Whilst we're waiting for an interface, allow SIGTERM to
 333                  * cause us to exit.
 334                  */
 335                 saved_handler = CatchSignal(SIGTERM, SIG_DFL);
 336
 337                 /* We only count IPv4, non-loopback interfaces here. */
 338                 while (iface_count_v4_nl() == 0) {
 339                         sleep(5);
 340                         load_interfaces();
 341                 }
 342
 343                 CatchSignal(SIGTERM, saved_handler);
 344
 345                 /*
 346                  * We got an interface, go back to blocking term.
 347                  */
 348
 349                 goto try_again;
 350         }
 351 }
 352
 353 /**************************************************************************** **
 354  Reload the services file.
 355  **************************************************************************** */
 356
 357 static bool reload_nmbd_services(bool test)
 358 {
 359         bool ret;
 360
 361         set_remote_machine_name("nmbd", False);
 362
 363         if ( lp_loaded() ) {
 364                 const char *fname = lp_configfile();
 365                 if (file_exist(fname) && !strcsequal(fname,get_dyn_CONFIGFILE())) {
 366                         set_dyn_CONFIGFILE(fname);
 367                         test = False;
 368                 }
 369         }
 370
 371         if ( test && !lp_file_list_changed() )
 372                 return(True);
 373
 374         ret = lp_load_global(get_dyn_CONFIGFILE());
 375
 376         /* perhaps the config filename is now set */
 377         if ( !test ) {
 378                 DEBUG( 3, ( "services not loaded\n" ) );
 379                 reload_nmbd_services( True );
 380         }
 381
 382         return(ret);
 383 }
 384
 385 /**************************************************************************** **
 386  * React on 'smbcontrol nmbd reload-config' in the same way as to SIGHUP
 387  **************************************************************************** */
 388
 389 static void msg_reload_nmbd_services(struct messaging_context *msg,
 390                                      void *private_data,
 391                                      uint32_t msg_type,
 392                                      struct server_id server_id,
 393                                      DATA_BLOB *data)
 394 {
 395         write_browse_list( 0, True );
 396         dump_all_namelists();
 397         reload_nmbd_services( True );
 398         reopen_logs();
 399         reload_interfaces(0);
 400 }
 401
 402 static void msg_nmbd_send_packet(struct messaging_context *msg,
 403                                  void *private_data,
 404                                  uint32_t msg_type,
 405                                  struct server_id src,
 406                                  DATA_BLOB *data)
 407 {
 408         struct packet_struct *p = (struct packet_struct *)data->data;
 409         struct subnet_record *subrec;
 410         struct sockaddr_storage ss;
 411         const struct sockaddr_storage *pss;
 412         const struct in_addr *local_ip;
 413
 414         DEBUG(10, ("Received send_packet from %u\n", (unsigned int)procid_to_pid(&src)));
 415
 416         if (data->length != sizeof(struct packet_struct)) {
 417                 DEBUG(2, ("Discarding invalid packet length from %u\n",
 418                           (unsigned int)procid_to_pid(&src)));
 419                 return;
 420         }
 421
 422         if ((p->packet_type != NMB_PACKET) &&
 423             (p->packet_type != DGRAM_PACKET)) {
 424                 DEBUG(2, ("Discarding invalid packet type from %u: %d\n",
 425                           (unsigned int)procid_to_pid(&src), p->packet_type));
 426                 return;
 427         }
 428
 429         in_addr_to_sockaddr_storage(&ss, p->ip);
 430         pss = iface_ip((struct sockaddr *)(void *)&ss);
 431
 432         if (pss == NULL) {
 433                 DEBUG(2, ("Could not find ip for packet from %u\n",
 434                           (unsigned int)procid_to_pid(&src)));
 435                 return;
 436         }
 437
 438         local_ip = &((const struct sockaddr_in *)pss)->sin_addr;
 439         subrec = FIRST_SUBNET;
 440
 441         p->recv_fd = -1;
 442         p->send_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->send_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(struct messaging_context *msg)
 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(msg, 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                 /* check for new network interfaces */
 657
 658                 reload_interfaces(t);
 659
 660                 /* free up temp memory */
 661                 TALLOC_FREE(frame);
 662         }
 663 }
 664
 665 /**************************************************************************** **
 666  Open the socket communication.
 667  **************************************************************************** */
 668
 669 static bool open_sockets(bool isdaemon, int port)
 670 {
 671         struct sockaddr_storage ss;
 672         const char *sock_addr = lp_socket_address();
 673
 674         /*
 675          * The sockets opened here will be used to receive broadcast
 676          * packets *only*. Interface specific sockets are opened in
 677          * make_subnet() in namedbsubnet.c. Thus we bind to the
 678          * address "0.0.0.0". The parameter 'socket address' is
 679          * now deprecated.
 680          */
 681
 682         if (!interpret_string_addr(&ss, sock_addr,
 683                                 AI_NUMERICHOST|AI_PASSIVE)) {
 684                 DEBUG(0,("open_sockets: unable to get socket address "
 685                         "from string %s", sock_addr));
 686                 return false;
 687         }
 688         if (ss.ss_family != AF_INET) {
 689                 DEBUG(0,("open_sockets: unable to use IPv6 socket"
 690                         "%s in nmbd\n",
 691                         sock_addr));
 692                 return false;
 693         }
 694
 695         if (isdaemon) {
 696                 ClientNMB = open_socket_in(SOCK_DGRAM, port,
 697                                            0, &ss,
 698                                            true);
 699         } else {
 700                 ClientNMB = 0;
 701         }
 702
 703         if (ClientNMB == -1) {
 704                 return false;
 705         }
 706
 707         ClientDGRAM = open_socket_in(SOCK_DGRAM, DGRAM_PORT,
 708                                            3, &ss,
 709                                            true);
 710
 711         if (ClientDGRAM == -1) {
 712                 if (ClientNMB != 0) {
 713                         close(ClientNMB);
 714                 }
 715                 return false;
 716         }
 717
 718         /* we are never interested in SIGPIPE */
 719         BlockSignals(True,SIGPIPE);
 720
 721         set_socket_options( ClientNMB,   "SO_BROADCAST" );
 722         set_socket_options( ClientDGRAM, "SO_BROADCAST" );
 723
 724         /* Ensure we're non-blocking. */
 725         set_blocking( ClientNMB, False);
 726         set_blocking( ClientDGRAM, False);
 727
 728         DEBUG( 3, ( "open_sockets: Broadcast sockets opened.\n" ) );
 729         return( True );
 730 }
 731
 732 /**************************************************************************** **
 733  main program
 734  **************************************************************************** */
 735
 736  int main(int argc, const char *argv[])
 737 {
 738         bool is_daemon;
 739         bool opt_interactive;
 740         bool Fork = true;
 741         bool no_process_group;
 742         bool log_stdout;
 743         poptContext pc;
 744         char *p_lmhosts = NULL;
 745         int opt;
 746         enum {
 747                 OPT_DAEMON = 1000,
 748                 OPT_INTERACTIVE,
 749                 OPT_FORK,
 750                 OPT_NO_PROCESS_GROUP,
 751                 OPT_LOG_STDOUT
 752         };
 753         struct poptOption long_options[] = {
 754         POPT_AUTOHELP
 755         {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon(default)" },
 756         {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)" },
 757         {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools & etc)" },
 758         {"no-process-group", 0, POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
 759         {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
 760         {"hosts", 'H', POPT_ARG_STRING, &p_lmhosts, 0, "Load a netbios hosts file"},
 761         {"port", 'p', POPT_ARG_INT, &global_nmb_port, 0, "Listen on the specified port" },
 762         POPT_COMMON_SAMBA
 763         { NULL }
 764         };
 765         TALLOC_CTX *frame;
 766         NTSTATUS status;
 767
 768         /*
 769          * Do this before any other talloc operation
 770          */
 771         talloc_enable_null_tracking();
 772         frame = talloc_stackframe();
 773
 774         setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
 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();
 823         dump_core_setup("nmbd", lp_logfile());
 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
 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 '%s'\n", get_dyn_CONFIGFILE()));
 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(nmbd_messaging_context());
 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                                    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(nmbd_messaging_context()))
 933                 exit(1);
 934         if (!nmbd_setup_sig_hup_handler(nmbd_messaging_context()))
 935                 exit(1);
 936
 937         /* get broadcast messages */
 938
 939         if (!serverid_register(procid_self(),
 940                                 FLAG_MSG_GENERAL |
 941                                 FLAG_MSG_NMBD |
 942                                 FLAG_MSG_DBWRAP)) {
 943                 DEBUG(1, ("Could not register myself in serverid.tdb\n"));
 944                 exit(1);
 945         }
 946
 947         messaging_register(nmbd_messaging_context(), NULL,
 948                            MSG_FORCE_ELECTION, nmbd_message_election);
 949 #if 0
 950         /* Until winsrepl is done. */
 951         messaging_register(nmbd_messaging_context(), NULL,
 952                            MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry);
 953 #endif
 954         messaging_register(nmbd_messaging_context(), NULL,
 955                            MSG_SHUTDOWN, nmbd_terminate);
 956         messaging_register(nmbd_messaging_context(), NULL,
 957                            MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services);
 958         messaging_register(nmbd_messaging_context(), NULL,
 959                            MSG_SEND_PACKET, msg_nmbd_send_packet);
 960
 961         TimeInit();
 962
 963         DEBUG( 3, ( "Opening sockets %d\n", global_nmb_port ) );
 964
 965         if ( !open_sockets( is_daemon, global_nmb_port ) ) {
 966                 kill_async_dns_child();
 967                 return 1;
 968         }
 969
 970         /* Determine all the IP addresses we have. */
 971         load_interfaces();
 972
 973         /* Create an nmbd subnet record for each of the above. */
 974         if( False == create_subnets() ) {
 975                 DEBUG(0,("ERROR: Failed when creating subnet lists. Exiting.\n"));
 976                 kill_async_dns_child();
 977                 exit(1);
 978         }
 979
 980         /* Load in any static local names. */
 981         if (p_lmhosts) {
 982                 set_dyn_LMHOSTSFILE(p_lmhosts);
 983         }
 984         load_lmhosts_file(get_dyn_LMHOSTSFILE());
 985         DEBUG(3,("Loaded hosts file %s\n", get_dyn_LMHOSTSFILE()));
 986
 987         /* If we are acting as a WINS server, initialise data structures. */
 988         if( !initialise_wins() ) {
 989                 DEBUG( 0, ( "nmbd: Failed when initialising WINS server.\n" ) );
 990                 kill_async_dns_child();
 991                 exit(1);
 992         }
 993
 994         /*
 995          * Register nmbd primary workgroup and nmbd names on all
 996          * the broadcast subnets, and on the WINS server (if specified).
 997          * Also initiate the startup of our primary workgroup (start
 998          * elections if we are setup as being able to be a local
 999          * master browser.
1000          */
1001
1002         if( False == register_my_workgroup_and_names() ) {
1003                 DEBUG(0,("ERROR: Failed when creating my my workgroup. Exiting.\n"));
1004                 kill_async_dns_child();
1005                 exit(1);
1006         }
1007
1008         if (!initialize_nmbd_proxy_logon()) {
1009                 DEBUG(0,("ERROR: Failed setup nmbd_proxy_logon.\n"));
1010                 kill_async_dns_child();
1011                 exit(1);
1012         }
1013
1014         if (!nmbd_init_packet_server()) {
1015                 kill_async_dns_child();
1016                 exit(1);
1017         }
1018
1019         TALLOC_FREE(frame);
1020         process(nmbd_messaging_context());
1021
1022         kill_async_dns_child();
1023         return(0);
1024 }