Context Navigation

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

Visit:

Last change on this file since 232 was 232, checked in by Herwig Bauernfeind, 16 years ago
Update 3.2 branch to 3.2.8
File size: 25.2 KB

Line
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 && !(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
66	static 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
89	static 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
102	static SIG_ATOMIC_T got_sig_term;
103
104	static 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
114	static SIG_ATOMIC_T reload_after_sighup;
115
116	static 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
126	static void fault_continue(void)
127	{
128	dump_core();
129	}
130
131	/**************************************************************************
132	Expire old names from the namelist and server list.
133	**************************************************************************** */
134
135	static 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
169	static 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
324	static 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
356	static 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
369	static 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
433	static 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
667	static 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
918	if (!reinit_after_fork(nmbd_messaging_context(),
919	nmbd_event_context(), false)) {
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.

Download in other formats: