2 Unix SMB/CIFS implementation.
3 Main SMB server routines
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Martin Pool 2002
6 Copyright (C) Jelmer Vernooij 2002-2003
7 Copyright (C) Volker Lendecke 1993-2007
8 Copyright (C) Jeremy Allison 1993-2007
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "smbd/globals.h"
30 extern int dcelogin_atmost_once;
33 int smbd_server_fd(void)
38 static void smbd_set_server_fd(int fd)
43 int get_client_fd(void)
48 struct event_context *smbd_event_context(void)
50 if (!smbd_event_ctx) {
51 smbd_event_ctx = event_context_init(talloc_autofree_context());
53 if (!smbd_event_ctx) {
54 smb_panic("Could not init smbd event context");
56 return smbd_event_ctx;
59 struct messaging_context *smbd_messaging_context(void)
61 if (smbd_msg_ctx == NULL) {
62 smbd_msg_ctx = messaging_init(talloc_autofree_context(),
64 smbd_event_context());
66 if (smbd_msg_ctx == NULL) {
67 DEBUG(0, ("Could not init smbd messaging context.\n"));
72 struct memcache *smbd_memcache(void)
74 if (!smbd_memcache_ctx) {
75 smbd_memcache_ctx = memcache_init(talloc_autofree_context(),
76 lp_max_stat_cache_size()*1024);
78 if (!smbd_memcache_ctx) {
79 smb_panic("Could not init smbd memcache");
82 return smbd_memcache_ctx;
85 /*******************************************************************
86 What to do when smb.conf is updated.
87 ********************************************************************/
89 static void smb_conf_updated(struct messaging_context *msg,
92 struct server_id server_id,
95 DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
96 "updated. Reloading.\n"));
97 reload_services(False);
101 /*******************************************************************
102 Delete a statcache entry.
103 ********************************************************************/
105 static void smb_stat_cache_delete(struct messaging_context *msg,
108 struct server_id server_id,
111 const char *name = (const char *)data->data;
112 DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
113 stat_cache_delete(name);
116 /****************************************************************************
117 Send a SIGTERM to our process group.
118 *****************************************************************************/
120 static void killkids(void)
122 if(am_parent) kill(0,SIGTERM);
125 /****************************************************************************
126 Process a sam sync message - not sure whether to do this here or
128 ****************************************************************************/
130 static void msg_sam_sync(struct messaging_context *msg,
133 struct server_id server_id,
136 DEBUG(10, ("** sam sync message received, ignoring\n"));
139 static void msg_exit_server(struct messaging_context *msg,
142 struct server_id server_id,
145 DEBUG(3, ("got a SHUTDOWN message\n"));
146 exit_server_cleanly(NULL);
150 static void msg_inject_fault(struct messaging_context *msg,
153 struct server_id src,
158 if (data->length != sizeof(sig)) {
160 DEBUG(0, ("Process %s sent bogus signal injection request\n",
161 procid_str_static(&src)));
165 sig = *(int *)data->data;
167 exit_server("internal error injected");
172 DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
173 procid_str_static(&src), sig, strsignal(sig)));
175 DEBUG(0, ("Process %s requested injection of signal %d\n",
176 procid_str_static(&src), sig));
179 kill(sys_getpid(), sig);
181 #endif /* DEVELOPER */
184 struct child_pid *prev, *next;
188 static void add_child_pid(pid_t pid)
190 struct child_pid *child;
192 if (lp_max_smbd_processes() == 0) {
193 /* Don't bother with the child list if we don't care anyway */
197 child = SMB_MALLOC_P(struct child_pid);
199 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
203 DLIST_ADD(children, child);
207 static void remove_child_pid(pid_t pid, bool unclean_shutdown)
209 struct child_pid *child;
211 if (unclean_shutdown) {
212 /* a child terminated uncleanly so tickle all processes to see
213 if they can grab any of the pending locks
215 DEBUG(3,(__location__ " Unclean shutdown of pid %u\n", pid));
216 messaging_send_buf(smbd_messaging_context(), procid_self(),
217 MSG_SMB_BRL_VALIDATE, NULL, 0);
218 message_send_all(smbd_messaging_context(),
219 MSG_SMB_UNLOCK, NULL, 0, NULL);
222 if (lp_max_smbd_processes() == 0) {
223 /* Don't bother with the child list if we don't care anyway */
227 for (child = children; child != NULL; child = child->next) {
228 if (child->pid == pid) {
229 struct child_pid *tmp = child;
230 DLIST_REMOVE(children, child);
237 DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid));
240 /****************************************************************************
241 Have we reached the process limit ?
242 ****************************************************************************/
244 static bool allowable_number_of_smbd_processes(void)
246 int max_processes = lp_max_smbd_processes();
251 return num_children < max_processes;
254 static void smbd_sig_chld_handler(struct tevent_context *ev,
255 struct tevent_signal *se,
264 while ((pid = sys_waitpid(-1, &status, WNOHANG)) > 0) {
265 bool unclean_shutdown = False;
267 /* If the child terminated normally, assume
268 it was an unclean shutdown unless the
271 if (WIFEXITED(status)) {
272 unclean_shutdown = WEXITSTATUS(status);
274 /* If the child terminated due to a signal
275 we always assume it was unclean.
277 if (WIFSIGNALED(status)) {
278 unclean_shutdown = True;
280 remove_child_pid(pid, unclean_shutdown);
284 static void smbd_setup_sig_chld_handler(void)
286 struct tevent_signal *se;
288 se = tevent_add_signal(smbd_event_context(),
289 smbd_event_context(),
291 smbd_sig_chld_handler,
294 exit_server("failed to setup SIGCHLD handler");
298 /****************************************************************************
299 Open the socket communication.
300 ****************************************************************************/
302 static bool open_sockets_smbd(bool interactive, const char *smb_ports)
304 int num_interfaces = iface_count();
306 int fd_listenset[FD_SETSIZE];
312 TALLOC_CTX *dns_ctx = NULL;
313 unsigned dns_port = 0;
319 dns_ctx = talloc_new(NULL);
322 smbd_setup_sig_chld_handler();
324 FD_ZERO(&listen_set);
326 /* use a reasonable default set of ports - listing on 445 and 139 */
328 ports = lp_smb_ports();
329 if (!ports || !*ports) {
330 ports = smb_xstrdup(SMB_PORTS);
332 ports = smb_xstrdup(ports);
335 ports = smb_xstrdup(smb_ports);
338 if (lp_interfaces() && lp_bind_interfaces_only()) {
339 /* We have been given an interfaces line, and been
340 told to only bind to those interfaces. Create a
341 socket per interface and bind to only these.
344 /* Now open a listen socket for each of the
346 for(i = 0; i < num_interfaces; i++) {
347 TALLOC_CTX *frame = NULL;
348 const struct sockaddr_storage *ifss =
349 iface_n_sockaddr_storage(i);
354 DEBUG(0,("open_sockets_smbd: "
355 "interface %d has NULL IP address !\n",
360 frame = talloc_stackframe();
362 next_token_talloc(frame,&ptr, &tok, " \t,");) {
363 unsigned port = atoi(tok);
364 if (port == 0 || port > 0xffff) {
368 /* Keep the first port for mDNS service
375 s = fd_listenset[num_sockets] =
376 open_socket_in(SOCK_STREAM,
378 num_sockets == 0 ? 0 : 2,
385 /* ready to listen */
386 set_socket_options(s,"SO_KEEPALIVE");
387 set_socket_options(s,lp_socket_options());
389 /* Set server socket to
390 * non-blocking for the accept. */
391 set_blocking(s,False);
393 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
394 DEBUG(0,("open_sockets_smbd: listen: "
395 "%s\n", strerror(errno)));
400 FD_SET(s,&listen_set);
401 maxfd = MAX( maxfd, s);
404 if (num_sockets >= FD_SETSIZE) {
405 DEBUG(0,("open_sockets_smbd: Too "
406 "many sockets to bind to\n"));
414 /* Just bind to 0.0.0.0 - accept connections
417 TALLOC_CTX *frame = talloc_stackframe();
420 const char *sock_addr = lp_socket_address();
422 const char *sock_ptr;
424 if (strequal(sock_addr, "0.0.0.0") ||
425 strequal(sock_addr, "::")) {
427 sock_addr = "::,0.0.0.0";
429 sock_addr = "0.0.0.0";
433 for (sock_ptr=sock_addr;
434 next_token_talloc(frame, &sock_ptr, &sock_tok, " \t,"); ) {
435 for (ptr=ports; next_token_talloc(frame, &ptr, &tok, " \t,"); ) {
436 struct sockaddr_storage ss;
438 unsigned port = atoi(tok);
439 if (port == 0 || port > 0xffff) {
443 /* Keep the first port for mDNS service
450 /* open an incoming socket */
451 if (!interpret_string_addr(&ss, sock_tok,
452 AI_NUMERICHOST|AI_PASSIVE)) {
456 s = open_socket_in(SOCK_STREAM,
458 num_sockets == 0 ? 0 : 2,
465 /* ready to listen */
466 set_socket_options(s,"SO_KEEPALIVE");
467 set_socket_options(s,lp_socket_options());
469 /* Set server socket to non-blocking
471 set_blocking(s,False);
473 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
474 DEBUG(0,("open_sockets_smbd: "
482 fd_listenset[num_sockets] = s;
483 FD_SET(s,&listen_set);
484 maxfd = MAX( maxfd, s);
488 if (num_sockets >= FD_SETSIZE) {
489 DEBUG(0,("open_sockets_smbd: Too "
490 "many sockets to bind to\n"));
501 if (num_sockets == 0) {
502 DEBUG(0,("open_sockets_smbd: No "
503 "sockets available to bind to.\n"));
507 /* Setup the main smbd so that we can get messages. Note that
508 do this after starting listening. This is needed as when in
509 clustered mode, ctdb won't allow us to start doing database
510 operations until it has gone thru a full startup, which
511 includes checking to see that smbd is listening. */
512 claim_connection(NULL,"",
513 FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_DBWRAP);
515 /* Listen to messages */
517 messaging_register(smbd_messaging_context(), NULL,
518 MSG_SMB_SAM_SYNC, msg_sam_sync);
519 messaging_register(smbd_messaging_context(), NULL,
520 MSG_SHUTDOWN, msg_exit_server);
521 messaging_register(smbd_messaging_context(), NULL,
522 MSG_SMB_FILE_RENAME, msg_file_was_renamed);
523 messaging_register(smbd_messaging_context(), NULL,
524 MSG_SMB_CONF_UPDATED, smb_conf_updated);
525 messaging_register(smbd_messaging_context(), NULL,
526 MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
527 brl_register_msgs(smbd_messaging_context());
529 #ifdef CLUSTER_SUPPORT
530 if (lp_clustering()) {
531 ctdbd_register_reconfigure(messaging_ctdbd_connection());
536 messaging_register(smbd_messaging_context(), NULL,
537 MSG_SMB_INJECT_FAULT, msg_inject_fault);
541 smbd_setup_mdns_registration(smbd_event_context(),
545 /* now accept incoming connections - forking a new process
546 for each incoming connection */
547 DEBUG(2,("waiting for a connection\n"));
549 struct timeval now, idle_timeout;
553 if (run_events(smbd_event_context(), 0, NULL, NULL)) {
557 idle_timeout = timeval_zero();
559 memcpy((char *)&r_fds, (char *)&listen_set,
564 event_add_to_select_args(smbd_event_context(), &now,
565 &r_fds, &w_fds, &idle_timeout,
568 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
569 timeval_is_zero(&idle_timeout) ?
570 NULL : &idle_timeout);
572 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
576 /* If the idle timeout fired and we don't have any connected
577 * users, exit gracefully. We should be running under a process
578 * controller that will restart us if necessry.
580 if (num == 0 && count_all_current_connections() == 0) {
581 exit_server_cleanly("idle timeout");
584 /* check if we need to reload services */
585 check_reload(time(NULL));
587 /* Find the sockets that are read-ready -
589 for( ; num > 0; num--) {
590 struct sockaddr addr;
591 socklen_t in_addrlen = sizeof(addr);
595 for(i = 0; i < num_sockets; i++) {
596 if(FD_ISSET(fd_listenset[i],&r_fds)) {
598 /* Clear this so we don't look
600 FD_CLR(fd_listenset[i],&r_fds);
605 smbd_set_server_fd(accept(s,&addr,&in_addrlen));
607 if (smbd_server_fd() == -1 && errno == EINTR)
610 if (smbd_server_fd() == -1) {
611 DEBUG(2,("open_sockets_smbd: accept: %s\n",
619 if (allowable_number_of_smbd_processes() &&
620 ((child = sys_fork())==0)) {
623 TALLOC_FREE(dns_ctx);
625 /* Stop zombies, the parent explicitly handles
626 * them, counting worker smbds. */
629 /* close the listening socket(s) */
630 for(i = 0; i < num_sockets; i++)
631 close(fd_listenset[i]);
633 /* close our standard file
635 close_low_fds(False);
638 if (!reinit_after_fork(
639 smbd_messaging_context(),
640 smbd_event_context(),
642 DEBUG(0,("reinit_after_fork() failed\n"));
643 smb_panic("reinit_after_fork() failed");
646 smbd_setup_sig_term_handler();
647 smbd_setup_sig_hup_handler();
651 /* The parent doesn't need this socket */
652 close(smbd_server_fd());
654 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
655 Clear the closed fd info out of server_fd --
656 and more importantly, out of client_fd in
657 util_sock.c, to avoid a possible
658 getpeername failure if we reopen the logs
659 and use %I in the filename.
662 smbd_set_server_fd(-1);
665 add_child_pid(child);
668 /* Force parent to check log size after
669 * spawning child. Fix from
670 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
671 * parent smbd will log to logserver.smb. It
672 * writes only two messages for each child
673 * started/finished. But each child writes,
674 * say, 50 messages also in logserver.smb,
675 * begining with the debug_count of the
676 * parent, before the child opens its own log
677 * file logserver.client. In a worst case
678 * scenario the size of logserver.smb would be
679 * checked after about 50*50=2500 messages
682 force_check_log_size();
687 /* NOTREACHED return True; */
690 /****************************************************************************
692 **************************************************************************/
693 void reload_printers(void)
696 int n_services = lp_numservices();
697 int pnum = lp_servicenumber(PRINTERS_NAME);
702 /* remove stale printers */
703 for (snum = 0; snum < n_services; snum++) {
704 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
705 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
706 lp_autoloaded(snum)))
709 pname = lp_printername(snum);
710 if (!pcap_printername_ok(pname)) {
711 DEBUG(3, ("removing stale printer %s\n", pname));
713 if (is_printer_published(NULL, snum, NULL))
714 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
715 del_a_printer(pname);
716 lp_killservice(snum);
723 /****************************************************************************
724 Reload the services file.
725 **************************************************************************/
727 bool reload_services(bool test)
732 char *fname = lp_configfile();
733 if (file_exist(fname) &&
734 !strcsequal(fname, get_dyn_CONFIGFILE())) {
735 set_dyn_CONFIGFILE(fname);
742 if (test && !lp_file_list_changed())
745 lp_killunused(conn_snum_used);
747 ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
751 /* perhaps the config filename is now set */
753 reload_services(True);
759 if (smbd_server_fd() != -1) {
760 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
761 set_socket_options(smbd_server_fd(), lp_socket_options());
764 mangle_reset_cache();
767 /* this forces service parameters to be flushed */
768 set_current_service(NULL,0,True);
773 /****************************************************************************
775 ****************************************************************************/
777 /* Reasons for shutting down a server process. */
778 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
780 static void exit_server_common(enum server_exit_reason how,
781 const char *const reason) _NORETURN_;
783 static void exit_server_common(enum server_exit_reason how,
784 const char *const reason)
790 exit_firsttime = false;
792 change_to_root_user();
794 if (negprot_global_auth_context) {
795 (negprot_global_auth_context->free)(&negprot_global_auth_context);
798 had_open_conn = conn_close_all();
800 invalidate_all_vuids();
802 /* 3 second timeout. */
803 print_notify_send_messages(smbd_messaging_context(), 3);
805 /* delete our entry in the connections database. */
806 yield_connection(NULL,"");
809 if (dcelogin_atmost_once) {
815 /* Destroy Samba DMAPI session only if we are master smbd process */
817 if (!dmapi_destroy_session()) {
818 DEBUG(0,("Unable to close Samba DMAPI session\n"));
826 if (how != SERVER_EXIT_NORMAL) {
827 int oldlevel = DEBUGLEVEL;
832 DEBUG(0,("Abnormal server exit: %s\n",
833 reason ? reason : "no explanation provided"));
838 DEBUGLEVEL = oldlevel;
842 DEBUG(3,("Server exit (%s)\n",
843 (reason ? reason : "normal exit")));
846 /* if we had any open SMB connections when we exited then we
847 need to tell the parent smbd so that it can trigger a retry
848 of any locks we may have been holding or open files we were
857 void exit_server(const char *const explanation)
859 exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
862 void exit_server_cleanly(const char *const explanation)
864 exit_server_common(SERVER_EXIT_NORMAL, explanation);
867 void exit_server_fault(void)
869 exit_server("critical server fault");
872 /****************************************************************************
873 Initialise connect, service and file structs.
874 ****************************************************************************/
876 static bool init_structs(void )
879 * Set the machine NETBIOS name if not already
880 * set from the config file.
898 /****************************************************************************
900 ****************************************************************************/
902 /* Declare prototype for build_options() to avoid having to run it through
903 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
904 prototype generation system is too complicated. */
906 extern void build_options(bool screen);
908 int main(int argc,const char *argv[])
910 /* shall I run as a daemon */
911 bool is_daemon = false;
912 bool interactive = false;
914 bool no_process_group = false;
915 bool log_stdout = false;
917 char *profile_level = NULL;
920 bool print_build_options = False;
925 OPT_NO_PROCESS_GROUP,
928 struct poptOption long_options[] = {
930 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
931 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
932 {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
933 {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
934 {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
935 {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
936 {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
937 {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
939 POPT_COMMON_DYNCONFIG
942 TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
948 #ifdef HAVE_SET_AUTH_PARAMETERS
949 set_auth_parameters(argc,argv);
952 pc = poptGetContext("smbd", argc, argv, long_options, 0);
953 while((opt = poptGetNextOpt(pc)) != -1) {
958 case OPT_INTERACTIVE:
964 case OPT_NO_PROCESS_GROUP:
965 no_process_group = true;
971 print_build_options = True;
974 d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
975 poptBadOption(pc, 0), poptStrerror(opt));
976 poptPrintUsage(pc, stderr, 0);
987 setup_logging(argv[0],log_stdout);
989 if (print_build_options) {
990 build_options(True); /* Display output to screen as well as debug */
997 /* needed for SecureWare on SCO */
1003 set_remote_machine_name("smbd", False);
1005 if (interactive && (DEBUGLEVEL >= 9)) {
1006 talloc_enable_leak_report();
1009 if (log_stdout && Fork) {
1010 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1014 /* we want to re-seed early to prevent time delays causing
1015 client problems at a later date. (tridge) */
1016 generate_random_buffer(NULL, 0);
1018 /* make absolutely sure we run as root - to handle cases where people
1019 are crazy enough to have it setuid */
1021 gain_root_privilege();
1022 gain_root_group_privilege();
1024 fault_setup((void (*)(void *))exit_server_fault);
1025 dump_core_setup("smbd");
1027 /* we are never interested in SIGPIPE */
1028 BlockSignals(True,SIGPIPE);
1031 /* we are never interested in SIGFPE */
1032 BlockSignals(True,SIGFPE);
1035 #if defined(SIGUSR2)
1036 /* We are no longer interested in USR2 */
1037 BlockSignals(True,SIGUSR2);
1040 /* POSIX demands that signals are inherited. If the invoking process has
1041 * these signals masked, we will have problems, as we won't recieve them. */
1042 BlockSignals(False, SIGHUP);
1043 BlockSignals(False, SIGUSR1);
1044 BlockSignals(False, SIGTERM);
1046 /* we want total control over the permissions on created files,
1047 so set our umask to 0 */
1054 DEBUG(0,("smbd version %s started.\n", samba_version_string()));
1055 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1057 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1058 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1060 /* Output the build options to the debug log */
1061 build_options(False);
1063 if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1064 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1068 if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1069 DEBUG(0, ("error opening config file\n"));
1073 if (smbd_messaging_context() == NULL)
1076 if (!reload_services(False))
1082 if (!profile_setup(smbd_messaging_context(), False)) {
1083 DEBUG(0,("ERROR: failed to setup profiling\n"));
1086 if (profile_level != NULL) {
1087 int pl = atoi(profile_level);
1088 struct server_id src;
1090 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1092 set_profile_level(pl, src);
1096 DEBUG(3,( "loaded services\n"));
1098 if (!is_daemon && !is_a_socket(0)) {
1100 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1103 * Setting is_daemon here prevents us from eventually calling
1104 * the open_sockets_inetd()
1110 if (is_daemon && !interactive) {
1111 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1112 become_daemon(Fork, no_process_group);
1117 * If we're interactive we want to set our own process group for
1118 * signal management.
1120 if (interactive && !no_process_group)
1121 setpgid( (pid_t)0, (pid_t)0);
1124 if (!directory_exist(lp_lockdir()))
1125 mkdir(lp_lockdir(), 0755);
1128 pidfile_create("smbd");
1130 if (!reinit_after_fork(smbd_messaging_context(),
1131 smbd_event_context(), false)) {
1132 DEBUG(0,("reinit_after_fork() failed\n"));
1136 smbd_setup_sig_term_handler();
1137 smbd_setup_sig_hup_handler();
1139 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1141 if (smbd_memcache() == NULL) {
1145 memcache_set_global(smbd_memcache());
1147 /* Initialise the password backed before the global_sam_sid
1148 to ensure that we fetch from ldap before we make a domain sid up */
1150 if(!initialize_password_db(False, smbd_event_context()))
1153 if (!secrets_init()) {
1154 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1158 if(!get_global_sam_sid()) {
1159 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1163 if (!session_init())
1166 if (!connections_init(True))
1169 if (!locking_init())
1174 if (!W_ERROR_IS_OK(registry_init_full()))
1178 if (!init_svcctl_db())
1182 if (!print_backend_init(smbd_messaging_context()))
1185 if (!init_guest_info()) {
1186 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1190 /* only start the background queue daemon if we are
1191 running as a daemon -- bad things will happen if
1192 smbd is launched via inetd and we fork a copy of
1195 if (is_daemon && !interactive
1196 && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1197 start_background_queue();
1204 /* Started from inetd. fd 0 is the socket. */
1205 /* We will abort gracefully when the client or remote system
1207 smbd_set_server_fd(dup(0));
1209 /* close our standard file descriptors */
1210 close_low_fds(False); /* Don't close stderr */
1214 exit_server_cleanly(NULL);
1218 if (!open_sockets_smbd(interactive, ports))
1225 exit_server_cleanly(NULL);