Context Navigation

source: branches/samba-3.3.x/source/nmbd/nmbd.c@ 221

Visit:

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: