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