source: branches/samba-3.2.x/source/nmbd/nmbd.c

Last change on this file was 232, checked in by Herwig Bauernfeind, 16 years ago

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