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