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 2 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, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21
  22 */
  23
  24 #include "includes.h"
  25
  26 int ClientNMB       = -1;
  27 int ClientDGRAM     = -1;
  28 int global_nmb_port = -1;
  29
  30 extern BOOL global_in_nmbd;
  31
  32 /* are we running as a daemon ? */
  33 static BOOL is_daemon;
  34
  35 /* fork or run in foreground ? */
  36 static BOOL Fork = True;
  37
  38 /* log to standard output ? */
  39 static BOOL log_stdout;
  40
  41 /* have we found LanMan clients yet? */
  42 BOOL found_lm_clients = False;
  43
  44 /* what server type are we currently */
  45
  46 time_t StartupTime = 0;
  47
  48 /**************************************************************************** **
  49  Handle a SIGTERM in band.
  50  **************************************************************************** */
  51
  52 static void terminate(void)
  53 {
  54         DEBUG(0,("Got SIGTERM: going down...\n"));
  55
  56         /* Write out wins.dat file if samba is a WINS server */
  57         wins_write_database(False);
  58
  59         /* Remove all SELF registered names from WINS */
  60         release_wins_names();
  61
  62         /* Announce all server entries as 0 time-to-live, 0 type. */
  63         announce_my_servers_removed();
  64
  65         /* If there was an async dns child - kill it. */
  66         kill_async_dns_child();
  67
  68         exit(0);
  69 }
  70
  71 /**************************************************************************** **
  72  Handle a SHUTDOWN message from smbcontrol.
  73  **************************************************************************** */
  74
  75 static void nmbd_terminate(int msg_type, pid_t src, void *buf, size_t len)
  76 {
  77         terminate();
  78 }
  79
  80 /**************************************************************************** **
  81  Catch a SIGTERM signal.
  82  **************************************************************************** */
  83
  84 static SIG_ATOMIC_T got_sig_term;
  85
  86 static void sig_term(int sig)
  87 {
  88         got_sig_term = 1;
  89         sys_select_signal();
  90 }
  91
  92 /**************************************************************************** **
  93  Catch a SIGHUP signal.
  94  **************************************************************************** */
  95
  96 static SIG_ATOMIC_T reload_after_sighup;
  97
  98 static void sig_hup(int sig)
  99 {
 100         reload_after_sighup = 1;
 101         sys_select_signal();
 102 }
 103
 104 #if DUMP_CORE
 105 /**************************************************************************** **
 106  Prepare to dump a core file - carefully!
 107  **************************************************************************** */
 108
 109 static BOOL dump_core(void)
 110 {
 111         char *p;
 112         pstring dname;
 113         pstrcpy( dname, lp_logfile() );
 114         if ((p=strrchr_m(dname,'/')))
 115                 *p=0;
 116         pstrcat( dname, "/corefiles" );
 117         mkdir( dname, 0700 );
 118         sys_chown( dname, getuid(), getgid() );
 119         chmod( dname, 0700 );
 120         if ( chdir(dname) )
 121                 return( False );
 122         umask( ~(0700) );
 123
 124 #ifdef HAVE_GETRLIMIT
 125 #ifdef RLIMIT_CORE
 126         {
 127                 struct rlimit rlp;
 128                 getrlimit( RLIMIT_CORE, &rlp );
 129                 rlp.rlim_cur = MAX( 4*1024*1024, rlp.rlim_cur );
 130                 setrlimit( RLIMIT_CORE, &rlp );
 131                 getrlimit( RLIMIT_CORE, &rlp );
 132                 DEBUG( 3, ( "Core limits now %d %d\n", (int)rlp.rlim_cur, (int)rlp.rlim_max ) );
 133         }
 134 #endif
 135 #endif
 136
 137
 138         DEBUG(0,("Dumping core in %s\n",dname));
 139         abort();
 140         return( True );
 141 }
 142 #endif
 143
 144 /**************************************************************************** **
 145  Possibly continue after a fault.
 146  **************************************************************************** */
 147
 148 static void fault_continue(void)
 149 {
 150 #if DUMP_CORE
 151         dump_core();
 152 #endif
 153 }
 154
 155 /**************************************************************************** **
 156  Expire old names from the namelist and server list.
 157  **************************************************************************** */
 158
 159 static void expire_names_and_servers(time_t t)
 160 {
 161         static time_t lastrun = 0;
 162
 163         if ( !lastrun )
 164                 lastrun = t;
 165         if ( t < (lastrun + 5) )
 166                 return;
 167         lastrun = t;
 168
 169         /*
 170          * Expire any timed out names on all the broadcast
 171          * subnets and those registered with the WINS server.
 172          * (nmbd_namelistdb.c)
 173          */
 174
 175         expire_names(t);
 176
 177         /*
 178          * Go through all the broadcast subnets and for each
 179          * workgroup known on that subnet remove any expired
 180          * server names. If a workgroup has an empty serverlist
 181          * and has itself timed out then remove the workgroup.
 182          * (nmbd_workgroupdb.c)
 183          */
 184
 185         expire_workgroups_and_servers(t);
 186 }
 187
 188 /************************************************************************** **
 189  Reload the list of network interfaces.
 190  ************************************************************************** */
 191
 192 static BOOL reload_interfaces(time_t t)
 193 {
 194         static time_t lastt;
 195         int n;
 196         struct subnet_record *subrec;
 197         extern BOOL rescan_listen_set;
 198         extern struct in_addr loopback_ip;
 199
 200         if (t && ((t - lastt) < NMBD_INTERFACES_RELOAD)) return False;
 201         lastt = t;
 202
 203         if (!interfaces_changed()) return False;
 204
 205         /* the list of probed interfaces has changed, we may need to add/remove
 206            some subnets */
 207         load_interfaces();
 208
 209         /* find any interfaces that need adding */
 210         for (n=iface_count() - 1; n >= 0; n--) {
 211                 struct interface *iface = get_interface(n);
 212
 213                 /*
 214                  * We don't want to add a loopback interface, in case
 215                  * someone has added 127.0.0.1 for smbd, nmbd needs to
 216                  * ignore it here. JRA.
 217                  */
 218
 219                 if (ip_equal(iface->ip, loopback_ip)) {
 220                         DEBUG(2,("reload_interfaces: Ignoring loopback interface %s\n", inet_ntoa(iface->ip)));
 221                         continue;
 222                 }
 223
 224                 for (subrec=subnetlist; subrec; subrec=subrec->next) {
 225                         if (ip_equal(iface->ip, subrec->myip) &&
 226                             ip_equal(iface->nmask, subrec->mask_ip)) break;
 227                 }
 228
 229                 if (!subrec) {
 230                         /* it wasn't found! add it */
 231                         DEBUG(2,("Found new interface %s\n",
 232                                  inet_ntoa(iface->ip)));
 233                         subrec = make_normal_subnet(iface);
 234                         if (subrec) register_my_workgroup_one_subnet(subrec);
 235                 }
 236         }
 237
 238         /* find any interfaces that need deleting */
 239         for (subrec=subnetlist; subrec; subrec=subrec->next) {
 240                 for (n=iface_count() - 1; n >= 0; n--) {
 241                         struct interface *iface = get_interface(n);
 242                         if (ip_equal(iface->ip, subrec->myip) &&
 243                             ip_equal(iface->nmask, subrec->mask_ip)) break;
 244                 }
 245                 if (n == -1) {
 246                         /* oops, an interface has disapeared. This is
 247                          tricky, we don't dare actually free the
 248                          interface as it could be being used, so
 249                          instead we just wear the memory leak and
 250                          remove it from the list of interfaces without
 251                          freeing it */
 252                         DEBUG(2,("Deleting dead interface %s\n",
 253                                  inet_ntoa(subrec->myip)));
 254                         close_subnet(subrec);
 255                 }
 256         }
 257
 258         rescan_listen_set = True;
 259
 260         /* We need to shutdown if there are no subnets... */
 261         if (FIRST_SUBNET == NULL) {
 262                 DEBUG(0,("reload_interfaces: No subnets to listen to. Shutting down...\n"));
 263                 return True;
 264         }
 265         return False;
 266 }
 267
 268 /**************************************************************************** **
 269  Reload the services file.
 270  **************************************************************************** */
 271
 272 static BOOL reload_nmbd_services(BOOL test)
 273 {
 274         BOOL ret;
 275
 276         set_remote_machine_name("nmbd", False);
 277
 278         if ( lp_loaded() ) {
 279                 pstring fname;
 280                 pstrcpy( fname,lp_configfile());
 281                 if (file_exist(fname,NULL) && !strcsequal(fname,dyn_CONFIGFILE)) {
 282                         pstrcpy(dyn_CONFIGFILE,fname);
 283                         test = False;
 284                 }
 285         }
 286
 287         if ( test && !lp_file_list_changed() )
 288                 return(True);
 289
 290         ret = lp_load( dyn_CONFIGFILE, True , False, False);
 291
 292         /* perhaps the config filename is now set */
 293         if ( !test ) {
 294                 DEBUG( 3, ( "services not loaded\n" ) );
 295                 reload_nmbd_services( True );
 296         }
 297
 298         return(ret);
 299 }
 300
 301 /**************************************************************************** **
 302  * React on 'smbcontrol nmbd reload-config' in the same way as to SIGHUP
 303  * We use buf here to return BOOL result to process() when reload_interfaces()
 304  * detects that there are no subnets.
 305  **************************************************************************** */
 306
 307 static void msg_reload_nmbd_services(int msg_type, pid_t src, void *buf, size_t len)
 308 {
 309         write_browse_list( 0, True );
 310         dump_all_namelists();
 311         reload_nmbd_services( True );
 312         reopen_logs();
 313
 314         if(buf) {
 315                 /* We were called from process() */
 316                 /* If reload_interfaces() returned True */
 317                 /* we need to shutdown if there are no subnets... */
 318                 /* pass this info back to process() */
 319                 *((BOOL*)buf) = reload_interfaces(0);
 320         }
 321 }
 322
 323
 324 /**************************************************************************** **
 325  The main select loop.
 326  **************************************************************************** */
 327
 328 static void process(void)
 329 {
 330         BOOL run_election;
 331         BOOL no_subnets;
 332
 333         while( True ) {
 334                 time_t t = time(NULL);
 335
 336                 /* Check for internal messages */
 337
 338                 message_dispatch();
 339
 340                 /*
 341                  * Check all broadcast subnets to see if
 342                  * we need to run an election on any of them.
 343                  * (nmbd_elections.c)
 344                  */
 345
 346                 run_election = check_elections();
 347
 348                 /*
 349                  * Read incoming UDP packets.
 350                  * (nmbd_packets.c)
 351                  */
 352
 353                 if(listen_for_packets(run_election))
 354                         return;
 355
 356                 /*
 357                  * Handle termination inband.
 358                  */
 359
 360                 if (got_sig_term) {
 361                         got_sig_term = 0;
 362                         terminate();
 363                 }
 364
 365                 /*
 366                  * Process all incoming packets
 367                  * read above. This calls the success and
 368                  * failure functions registered when response
 369                  * packets arrrive, and also deals with request
 370                  * packets from other sources.
 371                  * (nmbd_packets.c)
 372                  */
 373
 374                 run_packet_queue();
 375
 376                 /*
 377                  * Run any elections - initiate becoming
 378                  * a local master browser if we have won.
 379                  * (nmbd_elections.c)
 380                  */
 381
 382                 run_elections(t);
 383
 384                 /*
 385                  * Send out any broadcast announcements
 386                  * of our server names. This also announces
 387                  * the workgroup name if we are a local
 388                  * master browser.
 389                  * (nmbd_sendannounce.c)
 390                  */
 391
 392                 announce_my_server_names(t);
 393
 394                 /*
 395                  * Send out any LanMan broadcast announcements
 396                  * of our server names.
 397                  * (nmbd_sendannounce.c)
 398                  */
 399
 400                 announce_my_lm_server_names(t);
 401
 402                 /*
 403                  * If we are a local master browser, periodically
 404                  * announce ourselves to the domain master browser.
 405                  * This also deals with syncronising the domain master
 406                  * browser server lists with ourselves as a local
 407                  * master browser.
 408                  * (nmbd_sendannounce.c)
 409                  */
 410
 411                 announce_myself_to_domain_master_browser(t);
 412
 413                 /*
 414                  * Fullfill any remote announce requests.
 415                  * (nmbd_sendannounce.c)
 416                  */
 417
 418                 announce_remote(t);
 419
 420                 /*
 421                  * Fullfill any remote browse sync announce requests.
 422                  * (nmbd_sendannounce.c)
 423                  */
 424
 425                 browse_sync_remote(t);
 426
 427                 /*
 428                  * Scan the broadcast subnets, and WINS client
 429                  * namelists and refresh any that need refreshing.
 430                  * (nmbd_mynames.c)
 431                  */
 432
 433                 refresh_my_names(t);
 434
 435                 /*
 436                  * Scan the subnet namelists and server lists and
 437                  * expire thos that have timed out.
 438                  * (nmbd.c)
 439                  */
 440
 441                 expire_names_and_servers(t);
 442
 443                 /*
 444                  * Write out a snapshot of our current browse list into
 445                  * the browse.dat file. This is used by smbd to service
 446                  * incoming NetServerEnum calls - used to synchronise
 447                  * browse lists over subnets.
 448                  * (nmbd_serverlistdb.c)
 449                  */
 450
 451                 write_browse_list(t, False);
 452
 453                 /*
 454                  * If we are a domain master browser, we have a list of
 455                  * local master browsers we should synchronise browse
 456                  * lists with (these are added by an incoming local
 457                  * master browser announcement packet). Expire any of
 458                  * these that are no longer current, and pull the server
 459                  * lists from each of these known local master browsers.
 460                  * (nmbd_browsesync.c)
 461                  */
 462
 463                 dmb_expire_and_sync_browser_lists(t);
 464
 465                 /*
 466                  * Check that there is a local master browser for our
 467                  * workgroup for all our broadcast subnets. If one
 468                  * is not found, start an election (which we ourselves
 469                  * may or may not participate in, depending on the
 470                  * setting of the 'local master' parameter.
 471                  * (nmbd_elections.c)
 472                  */
 473
 474                 check_master_browser_exists(t);
 475
 476                 /*
 477                  * If we are configured as a logon server, attempt to
 478                  * register the special NetBIOS names to become such
 479                  * (WORKGROUP<1c> name) on all broadcast subnets and
 480                  * with the WINS server (if used). If we are configured
 481                  * to become a domain master browser, attempt to register
 482                  * the special NetBIOS name (WORKGROUP<1b> name) to
 483                  * become such.
 484                  * (nmbd_become_dmb.c)
 485                  */
 486
 487                 add_domain_names(t);
 488
 489                 /*
 490                  * If we are a WINS server, do any timer dependent
 491                  * processing required.
 492                  * (nmbd_winsserver.c)
 493                  */
 494
 495                 initiate_wins_processing(t);
 496
 497                 /*
 498                  * If we are a domain master browser, attempt to contact the
 499                  * WINS server to get a list of all known WORKGROUPS/DOMAINS.
 500                  * This will only work to a Samba WINS server.
 501                  * (nmbd_browsesync.c)
 502                  */
 503
 504                 if (lp_enhanced_browsing())
 505                         collect_all_workgroup_names_from_wins_server(t);
 506
 507                 /*
 508                  * Go through the response record queue and time out or re-transmit
 509                  * and expired entries.
 510                  * (nmbd_packets.c)
 511                  */
 512
 513                 retransmit_or_expire_response_records(t);
 514
 515                 /*
 516                  * check to see if any remote browse sync child processes have completed
 517                  */
 518
 519                 sync_check_completion();
 520
 521                 /*
 522                  * regularly sync with any other DMBs we know about
 523                  */
 524
 525                 if (lp_enhanced_browsing())
 526                         sync_all_dmbs(t);
 527
 528                 /*
 529                  * clear the unexpected packet queue
 530                  */
 531
 532                 clear_unexpected(t);
 533
 534                 /*
 535                  * Reload the services file if we got a sighup.
 536                  */
 537
 538                 if(reload_after_sighup) {
 539                         DEBUG( 0, ( "Got SIGHUP dumping debug info.\n" ) );
 540                         msg_reload_nmbd_services(MSG_SMB_CONF_UPDATED, (pid_t) 0, (void*) &no_subnets, 0);
 541                         if(no_subnets)
 542                                 return;
 543                         reload_after_sighup = 0;
 544                 }
 545
 546                 /* check for new network interfaces */
 547
 548                 if(reload_interfaces(t))
 549                         return;
 550
 551                 /* free up temp memory */
 552                         lp_talloc_free();
 553         }
 554 }
 555
 556 /**************************************************************************** **
 557  Open the socket communication.
 558  **************************************************************************** */
 559
 560 static BOOL open_sockets(BOOL isdaemon, int port)
 561 {
 562         /*
 563          * The sockets opened here will be used to receive broadcast
 564          * packets *only*. Interface specific sockets are opened in
 565          * make_subnet() in namedbsubnet.c. Thus we bind to the
 566          * address "0.0.0.0". The parameter 'socket address' is
 567          * now deprecated.
 568          */
 569
 570         if ( isdaemon )
 571                 ClientNMB = open_socket_in(SOCK_DGRAM, port,
 572                                            interpret_addr(lp_socket_address()),
 573                                            0,True);
 574         else
 575                 ClientNMB = 0;
 576
 577         ClientDGRAM = open_socket_in(SOCK_DGRAM,DGRAM_PORT,3,0,True);
 578
 579         if ( ClientNMB == -1 )
 580                 return( False );
 581
 582         /* we are never interested in SIGPIPE */
 583         BlockSignals(True,SIGPIPE);
 584
 585         set_socket_options( ClientNMB,   "SO_BROADCAST" );
 586         set_socket_options( ClientDGRAM, "SO_BROADCAST" );
 587
 588         DEBUG( 3, ( "open_sockets: Broadcast sockets opened.\n" ) );
 589         return( True );
 590 }
 591
 592 /**************************************************************************** **
 593  main program
 594  **************************************************************************** */
 595  int main(int argc, const char *argv[])
 596 {
 597         pstring logfile;
 598         static BOOL opt_interactive;
 599         poptContext pc;
 600         int opt;
 601         struct poptOption long_options[] = {
 602         POPT_AUTOHELP
 603         {"daemon", 'D', POPT_ARG_VAL, &is_daemon, True, "Become a daemon(default)" },
 604         {"interactive", 'i', POPT_ARG_VAL, &opt_interactive, True, "Run interactive (not a daemon)" },
 605         {"foreground", 'F', POPT_ARG_VAL, &Fork, False, "Run daemon in foreground (for daemontools & etc)" },
 606         {"log-stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
 607         {"hosts", 'H', POPT_ARG_STRING, dyn_LMHOSTSFILE, 'H', "Load a netbios hosts file"},
 608         {"port", 'p', POPT_ARG_INT, &global_nmb_port, NMB_PORT, "Listen on the specified port" },
 609         POPT_COMMON_SAMBA
 610         { NULL }
 611         };
 612
 613         global_nmb_port = NMB_PORT;
 614
 615         pc = poptGetContext("nmbd", argc, argv, long_options, 0);
 616         while ((opt = poptGetNextOpt(pc)) != -1) ;
 617         poptFreeContext(pc);
 618
 619         global_in_nmbd = True;
 620
 621         StartupTime = time(NULL);
 622
 623         sys_srandom(time(NULL) ^ sys_getpid());
 624
 625         slprintf(logfile, sizeof(logfile)-1, "%s/log.nmbd", dyn_LOGFILEBASE);
 626         lp_set_logfile(logfile);
 627
 628         fault_setup((void (*)(void *))fault_continue );
 629
 630         /* POSIX demands that signals are inherited. If the invoking process has
 631          * these signals masked, we will have problems, as we won't receive them. */
 632         BlockSignals(False, SIGHUP);
 633         BlockSignals(False, SIGUSR1);
 634         BlockSignals(False, SIGTERM);
 635
 636         CatchSignal( SIGHUP,  SIGNAL_CAST sig_hup );
 637         CatchSignal( SIGTERM, SIGNAL_CAST sig_term );
 638
 639 #if defined(SIGFPE)
 640         /* we are never interested in SIGFPE */
 641         BlockSignals(True,SIGFPE);
 642 #endif
 643
 644         /* We no longer use USR2... */
 645 #if defined(SIGUSR2)
 646         BlockSignals(True, SIGUSR2);
 647 #endif
 648
 649         if ( opt_interactive ) {
 650                 Fork = False;
 651                 log_stdout = True;
 652         }
 653
 654         if ( log_stdout && Fork ) {
 655                 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 656                 exit(1);
 657         }
 658
 659         setup_logging( argv[0], log_stdout );
 660
 661         reopen_logs();
 662
 663         DEBUG( 0, ( "Netbios nameserver version %s started.\n", SAMBA_VERSION_STRING) );
 664         DEBUGADD( 0, ( "Copyright Andrew Tridgell and the Samba Team 1994-2003\n" ) );
 665
 666         if ( !reload_nmbd_services(False) )
 667                 return(-1);
 668
 669         if(!init_names())
 670                 return -1;
 671
 672         reload_nmbd_services( True );
 673
 674         if (strequal(lp_workgroup(),"*")) {
 675                 DEBUG(0,("ERROR: a workgroup name of * is no longer supported\n"));
 676                 exit(1);
 677         }
 678
 679         set_samba_nb_type();
 680
 681         if (!is_daemon && !is_a_socket(0)) {
 682                 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
 683                 is_daemon = True;
 684         }
 685
 686         if (is_daemon && !opt_interactive) {
 687                 DEBUG( 2, ( "Becoming a daemon.\n" ) );
 688                 become_daemon(Fork);
 689         }
 690
 691 #if HAVE_SETPGID
 692         /*
 693          * If we're interactive we want to set our own process group for
 694          * signal management.
 695          */
 696         if (opt_interactive)
 697                 setpgid( (pid_t)0, (pid_t)0 );
 698 #endif
 699
 700 #ifndef SYNC_DNS
 701         /* Setup the async dns. We do it here so it doesn't have all the other
 702                 stuff initialised and thus chewing memory and sockets */
 703         if(lp_we_are_a_wins_server() && lp_dns_proxy()) {
 704                 start_async_dns();
 705         }
 706 #endif
 707
 708         if (!directory_exist(lp_lockdir(), NULL)) {
 709                 mkdir(lp_lockdir(), 0755);
 710         }
 711
 712         pidfile_create("nmbd");
 713         message_init();
 714         message_register(MSG_FORCE_ELECTION, nmbd_message_election);
 715         message_register(MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry);
 716         message_register(MSG_SHUTDOWN, nmbd_terminate);
 717         message_register(MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services);
 718
 719         DEBUG( 3, ( "Opening sockets %d\n", global_nmb_port ) );
 720
 721         if ( !open_sockets( is_daemon, global_nmb_port ) ) {
 722                 kill_async_dns_child();
 723                 return 1;
 724         }
 725
 726         /* Determine all the IP addresses we have. */
 727         load_interfaces();
 728
 729         /* Create an nmbd subnet record for each of the above. */
 730         if( False == create_subnets() ) {
 731                 DEBUG(0,("ERROR: Failed when creating subnet lists. Exiting.\n"));
 732                 kill_async_dns_child();
 733                 exit(1);
 734         }
 735
 736         /* Load in any static local names. */
 737         load_lmhosts_file(dyn_LMHOSTSFILE);
 738         DEBUG(3,("Loaded hosts file %s\n", dyn_LMHOSTSFILE));
 739
 740         /* If we are acting as a WINS server, initialise data structures. */
 741         if( !initialise_wins() ) {
 742                 DEBUG( 0, ( "nmbd: Failed when initialising WINS server.\n" ) );
 743                 kill_async_dns_child();
 744                 exit(1);
 745         }
 746
 747         /*
 748          * Register nmbd primary workgroup and nmbd names on all
 749          * the broadcast subnets, and on the WINS server (if specified).
 750          * Also initiate the startup of our primary workgroup (start
 751          * elections if we are setup as being able to be a local
 752          * master browser.
 753          */
 754
 755         if( False == register_my_workgroup_and_names() ) {
 756                 DEBUG(0,("ERROR: Failed when creating my my workgroup. Exiting.\n"));
 757                 kill_async_dns_child();
 758                 exit(1);
 759         }
 760
 761         /* We can only take signals in the select. */
 762         BlockSignals( True, SIGTERM );
 763
 764         process();
 765
 766         if (dbf)
 767                 x_fclose(dbf);
 768         kill_async_dns_child();
 769         return(0);
 770 }