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 static void msg_reload_nmbd_services(int msg_type, pid_t src, void *buf, size_t len)
 307 {
 308         write_browse_list( 0, True );
 309         dump_all_namelists();
 310         reload_nmbd_services( True );
 311         reopen_logs();
 312
 313         if(buf) {
 314                 /* We were called from process() */
 315                 /* If reload_interfaces() returned True */
 316                 /* we need to shutdown if there are no subnets... */
 317                 /* pass this info back to process() */
 318                 *((BOOL*)buf) = reload_interfaces(0);
 319         }
 320 }
 321
 322
 323 /**************************************************************************** **
 324  The main select loop.
 325  **************************************************************************** */
 326
 327 static void process(void)
 328 {
 329         BOOL run_election;
 330         BOOL no_subnets;
 331
 332         while( True ) {
 333                 time_t t = time(NULL);
 334
 335                 /* Check for internal messages */
 336
 337                 message_dispatch();
 338
 339                 /*
 340                  * Check all broadcast subnets to see if
 341                  * we need to run an election on any of them.
 342                  * (nmbd_elections.c)
 343                  */
 344
 345                 run_election = check_elections();
 346
 347                 /*
 348                  * Read incoming UDP packets.
 349                  * (nmbd_packets.c)
 350                  */
 351
 352                 if(listen_for_packets(run_election))
 353                         return;
 354
 355                 /*
 356                  * Handle termination inband.
 357                  */
 358
 359                 if (got_sig_term) {
 360                         got_sig_term = 0;
 361                         terminate();
 362                 }
 363
 364                 /*
 365                  * Process all incoming packets
 366                  * read above. This calls the success and
 367                  * failure functions registered when response
 368                  * packets arrrive, and also deals with request
 369                  * packets from other sources.
 370                  * (nmbd_packets.c)
 371                  */
 372
 373                 run_packet_queue();
 374
 375                 /*
 376                  * Run any elections - initiate becoming
 377                  * a local master browser if we have won.
 378                  * (nmbd_elections.c)
 379                  */
 380
 381                 run_elections(t);
 382
 383                 /*
 384                  * Send out any broadcast announcements
 385                  * of our server names. This also announces
 386                  * the workgroup name if we are a local
 387                  * master browser.
 388                  * (nmbd_sendannounce.c)
 389                  */
 390
 391                 announce_my_server_names(t);
 392
 393                 /*
 394                  * Send out any LanMan broadcast announcements
 395                  * of our server names.
 396                  * (nmbd_sendannounce.c)
 397                  */
 398
 399                 announce_my_lm_server_names(t);
 400
 401                 /*
 402                  * If we are a local master browser, periodically
 403                  * announce ourselves to the domain master browser.
 404                  * This also deals with syncronising the domain master
 405                  * browser server lists with ourselves as a local
 406                  * master browser.
 407                  * (nmbd_sendannounce.c)
 408                  */
 409
 410                 announce_myself_to_domain_master_browser(t);
 411
 412                 /*
 413                  * Fullfill any remote announce requests.
 414                  * (nmbd_sendannounce.c)
 415                  */
 416
 417                 announce_remote(t);
 418
 419                 /*
 420                  * Fullfill any remote browse sync announce requests.
 421                  * (nmbd_sendannounce.c)
 422                  */
 423
 424                 browse_sync_remote(t);
 425
 426                 /*
 427                  * Scan the broadcast subnets, and WINS client
 428                  * namelists and refresh any that need refreshing.
 429                  * (nmbd_mynames.c)
 430                  */
 431
 432                 refresh_my_names(t);
 433
 434                 /*
 435                  * Scan the subnet namelists and server lists and
 436                  * expire thos that have timed out.
 437                  * (nmbd.c)
 438                  */
 439
 440                 expire_names_and_servers(t);
 441
 442                 /*
 443                  * Write out a snapshot of our current browse list into
 444                  * the browse.dat file. This is used by smbd to service
 445                  * incoming NetServerEnum calls - used to synchronise
 446                  * browse lists over subnets.
 447                  * (nmbd_serverlistdb.c)
 448                  */
 449
 450                 write_browse_list(t, False);
 451
 452                 /*
 453                  * If we are a domain master browser, we have a list of
 454                  * local master browsers we should synchronise browse
 455                  * lists with (these are added by an incoming local
 456                  * master browser announcement packet). Expire any of
 457                  * these that are no longer current, and pull the server
 458                  * lists from each of these known local master browsers.
 459                  * (nmbd_browsesync.c)
 460                  */
 461
 462                 dmb_expire_and_sync_browser_lists(t);
 463
 464                 /*
 465                  * Check that there is a local master browser for our
 466                  * workgroup for all our broadcast subnets. If one
 467                  * is not found, start an election (which we ourselves
 468                  * may or may not participate in, depending on the
 469                  * setting of the 'local master' parameter.
 470                  * (nmbd_elections.c)
 471                  */
 472
 473                 check_master_browser_exists(t);
 474
 475                 /*
 476                  * If we are configured as a logon server, attempt to
 477                  * register the special NetBIOS names to become such
 478                  * (WORKGROUP<1c> name) on all broadcast subnets and
 479                  * with the WINS server (if used). If we are configured
 480                  * to become a domain master browser, attempt to register
 481                  * the special NetBIOS name (WORKGROUP<1b> name) to
 482                  * become such.
 483                  * (nmbd_become_dmb.c)
 484                  */
 485
 486                 add_domain_names(t);
 487
 488                 /*
 489                  * If we are a WINS server, do any timer dependent
 490                  * processing required.
 491                  * (nmbd_winsserver.c)
 492                  */
 493
 494                 initiate_wins_processing(t);
 495
 496                 /*
 497                  * If we are a domain master browser, attempt to contact the
 498                  * WINS server to get a list of all known WORKGROUPS/DOMAINS.
 499                  * This will only work to a Samba WINS server.
 500                  * (nmbd_browsesync.c)
 501                  */
 502
 503                 if (lp_enhanced_browsing())
 504                         collect_all_workgroup_names_from_wins_server(t);
 505
 506                 /*
 507                  * Go through the response record queue and time out or re-transmit
 508                  * and expired entries.
 509                  * (nmbd_packets.c)
 510                  */
 511
 512                 retransmit_or_expire_response_records(t);
 513
 514                 /*
 515                  * check to see if any remote browse sync child processes have completed
 516                  */
 517
 518                 sync_check_completion();
 519
 520                 /*
 521                  * regularly sync with any other DMBs we know about
 522                  */
 523
 524                 if (lp_enhanced_browsing())
 525                         sync_all_dmbs(t);
 526
 527                 /*
 528                  * clear the unexpected packet queue
 529                  */
 530
 531                 clear_unexpected(t);
 532
 533                 /*
 534                  * Reload the services file if we got a sighup.
 535                  */
 536
 537                 if(reload_after_sighup) {
 538                         DEBUG( 0, ( "Got SIGHUP dumping debug info.\n" ) );
 539                         msg_reload_nmbd_services(MSG_SMB_CONF_UPDATED, (pid_t) 0, (void*) &no_subnets, 0);
 540                         if(no_subnets)
 541                                 return;
 542                         reload_after_sighup = 0;
 543                 }
 544
 545                 /* check for new network interfaces */
 546
 547                 if(reload_interfaces(t))
 548                         return;
 549
 550                 /* free up temp memory */
 551                         lp_talloc_free();
 552         }
 553 }
 554
 555 /**************************************************************************** **
 556  Open the socket communication.
 557  **************************************************************************** */
 558
 559 static BOOL open_sockets(BOOL isdaemon, int port)
 560 {
 561         /*
 562          * The sockets opened here will be used to receive broadcast
 563          * packets *only*. Interface specific sockets are opened in
 564          * make_subnet() in namedbsubnet.c. Thus we bind to the
 565          * address "0.0.0.0". The parameter 'socket address' is
 566          * now deprecated.
 567          */
 568
 569         if ( isdaemon )
 570                 ClientNMB = open_socket_in(SOCK_DGRAM, port,
 571                                            interpret_addr(lp_socket_address()),
 572                                            0,True);
 573         else
 574                 ClientNMB = 0;
 575
 576         ClientDGRAM = open_socket_in(SOCK_DGRAM,DGRAM_PORT,3,0,True);
 577
 578         if ( ClientNMB == -1 )
 579                 return( False );
 580
 581         /* we are never interested in SIGPIPE */
 582         BlockSignals(True,SIGPIPE);
 583
 584         set_socket_options( ClientNMB,   "SO_BROADCAST" );
 585         set_socket_options( ClientDGRAM, "SO_BROADCAST" );
 586
 587         DEBUG( 3, ( "open_sockets: Broadcast sockets opened.\n" ) );
 588         return( True );
 589 }
 590
 591 /**************************************************************************** **
 592  main program
 593  **************************************************************************** */
 594  int main(int argc, const char *argv[])
 595 {
 596         pstring logfile;
 597         static BOOL opt_interactive;
 598         poptContext pc;
 599         int opt;
 600         struct poptOption long_options[] = {
 601         POPT_AUTOHELP
 602         {"daemon", 'D', POPT_ARG_VAL, &is_daemon, True, "Become a daemon(default)" },
 603         {"interactive", 'i', POPT_ARG_VAL, &opt_interactive, True, "Run interactive (not a daemon)" },
 604         {"foreground", 'F', POPT_ARG_VAL, &Fork, False, "Run daemon in foreground (for daemontools & etc)" },
 605         {"log-stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
 606         {"hosts", 'H', POPT_ARG_STRING, dyn_LMHOSTSFILE, 'H', "Load a netbios hosts file"},
 607         {"port", 'p', POPT_ARG_INT, &global_nmb_port, NMB_PORT, "Listen on the specified port" },
 608         POPT_COMMON_SAMBA
 609         { NULL }
 610         };
 611
 612         global_nmb_port = NMB_PORT;
 613
 614         pc = poptGetContext("nmbd", argc, argv, long_options, 0);
 615         while ((opt = poptGetNextOpt(pc)) != -1) ;
 616         poptFreeContext(pc);
 617
 618         global_in_nmbd = True;
 619
 620         StartupTime = time(NULL);
 621
 622         sys_srandom(time(NULL) ^ sys_getpid());
 623
 624         slprintf(logfile, sizeof(logfile)-1, "%s/log.nmbd", dyn_LOGFILEBASE);
 625         lp_set_logfile(logfile);
 626
 627         fault_setup((void (*)(void *))fault_continue );
 628
 629         /* POSIX demands that signals are inherited. If the invoking process has
 630          * these signals masked, we will have problems, as we won't receive them. */
 631         BlockSignals(False, SIGHUP);
 632         BlockSignals(False, SIGUSR1);
 633         BlockSignals(False, SIGTERM);
 634
 635         CatchSignal( SIGHUP,  SIGNAL_CAST sig_hup );
 636         CatchSignal( SIGTERM, SIGNAL_CAST sig_term );
 637
 638 #if defined(SIGFPE)
 639         /* we are never interested in SIGFPE */
 640         BlockSignals(True,SIGFPE);
 641 #endif
 642
 643         /* We no longer use USR2... */
 644 #if defined(SIGUSR2)
 645         BlockSignals(True, SIGUSR2);
 646 #endif
 647
 648         if ( opt_interactive ) {
 649                 Fork = False;
 650                 log_stdout = True;
 651         }
 652
 653   if ( log_stdout && Fork ) {
 654     DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
 655     exit(1);
 656   }
 657
 658   setup_logging( argv[0], log_stdout );
 659
 660   reopen_logs();
 661
 662   DEBUG( 0, ( "Netbios nameserver version %s started.\n", VERSION ) );
 663   DEBUGADD( 0, ( "Copyright Andrew Tridgell and the Samba Team 1994-2003\n" ) );
 664
 665   if ( !reload_nmbd_services(False) )
 666     return(-1);
 667
 668   if(!init_names())
 669     return -1;
 670
 671   reload_nmbd_services( True );
 672
 673   if (strequal(lp_workgroup(),"*"))
 674   {
 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   {
 683     DEBUG(0,("standard input is not a socket, assuming -D option\n"));
 684     is_daemon = True;
 685   }
 686
 687   if (is_daemon && !opt_interactive)
 688   {
 689     DEBUG( 2, ( "Becoming a daemon.\n" ) );
 690     become_daemon(Fork);
 691   }
 692
 693 #if HAVE_SETPGID
 694   /*
 695    * If we're interactive we want to set our own process group for
 696    * signal management.
 697    */
 698   if (opt_interactive)
 699     setpgid( (pid_t)0, (pid_t)0 );
 700 #endif
 701
 702 #ifndef SYNC_DNS
 703   /* Setup the async dns. We do it here so it doesn't have all the other
 704      stuff initialised and thus chewing memory and sockets */
 705   if(lp_we_are_a_wins_server() && lp_dns_proxy()) {
 706           start_async_dns();
 707   }
 708 #endif
 709
 710   if (!directory_exist(lp_lockdir(), NULL)) {
 711           mkdir(lp_lockdir(), 0755);
 712   }
 713
 714   pidfile_create("nmbd");
 715   message_init();
 716   message_register(MSG_FORCE_ELECTION, nmbd_message_election);
 717   message_register(MSG_WINS_NEW_ENTRY, nmbd_wins_new_entry);
 718   message_register(MSG_SHUTDOWN, nmbd_terminate);
 719   message_register(MSG_SMB_CONF_UPDATED, msg_reload_nmbd_services);
 720
 721   DEBUG( 3, ( "Opening sockets %d\n", global_nmb_port ) );
 722
 723   if ( !open_sockets( is_daemon, global_nmb_port ) ) {
 724     kill_async_dns_child();
 725     return 1;
 726   }
 727
 728   /* Determine all the IP addresses we have. */
 729   load_interfaces();
 730
 731   /* Create an nmbd subnet record for each of the above. */
 732   if( False == create_subnets() )
 733   {
 734     DEBUG(0,("ERROR: Failed when creating subnet lists. Exiting.\n"));
 735     kill_async_dns_child();
 736     exit(1);
 737   }
 738
 739   /* Load in any static local names. */
 740   load_lmhosts_file(dyn_LMHOSTSFILE);
 741   DEBUG(3,("Loaded hosts file %s\n", dyn_LMHOSTSFILE));
 742
 743   /* If we are acting as a WINS server, initialise data structures. */
 744   if( !initialise_wins() )
 745   {
 746     DEBUG( 0, ( "nmbd: Failed when initialising WINS server.\n" ) );
 747     kill_async_dns_child();
 748     exit(1);
 749   }
 750
 751   /*
 752    * Register nmbd primary workgroup and nmbd names on all
 753    * the broadcast subnets, and on the WINS server (if specified).
 754    * Also initiate the startup of our primary workgroup (start
 755    * elections if we are setup as being able to be a local
 756    * master browser.
 757    */
 758
 759   if( False == register_my_workgroup_and_names() )
 760   {
 761     DEBUG(0,("ERROR: Failed when creating my my workgroup. Exiting.\n"));
 762     kill_async_dns_child();
 763     exit(1);
 764   }
 765
 766   /* We can only take signals in the select. */
 767   BlockSignals( True, SIGTERM );
 768
 769   process();
 770
 771   if (dbf)
 772     x_fclose(dbf);
 773   kill_async_dns_child();
 774   return(0);
 775 }