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