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