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
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.
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.
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/>.
26 static int am_parent = 1;
28 /* the last message the was processed */
29 int last_message = -1;
31 /* a useful macro to debug the last message processed */
32 #define LAST_MESSAGE() smb_fn_name(last_message)
34 extern struct auth_context *negprot_global_auth_context;
35 extern pstring user_socket_options;
36 extern SIG_ATOMIC_T got_sig_term;
37 extern SIG_ATOMIC_T reload_after_sighup;
38 static SIG_ATOMIC_T got_sig_cld;
41 extern int dcelogin_atmost_once;
44 /* really we should have a top level context structure that has the
45 client file descriptor as an element. That would require a major rewrite :(
47 the following 2 functions are an alternative - they make the file
48 descriptor private to smbd
50 static int server_fd = -1;
52 int smbd_server_fd(void)
57 static void smbd_set_server_fd(int fd)
63 struct event_context *smbd_event_context(void)
65 static struct event_context *ctx;
67 if (!ctx && !(ctx = event_context_init(NULL))) {
68 smb_panic("Could not init smbd event context");
73 struct messaging_context *smbd_messaging_context(void)
75 static struct messaging_context *ctx;
77 if (!ctx && !(ctx = messaging_init(NULL, server_id_self(),
78 smbd_event_context()))) {
79 smb_panic("Could not init smbd messaging context");
84 /*******************************************************************
85 What to do when smb.conf is updated.
86 ********************************************************************/
88 static void smb_conf_updated(struct messaging_context *msg,
91 struct server_id server_id,
94 DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
95 "updated. Reloading.\n"));
96 reload_services(False);
100 /*******************************************************************
101 Delete a statcache entry.
102 ********************************************************************/
104 static void smb_stat_cache_delete(struct messaging_context *msg,
107 struct server_id server_id,
110 const char *name = (const char *)data->data;
111 DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
112 stat_cache_delete(name);
115 /****************************************************************************
117 ****************************************************************************/
119 static void sig_term(void)
122 sys_select_signal(SIGTERM);
125 /****************************************************************************
127 ****************************************************************************/
129 static void sig_hup(int sig)
131 reload_after_sighup = 1;
132 sys_select_signal(SIGHUP);
135 /****************************************************************************
137 ****************************************************************************/
138 static void sig_cld(int sig)
141 sys_select_signal(SIGCLD);
144 /****************************************************************************
145 Send a SIGTERM to our process group.
146 *****************************************************************************/
148 static void killkids(void)
150 if(am_parent) kill(0,SIGTERM);
153 /****************************************************************************
154 Process a sam sync message - not sure whether to do this here or
156 ****************************************************************************/
158 static void msg_sam_sync(struct messaging_context *msg,
161 struct server_id server_id,
164 DEBUG(10, ("** sam sync message received, ignoring\n"));
168 /****************************************************************************
169 Open the socket communication - inetd.
170 ****************************************************************************/
172 static BOOL open_sockets_inetd(void)
174 /* Started from inetd. fd 0 is the socket. */
175 /* We will abort gracefully when the client or remote system
177 smbd_set_server_fd(dup(0));
179 /* close our standard file descriptors */
180 close_low_fds(False); /* Don't close stderr */
182 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
183 set_socket_options(smbd_server_fd(), user_socket_options);
188 static void msg_exit_server(struct messaging_context *msg,
191 struct server_id server_id,
194 DEBUG(3, ("got a SHUTDOWN message\n"));
195 exit_server_cleanly(NULL);
199 static void msg_inject_fault(struct messaging_context *msg,
202 struct server_id src,
207 if (data->length != sizeof(sig)) {
209 DEBUG(0, ("Process %s sent bogus signal injection request\n",
210 procid_str_static(&src)));
214 sig = *(int *)data->data;
216 exit_server("internal error injected");
221 DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
222 procid_str_static(&src), sig, strsignal(sig)));
224 DEBUG(0, ("Process %s requested injection of signal %d\n",
225 procid_str_static(&src), sig));
228 kill(sys_getpid(), sig);
230 #endif /* DEVELOPER */
233 struct child_pid *prev, *next;
237 static struct child_pid *children;
238 static int num_children;
240 static void add_child_pid(pid_t pid)
242 struct child_pid *child;
244 if (lp_max_smbd_processes() == 0) {
245 /* Don't bother with the child list if we don't care anyway */
249 child = SMB_MALLOC_P(struct child_pid);
251 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
255 DLIST_ADD(children, child);
259 static void remove_child_pid(pid_t pid)
261 struct child_pid *child;
263 if (lp_max_smbd_processes() == 0) {
264 /* Don't bother with the child list if we don't care anyway */
268 for (child = children; child != NULL; child = child->next) {
269 if (child->pid == pid) {
270 struct child_pid *tmp = child;
271 DLIST_REMOVE(children, child);
278 DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid));
281 /****************************************************************************
282 Have we reached the process limit ?
283 ****************************************************************************/
285 static BOOL allowable_number_of_smbd_processes(void)
287 int max_processes = lp_max_smbd_processes();
292 return num_children < max_processes;
295 /****************************************************************************
296 Open the socket communication.
297 ****************************************************************************/
299 static BOOL open_sockets_smbd(BOOL is_daemon, BOOL interactive, const char *smb_ports)
301 int num_interfaces = iface_count();
303 int fd_listenset[FD_SETSIZE];
311 return open_sockets_inetd();
317 static int atexit_set;
318 if(atexit_set == 0) {
326 CatchSignal(SIGCLD, sig_cld);
328 FD_ZERO(&listen_set);
330 /* use a reasonable default set of ports - listing on 445 and 139 */
332 ports = lp_smb_ports();
333 if (!ports || !*ports) {
334 ports = smb_xstrdup(SMB_PORTS);
336 ports = smb_xstrdup(ports);
339 ports = smb_xstrdup(smb_ports);
342 if (lp_interfaces() && lp_bind_interfaces_only()) {
343 /* We have been given an interfaces line, and been
344 told to only bind to those interfaces. Create a
345 socket per interface and bind to only these.
348 /* Now open a listen socket for each of the
350 for(i = 0; i < num_interfaces; i++) {
351 struct in_addr *ifip = iface_n_ip(i);
356 DEBUG(0,("open_sockets_smbd: interface %d has NULL IP address !\n", i));
360 for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
361 unsigned port = atoi(tok);
362 if (port == 0 || port > 0xffff) {
365 s = fd_listenset[num_sockets] = open_socket_in(SOCK_STREAM, port, 0, ifip->s_addr, True);
369 /* ready to listen */
370 set_socket_options(s,"SO_KEEPALIVE");
371 set_socket_options(s,user_socket_options);
373 /* Set server socket to non-blocking for the accept. */
374 set_blocking(s,False);
376 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
377 DEBUG(0,("listen: %s\n",strerror(errno)));
381 FD_SET(s,&listen_set);
382 maxfd = MAX( maxfd, s);
385 if (num_sockets >= FD_SETSIZE) {
386 DEBUG(0,("open_sockets_smbd: Too many sockets to bind to\n"));
392 /* Just bind to 0.0.0.0 - accept connections
400 for (ptr=ports; next_token(&ptr, tok, " \t,", sizeof(tok)); ) {
401 unsigned port = atoi(tok);
402 if (port == 0 || port > 0xffff) continue;
403 /* open an incoming socket */
404 s = open_socket_in(SOCK_STREAM, port, 0,
405 interpret_addr(lp_socket_address()),True);
409 /* ready to listen */
410 set_socket_options(s,"SO_KEEPALIVE");
411 set_socket_options(s,user_socket_options);
413 /* Set server socket to non-blocking for the accept. */
414 set_blocking(s,False);
416 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
417 DEBUG(0,("open_sockets_smbd: listen: %s\n",
423 fd_listenset[num_sockets] = s;
424 FD_SET(s,&listen_set);
425 maxfd = MAX( maxfd, s);
429 if (num_sockets >= FD_SETSIZE) {
430 DEBUG(0,("open_sockets_smbd: Too many sockets to bind to\n"));
439 /* Setup the main smbd so that we can get messages. Note that
440 do this after starting listening. This is needed as when in
441 clustered mode, ctdb won't allow us to start doing database
442 operations until it has gone thru a full startup, which
443 includes checking to see that smbd is listening. */
444 claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_SMBD);
446 /* Listen to messages */
448 messaging_register(smbd_messaging_context(), NULL,
449 MSG_SMB_SAM_SYNC, msg_sam_sync);
450 messaging_register(smbd_messaging_context(), NULL,
451 MSG_SHUTDOWN, msg_exit_server);
452 messaging_register(smbd_messaging_context(), NULL,
453 MSG_SMB_FILE_RENAME, msg_file_was_renamed);
454 messaging_register(smbd_messaging_context(), NULL,
455 MSG_SMB_CONF_UPDATED, smb_conf_updated);
456 messaging_register(smbd_messaging_context(), NULL,
457 MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
458 brl_register_msgs(smbd_messaging_context());
461 messaging_register(smbd_messaging_context(), NULL,
462 MSG_SMB_INJECT_FAULT, msg_inject_fault);
465 /* now accept incoming connections - forking a new process
466 for each incoming connection */
467 DEBUG(2,("waiting for a connection\n"));
469 struct timeval now, idle_timeout;
473 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
474 message_dispatch(smbd_messaging_context());
480 while ((pid = sys_waitpid(-1, NULL, WNOHANG)) > 0) {
481 remove_child_pid(pid);
485 idle_timeout = timeval_zero();
487 memcpy((char *)&r_fds, (char *)&listen_set,
492 event_add_to_select_args(smbd_event_context(), &now,
493 &r_fds, &w_fds, &idle_timeout,
496 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
497 timeval_is_zero(&idle_timeout) ?
498 NULL : &idle_timeout);
500 if (num == -1 && errno == EINTR) {
502 exit_server_cleanly(NULL);
505 /* check for sighup processing */
506 if (reload_after_sighup) {
507 change_to_root_user();
508 DEBUG(1,("Reloading services after SIGHUP\n"));
509 reload_services(False);
510 reload_after_sighup = 0;
516 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
520 /* check if we need to reload services */
521 check_reload(time(NULL));
523 /* Find the sockets that are read-ready -
525 for( ; num > 0; num--) {
526 struct sockaddr addr;
527 socklen_t in_addrlen = sizeof(addr);
531 for(i = 0; i < num_sockets; i++) {
532 if(FD_ISSET(fd_listenset[i],&r_fds)) {
534 /* Clear this so we don't look
536 FD_CLR(fd_listenset[i],&r_fds);
541 smbd_set_server_fd(accept(s,&addr,&in_addrlen));
543 if (smbd_server_fd() == -1 && errno == EINTR)
546 if (smbd_server_fd() == -1) {
547 DEBUG(0,("open_sockets_smbd: accept: %s\n",
552 /* Ensure child is set to blocking mode */
553 set_blocking(smbd_server_fd(),True);
555 if (smbd_server_fd() != -1 && interactive)
558 if (allowable_number_of_smbd_processes() &&
559 smbd_server_fd() != -1 &&
560 ((child = sys_fork())==0)) {
563 /* Stop zombies, the parent explicitly handles
564 * them, counting worker smbds. */
567 /* close the listening socket(s) */
568 for(i = 0; i < num_sockets; i++)
569 close(fd_listenset[i]);
571 /* close our standard file
573 close_low_fds(False);
576 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
577 set_socket_options(smbd_server_fd(),user_socket_options);
579 /* this is needed so that we get decent entries
580 in smbstatus for port 445 connects */
581 set_remote_machine_name(get_peer_addr(smbd_server_fd()),
584 /* Reset the state of the random
585 * number generation system, so
586 * children do not get the same random
587 * numbers as each other */
589 set_need_random_reseed();
590 /* tdb needs special fork handling - remove
591 * CLEAR_IF_FIRST flags */
592 if (tdb_reopen_all(1) == -1) {
593 DEBUG(0,("tdb_reopen_all failed.\n"));
594 smb_panic("tdb_reopen_all failed");
599 /* The parent doesn't need this socket */
600 close(smbd_server_fd());
602 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
603 Clear the closed fd info out of server_fd --
604 and more importantly, out of client_fd in
605 util_sock.c, to avoid a possible
606 getpeername failure if we reopen the logs
607 and use %I in the filename.
610 smbd_set_server_fd(-1);
613 add_child_pid(child);
616 /* Force parent to check log size after
617 * spawning child. Fix from
618 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
619 * parent smbd will log to logserver.smb. It
620 * writes only two messages for each child
621 * started/finished. But each child writes,
622 * say, 50 messages also in logserver.smb,
623 * begining with the debug_count of the
624 * parent, before the child opens its own log
625 * file logserver.client. In a worst case
626 * scenario the size of logserver.smb would be
627 * checked after about 50*50=2500 messages
630 force_check_log_size();
635 /* NOTREACHED return True; */
638 /****************************************************************************
640 **************************************************************************/
641 void reload_printers(void)
644 int n_services = lp_numservices();
645 int pnum = lp_servicenumber(PRINTERS_NAME);
650 /* remove stale printers */
651 for (snum = 0; snum < n_services; snum++) {
652 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
653 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
654 lp_autoloaded(snum)))
657 pname = lp_printername(snum);
658 if (!pcap_printername_ok(pname)) {
659 DEBUG(3, ("removing stale printer %s\n", pname));
661 if (is_printer_published(NULL, snum, NULL))
662 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
663 del_a_printer(pname);
664 lp_killservice(snum);
671 /****************************************************************************
672 Reload the services file.
673 **************************************************************************/
675 BOOL reload_services(BOOL test)
681 pstrcpy(fname,lp_configfile());
682 if (file_exist(fname, NULL) &&
683 !strcsequal(fname, dyn_CONFIGFILE)) {
684 pstrcpy(dyn_CONFIGFILE, fname);
691 if (test && !lp_file_list_changed())
694 lp_killunused(conn_snum_used);
696 ret = lp_load(dyn_CONFIGFILE, False, False, True, True);
700 /* perhaps the config filename is now set */
702 reload_services(True);
708 if (smbd_server_fd() != -1) {
709 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
710 set_socket_options(smbd_server_fd(), user_socket_options);
713 mangle_reset_cache();
716 /* this forces service parameters to be flushed */
717 set_current_service(NULL,0,True);
722 /****************************************************************************
724 ****************************************************************************/
726 /* Reasons for shutting down a server process. */
727 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
729 static void exit_server_common(enum server_exit_reason how,
730 const char *const reason) NORETURN_ATTRIBUTE;
732 static void exit_server_common(enum server_exit_reason how,
733 const char *const reason)
735 static int firsttime=1;
741 change_to_root_user();
743 if (negprot_global_auth_context) {
744 (negprot_global_auth_context->free)(&negprot_global_auth_context);
749 invalidate_all_vuids();
751 /* 3 second timeout. */
752 print_notify_send_messages(smbd_messaging_context(), 3);
754 /* delete our entry in the connections database. */
755 yield_connection(NULL,"");
757 respond_to_all_remaining_local_messages();
760 if (dcelogin_atmost_once) {
768 if (how != SERVER_EXIT_NORMAL) {
769 int oldlevel = DEBUGLEVEL;
774 DEBUG(0,("Abnormal server exit: %s\n",
775 reason ? reason : "no explanation provided"));
780 DEBUGLEVEL = oldlevel;
784 DEBUG(3,("Server exit (%s)\n",
785 (reason ? reason : "normal exit")));
791 void exit_server(const char *const explanation)
793 exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
796 void exit_server_cleanly(const char *const explanation)
798 exit_server_common(SERVER_EXIT_NORMAL, explanation);
801 void exit_server_fault(void)
803 exit_server("critical server fault");
806 /****************************************************************************
807 Initialise connect, service and file structs.
808 ****************************************************************************/
810 static BOOL init_structs(void )
813 * Set the machine NETBIOS name if not already
814 * set from the config file.
835 * Send keepalive packets to our client
837 static BOOL keepalive_fn(const struct timeval *now, void *private_data)
839 if (!send_keepalive(smbd_server_fd())) {
840 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
847 * Do the recurring check if we're idle
849 static BOOL deadtime_fn(const struct timeval *now, void *private_data)
851 if ((conn_num_open() == 0)
852 || (conn_idle_all(now->tv_sec))) {
853 DEBUG( 2, ( "Closing idle connection\n" ) );
854 messaging_send(smbd_messaging_context(), procid_self(),
855 MSG_SHUTDOWN, &data_blob_null);
863 /****************************************************************************
865 ****************************************************************************/
867 /* Declare prototype for build_options() to avoid having to run it through
868 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
869 prototype generation system is too complicated. */
871 extern void build_options(BOOL screen);
873 int main(int argc,const char *argv[])
875 /* shall I run as a daemon */
876 static BOOL is_daemon = False;
877 static BOOL interactive = False;
878 static BOOL Fork = True;
879 static BOOL no_process_group = False;
880 static BOOL log_stdout = False;
881 static char *ports = NULL;
882 static char *profile_level = NULL;
885 BOOL print_build_options = False;
887 struct poptOption long_options[] = {
889 {"daemon", 'D', POPT_ARG_VAL, &is_daemon, True, "Become a daemon (default)" },
890 {"interactive", 'i', POPT_ARG_VAL, &interactive, True, "Run interactive (not a daemon)"},
891 {"foreground", 'F', POPT_ARG_VAL, &Fork, False, "Run daemon in foreground (for daemontools, etc.)" },
892 {"no-process-group", '\0', POPT_ARG_VAL, &no_process_group, True, "Don't create a new process group" },
893 {"log-stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
894 {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
895 {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
896 {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
898 POPT_COMMON_DYNCONFIG
906 #ifdef HAVE_SET_AUTH_PARAMETERS
907 set_auth_parameters(argc,argv);
910 pc = poptGetContext("smbd", argc, argv, long_options, 0);
911 while((opt = poptGetNextOpt(pc)) != -1) {
914 print_build_options = True;
917 d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
918 poptBadOption(pc, 0), poptStrerror(opt));
919 poptPrintUsage(pc, stderr, 0);
925 if (print_build_options) {
926 build_options(True); /* Display output to screen as well as debug */
931 /* needed for SecureWare on SCO */
937 set_remote_machine_name("smbd", False);
944 if (interactive && (DEBUGLEVEL >= 9)) {
945 talloc_enable_leak_report();
948 if (log_stdout && Fork) {
949 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
953 setup_logging(argv[0],log_stdout);
955 /* we want to re-seed early to prevent time delays causing
956 client problems at a later date. (tridge) */
957 generate_random_buffer(NULL, 0);
959 /* make absolutely sure we run as root - to handle cases where people
960 are crazy enough to have it setuid */
962 gain_root_privilege();
963 gain_root_group_privilege();
965 fault_setup((void (*)(void *))exit_server_fault);
966 dump_core_setup("smbd");
968 CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
969 CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
971 /* we are never interested in SIGPIPE */
972 BlockSignals(True,SIGPIPE);
975 /* we are never interested in SIGFPE */
976 BlockSignals(True,SIGFPE);
980 /* We are no longer interested in USR2 */
981 BlockSignals(True,SIGUSR2);
984 /* POSIX demands that signals are inherited. If the invoking process has
985 * these signals masked, we will have problems, as we won't recieve them. */
986 BlockSignals(False, SIGHUP);
987 BlockSignals(False, SIGUSR1);
988 BlockSignals(False, SIGTERM);
990 /* we want total control over the permissions on created files,
991 so set our umask to 0 */
998 DEBUG(0,( "smbd version %s started.\n", SAMBA_VERSION_STRING));
999 DEBUGADD( 0, ( "%s\n", COPYRIGHT_STARTUP_MESSAGE ) );
1001 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1002 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1004 /* Output the build options to the debug log */
1005 build_options(False);
1007 if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1008 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1013 * Do this before reload_services.
1016 if (!reload_services(False))
1022 if (!profile_setup(smbd_messaging_context(), False)) {
1023 DEBUG(0,("ERROR: failed to setup profiling\n"));
1026 if (profile_level != NULL) {
1027 int pl = atoi(profile_level);
1028 struct server_id src;
1030 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1032 set_profile_level(pl, src);
1036 DEBUG(3,( "loaded services\n"));
1038 if (!is_daemon && !is_a_socket(0)) {
1040 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1043 * Setting is_daemon here prevents us from eventually calling
1044 * the open_sockets_inetd()
1050 if (is_daemon && !interactive) {
1051 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1052 become_daemon(Fork, no_process_group);
1057 * If we're interactive we want to set our own process group for
1058 * signal management.
1060 if (interactive && !no_process_group)
1061 setpgid( (pid_t)0, (pid_t)0);
1064 if (!directory_exist(lp_lockdir(), NULL))
1065 mkdir(lp_lockdir(), 0755);
1068 pidfile_create("smbd");
1070 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1072 if (smbd_messaging_context() == NULL)
1075 /* Initialise the password backed before the global_sam_sid
1076 to ensure that we fetch from ldap before we make a domain sid up */
1078 if(!initialize_password_db(False, smbd_event_context()))
1081 if (!secrets_init()) {
1082 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1086 if(!get_global_sam_sid()) {
1087 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1091 if (!session_init())
1094 if (!connections_init(True))
1097 if (!locking_init(0))
1102 if (!init_registry())
1106 if (!init_svcctl_db())
1110 if (!print_backend_init(smbd_messaging_context()))
1113 if (!init_guest_info()) {
1114 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1118 /* only start the background queue daemon if we are
1119 running as a daemon -- bad things will happen if
1120 smbd is launched via inetd and we fork a copy of
1123 if ( is_daemon && !interactive )
1124 start_background_queue();
1126 /* Always attempt to initialize DMAPI. We will only use it later if
1127 * lp_dmapi_support is set on the share, but we need a single global
1128 * session to work with.
1130 dmapi_init_session();
1132 if (!open_sockets_smbd(is_daemon, interactive, ports))
1136 * everything after this point is run after the fork()
1143 /* Possibly reload the services file. Only worth doing in
1144 * daemon mode. In inetd mode, we know we only just loaded this.
1147 reload_services(True);
1150 if (!init_account_policy()) {
1151 DEBUG(0,("Could not open account policy tdb.\n"));
1155 if (*lp_rootdir()) {
1156 if (sys_chroot(lp_rootdir()) == 0)
1157 DEBUG(2,("Changed root to %s\n", lp_rootdir()));
1161 if (!init_oplocks(smbd_messaging_context()))
1164 /* Setup aio signal handler. */
1165 initialize_async_io_handler();
1168 * For clustering, we need to re-init our ctdbd connection after the
1171 if (!NT_STATUS_IS_OK(messaging_reinit(smbd_messaging_context())))
1174 /* register our message handlers */
1175 messaging_register(smbd_messaging_context(), NULL,
1176 MSG_SMB_FORCE_TDIS, msg_force_tdis);
1178 if ((lp_keepalive() != 0)
1179 && !(event_add_idle(smbd_event_context(), NULL,
1180 timeval_set(lp_keepalive(), 0),
1181 "keepalive", keepalive_fn,
1183 DEBUG(0, ("Could not add keepalive event\n"));
1187 if (!(event_add_idle(smbd_event_context(), NULL,
1188 timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1189 "deadtime", deadtime_fn, NULL))) {
1190 DEBUG(0, ("Could not add deadtime event\n"));
1196 namecache_shutdown();
1198 exit_server_cleanly(NULL);