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 #include "util_cluster.h"
  30
  31 int ClientNMB       = -1;
  32 int ClientDGRAM     = -1;
  33 int global_nmb_port = -1;
  34
  35 extern bool rescan_listen_set;
  36 extern bool global_in_nmbd;
  37
  38 extern bool override_logfile;
  39
  40 /* have we found LanMan clients yet? */
  41 bool found_lm_clients = False;
  42
  43 /* what server type are we currently */
  44
  45 time_t StartupTime = 0;
  46
  47 struct tevent_context *nmbd_event_context(void)
  48 {
  49         return server_event_context();
  50 }
  51
  52 /**************************************************************************** **
  53  Handle a SIGTERM in band.
  54  **************************************************************************** */
  55
  56 static void terminate(struct messaging_context *msg)
  57 {
  58         DEBUG(0,("Got SIGTERM: going down...\n"));
  59
  60         /* Write out wins.dat file if samba is a WINS server */
  61         wins_write_database(0,False);
  62
  63         /* Remove all SELF registered names from WINS */
  64         release_wins_names();
  65
  66         /* Announce all server entries as 0 time-to-live, 0 type. */
  67         announce_my_servers_removed();
  68
  69         /* If there was an async dns child - kill it. */
  70         kill_async_dns_child();
  71
  72         gencache_stabilize();
  73
  74         pidfile_unlink(lp_pid_directory(), "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 disappeared. 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_next_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 arrive, 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         bool ok;
 806
 807         /*
 808          * Do this before any other talloc operation
 809          */
 810         talloc_enable_null_tracking();
 811         frame = talloc_stackframe();
 812
 813         /*
 814          * We want total control over the permissions on created files,
 815          * so set our umask to 0.
 816          */
 817         umask(0);
 818
 819         setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
 820
 821         smb_init_locale();
 822
 823         global_nmb_port = NMB_PORT;
 824
 825         pc = poptGetContext("nmbd", argc, argv, long_options, 0);
 826         while ((opt = poptGetNextOpt(pc)) != -1) {
 827                 switch (opt) {
 828                 case OPT_DAEMON:
 829                         is_daemon = true;
 830                         break;
 831                 case OPT_INTERACTIVE:
 832                         opt_interactive = true;
 833                         break;
 834                 case OPT_FORK:
 835                         Fork = false;
 836                         break;
 837                 case OPT_NO_PROCESS_GROUP:
 838                         no_process_group = true;
 839                         break;
 840                 case OPT_LOG_STDOUT:
 841                         log_stdout = true;
 842                         break;
 843                 default:
 844                         d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
 845                                   poptBadOption(pc, 0), poptStrerror(opt));
 846                         poptPrintUsage(pc, stderr, 0);
 847                         exit(1);
 848                 }
 849         };
 850         poptFreeContext(pc);
 851
 852         global_in_nmbd = true;
 853
 854         StartupTime = time(NULL);
 855
 856         sys_srandom(time(NULL) ^ getpid());
 857
 858         if (!override_logfile) {
 859                 char *lfile = NULL;
 860                 if (asprintf(&lfile, "%s/log.nmbd", get_dyn_LOGFILEBASE()) < 0) {
 861                         exit(1);
 862                 }
 863                 lp_set_logfile(lfile);
 864                 SAFE_FREE(lfile);
 865         }
 866
 867         fault_setup();
 868         dump_core_setup("nmbd", lp_logfile(talloc_tos()));
 869
 870         /* POSIX demands that signals are inherited. If the invoking process has
 871          * these signals masked, we will have problems, as we won't receive them. */
 872         BlockSignals(False, SIGHUP);
 873         BlockSignals(False, SIGUSR1);
 874         BlockSignals(False, SIGTERM);
 875
 876 #if defined(SIGFPE)
 877         /* we are never interested in SIGFPE */
 878         BlockSignals(True,SIGFPE);
 879 #endif
 880
 881         /* We no longer use USR2... */
 882 #if defined(SIGUSR2)
 883         BlockSignals(True, SIGUSR2);
 884 #endif
 885
 886         /* Ignore children - no zombies. */
 887         CatchChild();
 888
 889         if ( opt_interactive ) {
 890                 Fork = False;
 891                 log_stdout = True;
 892         }
 893
 894         if ( log_stdout && Fork ) {
 895                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 896                 exit(1);
 897         }
 898
 899         if (log_stdout) {
 900                 setup_logging(argv[0], DEBUG_STDOUT);
 901         } else {
 902                 setup_logging( argv[0], DEBUG_FILE);
 903         }
 904
 905         reopen_logs();
 906
 907         DEBUG(0,("nmbd version %s started.\n", samba_version_string()));
 908         DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
 909
 910         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
 911                 DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
 912                 exit(1);
 913         }
 914
 915         reopen_logs();
 916
 917         if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
 918             && !lp_parm_bool(-1, "server role check", "inhibit", false)) {
 919                 /* TODO: when we have a merged set of defaults for
 920                  * loadparm, we could possibly check if the internal
 921                  * nbt server is in the list, and allow a startup if disabled */
 922                 DEBUG(0, ("server role = 'active directory domain controller' not compatible with running nmbd standalone. \n"));
 923                 DEBUGADD(0, ("You should start 'samba' instead, and it will control starting the internal nbt server\n"));
 924                 exit(1);
 925         }
 926
 927         if (!cluster_probe_ok()) {
 928                 exit(1);
 929         }
 930
 931         msg = messaging_init(NULL, server_event_context());
 932         if (msg == NULL) {
 933                 return 1;
 934         }
 935
 936         if ( !reload_nmbd_services(False) )
 937                 return(-1);
 938
 939         if(!init_names())
 940                 return -1;
 941
 942         reload_nmbd_services( True );
 943
 944         if (strequal(lp_workgroup(),"*")) {
 945                 DEBUG(0,("ERROR: a workgroup name of * is no longer supported\n"));
 946                 exit(1);
 947         }
 948
 949         set_samba_nb_type();
 950
 951         if (!is_daemon && !is_a_socket(0)) {
 952                 DEBUG(3, ("standard input is not a socket, assuming -D option\n"));
 953                 is_daemon = True;
 954         }
 955
 956         if (is_daemon && !opt_interactive) {
 957                 DEBUG(3, ("Becoming a daemon.\n"));
 958                 become_daemon(Fork, no_process_group, log_stdout);
 959         }
 960
 961 #if HAVE_SETPGID
 962         /*
 963          * If we're interactive we want to set our own process group for
 964          * signal management.
 965          */
 966         if (opt_interactive && !no_process_group)
 967                 setpgid( (pid_t)0, (pid_t)0 );
 968 #endif
 969
 970 #ifndef SYNC_DNS
 971         /* Setup the async dns. We do it here so it doesn't have all the other
 972                 stuff initialised and thus chewing memory and sockets */
 973         if(lp_we_are_a_wins_server() && lp_wins_dns_proxy()) {
 974                 start_async_dns(msg);
 975         }
 976 #endif
 977
 978         ok = directory_create_or_exist(lp_lock_directory(), 0755);
 979         if (!ok) {
 980                 exit_daemon("Failed to create directory for lock files, check 'lock directory'", errno);
 981         }
 982
 983         ok = directory_create_or_exist(lp_pid_directory(), 0755);
 984         if (!ok) {
 985                 exit_daemon("Failed to create directory for pid files, check 'pid directory'", errno);
 986         }
 987
 988         pidfile_create(lp_pid_directory(), "nmbd");
 989
 990         status = reinit_after_fork(msg, nmbd_event_context(), false, NULL);
 991
 992         if (!NT_STATUS_IS_OK(status)) {
 993                 exit_daemon("reinit_after_fork() failed", map_errno_from_nt_status(status));
 994         }
 995
 996         /*
 997          * Do not initialize the parent-child-pipe before becoming
 998          * a daemon: this is used to detect a died parent in the child
 999          * process.
1000          */
1001         status = init_before_fork();
1002         if (!NT_STATUS_IS_OK(status)) {
1003                 exit_daemon(nt_errstr(status), map_errno_from_nt_status(status));
1004         }
1005
1006         if (!nmbd_setup_sig_term_handler(msg))
1007                 exit_daemon("NMBD failed to setup signal handler", EINVAL);
1008         if (!nmbd_setup_stdin_handler(msg, !Fork))
1009                 exit_daemon("NMBD failed to setup stdin handler", EINVAL);
1010         if (!nmbd_setup_sig_hup_handler(msg))
1011                 exit_daemon("NMBD failed to setup SIGHUP handler", EINVAL);
1012
1013         if (!messaging_parent_dgm_cleanup_init(msg)) {
1014                 exit(1);
1015         }
1016
1017         messaging_register(msg, NULL, MSG_FORCE_ELECTION,
1018                            nmbd_message_election);
1019 #if 0
1020         /* Until winsrepl is done. */
1021         messaging_register(msg, NULL, MSG_WINS_NEW_ENTRY,
1022                            nmbd_wins_new_entry);
1023 #endif
1024         messaging_register(msg, NULL, MSG_SHUTDOWN,
1025                            nmbd_terminate);
1026         messaging_register(msg, NULL, MSG_SMB_CONF_UPDATED,
1027                            msg_reload_nmbd_services);
1028         messaging_register(msg, NULL, MSG_SEND_PACKET,
1029                            msg_nmbd_send_packet);
1030
1031         TimeInit();
1032
1033         DEBUG( 3, ( "Opening sockets %d\n", global_nmb_port ) );
1034
1035         if ( !open_sockets( is_daemon, global_nmb_port ) ) {
1036                 kill_async_dns_child();
1037                 return 1;
1038         }
1039
1040         /* Determine all the IP addresses we have. */
1041         load_interfaces();
1042
1043         /* Create an nmbd subnet record for each of the above. */
1044         if( False == create_subnets() ) {
1045                 kill_async_dns_child();
1046                 exit_daemon("NMBD failed when creating subnet lists", EACCES);
1047         }
1048
1049         /* Load in any static local names. */
1050         if (p_lmhosts) {
1051                 set_dyn_LMHOSTSFILE(p_lmhosts);
1052         }
1053         load_lmhosts_file(get_dyn_LMHOSTSFILE());
1054         DEBUG(3,("Loaded hosts file %s\n", get_dyn_LMHOSTSFILE()));
1055
1056         /* If we are acting as a WINS server, initialise data structures. */
1057         if( !initialise_wins() ) {
1058                 kill_async_dns_child();
1059                 exit_daemon( "NMBD failed when initialising WINS server.", EACCES);
1060         }
1061
1062         /*
1063          * Register nmbd primary workgroup and nmbd names on all
1064          * the broadcast subnets, and on the WINS server (if specified).
1065          * Also initiate the startup of our primary workgroup (start
1066          * elections if we are setup as being able to be a local
1067          * master browser.
1068          */
1069
1070         if( False == register_my_workgroup_and_names() ) {
1071                 kill_async_dns_child();
1072                 exit_daemon( "NMBD failed when creating my workgroup.", EACCES);
1073         }
1074
1075         if (!initialize_nmbd_proxy_logon()) {
1076                 kill_async_dns_child();
1077                 exit_daemon( "NMBD failed to setup nmbd_proxy_logon.", EACCES);
1078         }
1079
1080         if (!nmbd_init_packet_server()) {
1081                 kill_async_dns_child();
1082                 exit_daemon( "NMBD failed to setup packet server.", EACCES);
1083         }
1084
1085         if (is_daemon && !opt_interactive) {
1086                 daemon_ready("nmbd");
1087         }
1088
1089         TALLOC_FREE(frame);
1090         process(msg);
1091
1092         kill_async_dns_child();
1093         return(0);
1094 }