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