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/>.
28 static int am_parent = 1;
30 extern struct auth_context *negprot_global_auth_context;
31 extern SIG_ATOMIC_T got_sig_term;
32 extern SIG_ATOMIC_T reload_after_sighup;
33 static SIG_ATOMIC_T got_sig_cld;
36 extern int dcelogin_atmost_once;
39 /* really we should have a top level context structure that has the
40 client file descriptor as an element. That would require a major rewrite :(
42 the following 2 functions are an alternative - they make the file
43 descriptor private to smbd
45 static int server_fd = -1;
47 int smbd_server_fd(void)
52 static void smbd_set_server_fd(int fd)
57 int get_client_fd(void)
62 struct event_context *smbd_event_context(void)
64 static struct event_context *ctx;
66 if (!ctx && !(ctx = event_context_init(NULL))) {
67 smb_panic("Could not init smbd event context");
72 struct messaging_context *smbd_messaging_context(void)
74 static struct messaging_context *ctx;
76 if (!ctx && !(ctx = messaging_init(NULL, server_id_self(),
77 smbd_event_context()))) {
78 smb_panic("Could not init smbd messaging context");
83 struct memcache *smbd_memcache(void)
85 static struct memcache *cache;
88 && !(cache = memcache_init(NULL,
89 lp_max_stat_cache_size()*1024))) {
91 smb_panic("Could not init smbd memcache");
96 /*******************************************************************
97 What to do when smb.conf is updated.
98 ********************************************************************/
100 static void smb_conf_updated(struct messaging_context *msg,
103 struct server_id server_id,
106 DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
107 "updated. Reloading.\n"));
108 reload_services(False);
112 /*******************************************************************
113 Delete a statcache entry.
114 ********************************************************************/
116 static void smb_stat_cache_delete(struct messaging_context *msg,
119 struct server_id server_id,
122 const char *name = (const char *)data->data;
123 DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
124 stat_cache_delete(name);
127 /****************************************************************************
129 ****************************************************************************/
131 static void sig_term(void)
134 sys_select_signal(SIGTERM);
137 /****************************************************************************
139 ****************************************************************************/
141 static void sig_hup(int sig)
143 reload_after_sighup = 1;
144 sys_select_signal(SIGHUP);
147 /****************************************************************************
149 ****************************************************************************/
150 static void sig_cld(int sig)
153 sys_select_signal(SIGCLD);
156 /****************************************************************************
157 Send a SIGTERM to our process group.
158 *****************************************************************************/
160 static void killkids(void)
162 if(am_parent) kill(0,SIGTERM);
165 /****************************************************************************
166 Process a sam sync message - not sure whether to do this here or
168 ****************************************************************************/
170 static void msg_sam_sync(struct messaging_context *msg,
173 struct server_id server_id,
176 DEBUG(10, ("** sam sync message received, ignoring\n"));
180 /****************************************************************************
181 Open the socket communication - inetd.
182 ****************************************************************************/
184 static bool open_sockets_inetd(void)
186 /* Started from inetd. fd 0 is the socket. */
187 /* We will abort gracefully when the client or remote system
189 smbd_set_server_fd(dup(0));
191 /* close our standard file descriptors */
192 close_low_fds(False); /* Don't close stderr */
194 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
195 set_socket_options(smbd_server_fd(), lp_socket_options());
200 static void msg_exit_server(struct messaging_context *msg,
203 struct server_id server_id,
206 DEBUG(3, ("got a SHUTDOWN message\n"));
207 exit_server_cleanly(NULL);
211 static void msg_inject_fault(struct messaging_context *msg,
214 struct server_id src,
219 if (data->length != sizeof(sig)) {
221 DEBUG(0, ("Process %s sent bogus signal injection request\n",
222 procid_str_static(&src)));
226 sig = *(int *)data->data;
228 exit_server("internal error injected");
233 DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
234 procid_str_static(&src), sig, strsignal(sig)));
236 DEBUG(0, ("Process %s requested injection of signal %d\n",
237 procid_str_static(&src), sig));
240 kill(sys_getpid(), sig);
242 #endif /* DEVELOPER */
245 struct child_pid *prev, *next;
249 static struct child_pid *children;
250 static int num_children;
252 static void add_child_pid(pid_t pid)
254 struct child_pid *child;
256 if (lp_max_smbd_processes() == 0) {
257 /* Don't bother with the child list if we don't care anyway */
261 child = SMB_MALLOC_P(struct child_pid);
263 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
267 DLIST_ADD(children, child);
271 static void remove_child_pid(pid_t pid)
273 struct child_pid *child;
275 if (lp_max_smbd_processes() == 0) {
276 /* Don't bother with the child list if we don't care anyway */
280 for (child = children; child != NULL; child = child->next) {
281 if (child->pid == pid) {
282 struct child_pid *tmp = child;
283 DLIST_REMOVE(children, child);
290 DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid));
293 /****************************************************************************
294 Have we reached the process limit ?
295 ****************************************************************************/
297 static bool allowable_number_of_smbd_processes(void)
299 int max_processes = lp_max_smbd_processes();
304 return num_children < max_processes;
307 /****************************************************************************
308 Open the socket communication.
309 ****************************************************************************/
311 static bool open_sockets_smbd(bool is_daemon, bool interactive, const char *smb_ports)
313 int num_interfaces = iface_count();
315 int fd_listenset[FD_SETSIZE];
321 struct dns_reg_state * dns_reg = NULL;
322 unsigned dns_port = 0;
325 return open_sockets_inetd();
330 static int atexit_set;
331 if(atexit_set == 0) {
339 CatchSignal(SIGCLD, sig_cld);
341 FD_ZERO(&listen_set);
343 /* use a reasonable default set of ports - listing on 445 and 139 */
345 ports = lp_smb_ports();
346 if (!ports || !*ports) {
347 ports = smb_xstrdup(SMB_PORTS);
349 ports = smb_xstrdup(ports);
352 ports = smb_xstrdup(smb_ports);
355 if (lp_interfaces() && lp_bind_interfaces_only()) {
356 /* We have been given an interfaces line, and been
357 told to only bind to those interfaces. Create a
358 socket per interface and bind to only these.
361 /* Now open a listen socket for each of the
363 for(i = 0; i < num_interfaces; i++) {
364 TALLOC_CTX *frame = NULL;
365 const struct sockaddr_storage *ifss =
366 iface_n_sockaddr_storage(i);
371 DEBUG(0,("open_sockets_smbd: "
372 "interface %d has NULL IP address !\n",
377 frame = talloc_stackframe();
379 next_token_talloc(frame,&ptr, &tok, " \t,");) {
380 unsigned port = atoi(tok);
381 if (port == 0 || port > 0xffff) {
385 /* Keep the first port for mDNS service
392 s = fd_listenset[num_sockets] =
393 open_socket_in(SOCK_STREAM,
395 num_sockets == 0 ? 0 : 2,
402 /* ready to listen */
403 set_socket_options(s,"SO_KEEPALIVE");
404 set_socket_options(s,lp_socket_options());
406 /* Set server socket to
407 * non-blocking for the accept. */
408 set_blocking(s,False);
410 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
411 DEBUG(0,("open_sockets_smbd: listen: "
412 "%s\n", strerror(errno)));
417 FD_SET(s,&listen_set);
418 maxfd = MAX( maxfd, s);
421 if (num_sockets >= FD_SETSIZE) {
422 DEBUG(0,("open_sockets_smbd: Too "
423 "many sockets to bind to\n"));
431 /* Just bind to 0.0.0.0 - accept connections
434 TALLOC_CTX *frame = talloc_stackframe();
437 const char *sock_addr = lp_socket_address();
439 const char *sock_ptr;
441 if (strequal(sock_addr, "0.0.0.0") ||
442 strequal(sock_addr, "::")) {
444 sock_addr = "::,0.0.0.0";
446 sock_addr = "0.0.0.0";
450 for (sock_ptr=sock_addr;
451 next_token_talloc(frame, &sock_ptr, &sock_tok, " \t,"); ) {
452 for (ptr=ports; next_token_talloc(frame, &ptr, &tok, " \t,"); ) {
453 struct sockaddr_storage ss;
455 unsigned port = atoi(tok);
456 if (port == 0 || port > 0xffff) {
460 /* Keep the first port for mDNS service
467 /* open an incoming socket */
468 if (!interpret_string_addr(&ss, sock_tok,
469 AI_NUMERICHOST|AI_PASSIVE)) {
473 s = open_socket_in(SOCK_STREAM,
475 num_sockets == 0 ? 0 : 2,
482 /* ready to listen */
483 set_socket_options(s,"SO_KEEPALIVE");
484 set_socket_options(s,lp_socket_options());
486 /* Set server socket to non-blocking
488 set_blocking(s,False);
490 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
491 DEBUG(0,("open_sockets_smbd: "
499 fd_listenset[num_sockets] = s;
500 FD_SET(s,&listen_set);
501 maxfd = MAX( maxfd, s);
505 if (num_sockets >= FD_SETSIZE) {
506 DEBUG(0,("open_sockets_smbd: Too "
507 "many sockets to bind to\n"));
518 if (num_sockets == 0) {
519 DEBUG(0,("open_sockets_smbd: No "
520 "sockets available to bind to.\n"));
524 /* Setup the main smbd so that we can get messages. Note that
525 do this after starting listening. This is needed as when in
526 clustered mode, ctdb won't allow us to start doing database
527 operations until it has gone thru a full startup, which
528 includes checking to see that smbd is listening. */
529 claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_SMBD);
531 /* Listen to messages */
533 messaging_register(smbd_messaging_context(), NULL,
534 MSG_SMB_SAM_SYNC, msg_sam_sync);
535 messaging_register(smbd_messaging_context(), NULL,
536 MSG_SHUTDOWN, msg_exit_server);
537 messaging_register(smbd_messaging_context(), NULL,
538 MSG_SMB_FILE_RENAME, msg_file_was_renamed);
539 messaging_register(smbd_messaging_context(), NULL,
540 MSG_SMB_CONF_UPDATED, smb_conf_updated);
541 messaging_register(smbd_messaging_context(), NULL,
542 MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
543 brl_register_msgs(smbd_messaging_context());
546 messaging_register(smbd_messaging_context(), NULL,
547 MSG_SMB_INJECT_FAULT, msg_inject_fault);
550 /* now accept incoming connections - forking a new process
551 for each incoming connection */
552 DEBUG(2,("waiting for a connection\n"));
554 struct timeval now, idle_timeout;
558 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
559 message_dispatch(smbd_messaging_context());
565 while ((pid = sys_waitpid(-1, NULL, WNOHANG)) > 0) {
566 remove_child_pid(pid);
570 idle_timeout = timeval_zero();
572 memcpy((char *)&r_fds, (char *)&listen_set,
577 /* Kick off our mDNS registration. */
579 dns_register_smbd(&dns_reg, dns_port, &maxfd,
580 &r_fds, &idle_timeout);
583 event_add_to_select_args(smbd_event_context(), &now,
584 &r_fds, &w_fds, &idle_timeout,
587 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
588 timeval_is_zero(&idle_timeout) ?
589 NULL : &idle_timeout);
591 if (num == -1 && errno == EINTR) {
593 exit_server_cleanly(NULL);
596 /* check for sighup processing */
597 if (reload_after_sighup) {
598 change_to_root_user();
599 DEBUG(1,("Reloading services after SIGHUP\n"));
600 reload_services(False);
601 reload_after_sighup = 0;
607 /* process pending nDNS responses */
608 if (dns_register_smbd_reply(dns_reg, &r_fds, &idle_timeout)) {
612 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
616 /* check if we need to reload services */
617 check_reload(time(NULL));
619 /* Find the sockets that are read-ready -
621 for( ; num > 0; num--) {
622 struct sockaddr addr;
623 socklen_t in_addrlen = sizeof(addr);
627 for(i = 0; i < num_sockets; i++) {
628 if(FD_ISSET(fd_listenset[i],&r_fds)) {
630 /* Clear this so we don't look
632 FD_CLR(fd_listenset[i],&r_fds);
637 smbd_set_server_fd(accept(s,&addr,&in_addrlen));
639 if (smbd_server_fd() == -1 && errno == EINTR)
642 if (smbd_server_fd() == -1) {
643 DEBUG(0,("open_sockets_smbd: accept: %s\n",
648 /* Ensure child is set to blocking mode */
649 set_blocking(smbd_server_fd(),True);
651 if (smbd_server_fd() != -1 && interactive)
654 if (allowable_number_of_smbd_processes() &&
655 smbd_server_fd() != -1 &&
656 ((child = sys_fork())==0)) {
657 char remaddr[INET6_ADDRSTRLEN];
661 /* Stop zombies, the parent explicitly handles
662 * them, counting worker smbds. */
665 /* close the listening socket(s) */
666 for(i = 0; i < num_sockets; i++)
667 close(fd_listenset[i]);
669 /* close our mDNS daemon handle */
670 dns_register_close(&dns_reg);
672 /* close our standard file
674 close_low_fds(False);
677 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
678 set_socket_options(smbd_server_fd(),
679 lp_socket_options());
681 /* this is needed so that we get decent entries
682 in smbstatus for port 445 connects */
683 set_remote_machine_name(get_peer_addr(smbd_server_fd(),
688 /* Reset the state of the random
689 * number generation system, so
690 * children do not get the same random
691 * numbers as each other */
693 set_need_random_reseed();
694 /* tdb needs special fork handling - remove
695 * CLEAR_IF_FIRST flags */
696 if (tdb_reopen_all(1) == -1) {
697 DEBUG(0,("tdb_reopen_all failed.\n"));
698 smb_panic("tdb_reopen_all failed");
703 /* The parent doesn't need this socket */
704 close(smbd_server_fd());
706 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
707 Clear the closed fd info out of server_fd --
708 and more importantly, out of client_fd in
709 util_sock.c, to avoid a possible
710 getpeername failure if we reopen the logs
711 and use %I in the filename.
714 smbd_set_server_fd(-1);
717 add_child_pid(child);
720 /* Force parent to check log size after
721 * spawning child. Fix from
722 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
723 * parent smbd will log to logserver.smb. It
724 * writes only two messages for each child
725 * started/finished. But each child writes,
726 * say, 50 messages also in logserver.smb,
727 * begining with the debug_count of the
728 * parent, before the child opens its own log
729 * file logserver.client. In a worst case
730 * scenario the size of logserver.smb would be
731 * checked after about 50*50=2500 messages
734 force_check_log_size();
739 /* NOTREACHED return True; */
742 /****************************************************************************
744 **************************************************************************/
745 void reload_printers(void)
748 int n_services = lp_numservices();
749 int pnum = lp_servicenumber(PRINTERS_NAME);
754 /* remove stale printers */
755 for (snum = 0; snum < n_services; snum++) {
756 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
757 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
758 lp_autoloaded(snum)))
761 pname = lp_printername(snum);
762 if (!pcap_printername_ok(pname)) {
763 DEBUG(3, ("removing stale printer %s\n", pname));
765 if (is_printer_published(NULL, snum, NULL))
766 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
767 del_a_printer(pname);
768 lp_killservice(snum);
775 /****************************************************************************
776 Reload the services file.
777 **************************************************************************/
779 bool reload_services(bool test)
784 char *fname = lp_configfile();
785 if (file_exist(fname, NULL) &&
786 !strcsequal(fname, get_dyn_CONFIGFILE())) {
787 set_dyn_CONFIGFILE(fname);
794 if (test && !lp_file_list_changed())
797 lp_killunused(conn_snum_used);
799 ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
803 /* perhaps the config filename is now set */
805 reload_services(True);
811 if (smbd_server_fd() != -1) {
812 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
813 set_socket_options(smbd_server_fd(), lp_socket_options());
816 mangle_reset_cache();
819 /* this forces service parameters to be flushed */
820 set_current_service(NULL,0,True);
825 /****************************************************************************
827 ****************************************************************************/
829 /* Reasons for shutting down a server process. */
830 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
832 static void exit_server_common(enum server_exit_reason how,
833 const char *const reason) NORETURN_ATTRIBUTE;
835 static void exit_server_common(enum server_exit_reason how,
836 const char *const reason)
838 static int firsttime=1;
844 change_to_root_user();
846 if (negprot_global_auth_context) {
847 (negprot_global_auth_context->free)(&negprot_global_auth_context);
852 invalidate_all_vuids();
854 /* 3 second timeout. */
855 print_notify_send_messages(smbd_messaging_context(), 3);
857 /* delete our entry in the connections database. */
858 yield_connection(NULL,"");
860 respond_to_all_remaining_local_messages();
863 if (dcelogin_atmost_once) {
871 if (how != SERVER_EXIT_NORMAL) {
872 int oldlevel = DEBUGLEVEL;
877 DEBUG(0,("Abnormal server exit: %s\n",
878 reason ? reason : "no explanation provided"));
883 DEBUGLEVEL = oldlevel;
887 DEBUG(3,("Server exit (%s)\n",
888 (reason ? reason : "normal exit")));
894 void exit_server(const char *const explanation)
896 exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
899 void exit_server_cleanly(const char *const explanation)
901 exit_server_common(SERVER_EXIT_NORMAL, explanation);
904 void exit_server_fault(void)
906 exit_server("critical server fault");
909 /****************************************************************************
910 Initialise connect, service and file structs.
911 ****************************************************************************/
913 static bool init_structs(void )
916 * Set the machine NETBIOS name if not already
917 * set from the config file.
938 * Send keepalive packets to our client
940 static bool keepalive_fn(const struct timeval *now, void *private_data)
942 if (!send_keepalive(smbd_server_fd())) {
943 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
950 * Do the recurring check if we're idle
952 static bool deadtime_fn(const struct timeval *now, void *private_data)
954 if ((conn_num_open() == 0)
955 || (conn_idle_all(now->tv_sec))) {
956 DEBUG( 2, ( "Closing idle connection\n" ) );
957 messaging_send(smbd_messaging_context(), procid_self(),
958 MSG_SHUTDOWN, &data_blob_null);
966 /****************************************************************************
968 ****************************************************************************/
970 /* Declare prototype for build_options() to avoid having to run it through
971 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
972 prototype generation system is too complicated. */
974 extern void build_options(bool screen);
976 int main(int argc,const char *argv[])
978 /* shall I run as a daemon */
979 static bool is_daemon = False;
980 static bool interactive = False;
981 static bool Fork = True;
982 static bool no_process_group = False;
983 static bool log_stdout = False;
984 static char *ports = NULL;
985 static char *profile_level = NULL;
988 bool print_build_options = False;
993 OPT_NO_PROCESS_GROUP,
996 struct poptOption long_options[] = {
998 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
999 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
1000 {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
1001 {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
1002 {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
1003 {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
1004 {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
1005 {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
1007 POPT_COMMON_DYNCONFIG
1010 TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
1014 #ifdef HAVE_SET_AUTH_PARAMETERS
1015 set_auth_parameters(argc,argv);
1018 pc = poptGetContext("smbd", argc, argv, long_options, 0);
1019 while((opt = poptGetNextOpt(pc)) != -1) {
1024 case OPT_INTERACTIVE:
1030 case OPT_NO_PROCESS_GROUP:
1031 no_process_group = true;
1033 case OPT_LOG_STDOUT:
1037 print_build_options = True;
1040 d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1041 poptBadOption(pc, 0), poptStrerror(opt));
1042 poptPrintUsage(pc, stderr, 0);
1046 poptFreeContext(pc);
1053 setup_logging(argv[0],log_stdout);
1055 if (print_build_options) {
1056 build_options(True); /* Display output to screen as well as debug */
1063 /* needed for SecureWare on SCO */
1069 set_remote_machine_name("smbd", False);
1071 if (interactive && (DEBUGLEVEL >= 9)) {
1072 talloc_enable_leak_report();
1075 if (log_stdout && Fork) {
1076 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1080 /* we want to re-seed early to prevent time delays causing
1081 client problems at a later date. (tridge) */
1082 generate_random_buffer(NULL, 0);
1084 /* make absolutely sure we run as root - to handle cases where people
1085 are crazy enough to have it setuid */
1087 gain_root_privilege();
1088 gain_root_group_privilege();
1090 fault_setup((void (*)(void *))exit_server_fault);
1091 dump_core_setup("smbd");
1093 CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
1094 CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
1096 /* we are never interested in SIGPIPE */
1097 BlockSignals(True,SIGPIPE);
1100 /* we are never interested in SIGFPE */
1101 BlockSignals(True,SIGFPE);
1104 #if defined(SIGUSR2)
1105 /* We are no longer interested in USR2 */
1106 BlockSignals(True,SIGUSR2);
1109 /* POSIX demands that signals are inherited. If the invoking process has
1110 * these signals masked, we will have problems, as we won't recieve them. */
1111 BlockSignals(False, SIGHUP);
1112 BlockSignals(False, SIGUSR1);
1113 BlockSignals(False, SIGTERM);
1115 /* we want total control over the permissions on created files,
1116 so set our umask to 0 */
1123 DEBUG(0,("smbd version %s started.\n", SAMBA_VERSION_STRING));
1124 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1126 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1127 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1129 /* Output the build options to the debug log */
1130 build_options(False);
1132 if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1133 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1138 * Do this before reload_services.
1141 if (!reload_services(False))
1147 if (!profile_setup(smbd_messaging_context(), False)) {
1148 DEBUG(0,("ERROR: failed to setup profiling\n"));
1151 if (profile_level != NULL) {
1152 int pl = atoi(profile_level);
1153 struct server_id src;
1155 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1157 set_profile_level(pl, src);
1161 DEBUG(3,( "loaded services\n"));
1163 if (!is_daemon && !is_a_socket(0)) {
1165 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1168 * Setting is_daemon here prevents us from eventually calling
1169 * the open_sockets_inetd()
1175 if (is_daemon && !interactive) {
1176 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1177 become_daemon(Fork, no_process_group);
1182 * If we're interactive we want to set our own process group for
1183 * signal management.
1185 if (interactive && !no_process_group)
1186 setpgid( (pid_t)0, (pid_t)0);
1189 if (!directory_exist(lp_lockdir(), NULL))
1190 mkdir(lp_lockdir(), 0755);
1193 pidfile_create("smbd");
1195 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1197 if (smbd_messaging_context() == NULL)
1200 if (smbd_memcache() == NULL) {
1204 memcache_set_global(smbd_memcache());
1206 /* Initialise the password backed before the global_sam_sid
1207 to ensure that we fetch from ldap before we make a domain sid up */
1209 if(!initialize_password_db(False, smbd_event_context()))
1212 if (!secrets_init()) {
1213 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1217 if(!get_global_sam_sid()) {
1218 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1222 if (!session_init())
1225 if (!connections_init(True))
1228 if (!locking_init())
1233 if (!init_registry())
1237 if (!init_svcctl_db())
1241 if (!print_backend_init(smbd_messaging_context()))
1244 if (!init_guest_info()) {
1245 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1249 /* only start the background queue daemon if we are
1250 running as a daemon -- bad things will happen if
1251 smbd is launched via inetd and we fork a copy of
1254 if ( is_daemon && !interactive )
1255 start_background_queue();
1257 /* Always attempt to initialize DMAPI. We will only use it later if
1258 * lp_dmapi_support is set on the share, but we need a single global
1259 * session to work with.
1261 dmapi_init_session();
1263 if (!open_sockets_smbd(is_daemon, interactive, ports))
1267 * everything after this point is run after the fork()
1274 /* Possibly reload the services file. Only worth doing in
1275 * daemon mode. In inetd mode, we know we only just loaded this.
1278 reload_services(True);
1281 if (!init_account_policy()) {
1282 DEBUG(0,("Could not open account policy tdb.\n"));
1286 if (*lp_rootdir()) {
1287 if (sys_chroot(lp_rootdir()) == 0)
1288 DEBUG(2,("Changed root to %s\n", lp_rootdir()));
1292 if (!init_oplocks(smbd_messaging_context()))
1295 /* Setup aio signal handler. */
1296 initialize_async_io_handler();
1299 * For clustering, we need to re-init our ctdbd connection after the
1302 if (!NT_STATUS_IS_OK(messaging_reinit(smbd_messaging_context())))
1305 /* register our message handlers */
1306 messaging_register(smbd_messaging_context(), NULL,
1307 MSG_SMB_FORCE_TDIS, msg_force_tdis);
1309 if ((lp_keepalive() != 0)
1310 && !(event_add_idle(smbd_event_context(), NULL,
1311 timeval_set(lp_keepalive(), 0),
1312 "keepalive", keepalive_fn,
1314 DEBUG(0, ("Could not add keepalive event\n"));
1318 if (!(event_add_idle(smbd_event_context(), NULL,
1319 timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1320 "deadtime", deadtime_fn, NULL))) {
1321 DEBUG(0, ("Could not add deadtime event\n"));
1329 namecache_shutdown();
1331 exit_server_cleanly(NULL);