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, port, 0,
399 /* ready to listen */
400 set_socket_options(s,"SO_KEEPALIVE");
401 set_socket_options(s,lp_socket_options());
403 /* Set server socket to
404 * non-blocking for the accept. */
405 set_blocking(s,False);
407 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
408 DEBUG(0,("open_sockets_smbd: listen: "
409 "%s\n", strerror(errno)));
414 FD_SET(s,&listen_set);
415 maxfd = MAX( maxfd, s);
418 if (num_sockets >= FD_SETSIZE) {
419 DEBUG(0,("open_sockets_smbd: Too "
420 "many sockets to bind to\n"));
428 /* Just bind to 0.0.0.0 - accept connections
431 TALLOC_CTX *frame = talloc_stackframe();
434 const char *sock_addr = lp_socket_address();
436 const char *sock_ptr;
438 if (strequal(sock_addr, "0.0.0.0") ||
439 strequal(sock_addr, "::")) {
441 sock_addr = "::,0.0.0.0";
443 sock_addr = "0.0.0.0";
447 for (sock_ptr=sock_addr;
448 next_token_talloc(frame, &sock_ptr, &sock_tok, " \t,"); ) {
449 for (ptr=ports; next_token_talloc(frame, &ptr, &tok, " \t,"); ) {
450 struct sockaddr_storage ss;
452 unsigned port = atoi(tok);
453 if (port == 0 || port > 0xffff) {
457 /* Keep the first port for mDNS service
464 /* open an incoming socket */
465 if (!interpret_string_addr(&ss, sock_tok,
466 AI_NUMERICHOST|AI_PASSIVE)) {
470 s = open_socket_in(SOCK_STREAM, port, 0,
476 /* ready to listen */
477 set_socket_options(s,"SO_KEEPALIVE");
478 set_socket_options(s,lp_socket_options());
480 /* Set server socket to non-blocking
482 set_blocking(s,False);
484 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
485 DEBUG(0,("open_sockets_smbd: "
493 fd_listenset[num_sockets] = s;
494 FD_SET(s,&listen_set);
495 maxfd = MAX( maxfd, s);
499 if (num_sockets >= FD_SETSIZE) {
500 DEBUG(0,("open_sockets_smbd: Too "
501 "many sockets to bind to\n"));
512 if (num_sockets == 0) {
513 DEBUG(0,("open_sockets_smbd: No "
514 "sockets available to bind to.\n"));
518 /* Setup the main smbd so that we can get messages. Note that
519 do this after starting listening. This is needed as when in
520 clustered mode, ctdb won't allow us to start doing database
521 operations until it has gone thru a full startup, which
522 includes checking to see that smbd is listening. */
523 claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_SMBD);
525 /* Listen to messages */
527 messaging_register(smbd_messaging_context(), NULL,
528 MSG_SMB_SAM_SYNC, msg_sam_sync);
529 messaging_register(smbd_messaging_context(), NULL,
530 MSG_SHUTDOWN, msg_exit_server);
531 messaging_register(smbd_messaging_context(), NULL,
532 MSG_SMB_FILE_RENAME, msg_file_was_renamed);
533 messaging_register(smbd_messaging_context(), NULL,
534 MSG_SMB_CONF_UPDATED, smb_conf_updated);
535 messaging_register(smbd_messaging_context(), NULL,
536 MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
537 brl_register_msgs(smbd_messaging_context());
540 messaging_register(smbd_messaging_context(), NULL,
541 MSG_SMB_INJECT_FAULT, msg_inject_fault);
544 /* now accept incoming connections - forking a new process
545 for each incoming connection */
546 DEBUG(2,("waiting for a connection\n"));
548 struct timeval now, idle_timeout;
552 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
553 message_dispatch(smbd_messaging_context());
559 while ((pid = sys_waitpid(-1, NULL, WNOHANG)) > 0) {
560 remove_child_pid(pid);
564 idle_timeout = timeval_zero();
566 memcpy((char *)&r_fds, (char *)&listen_set,
571 /* Kick off our mDNS registration. */
573 dns_register_smbd(&dns_reg, dns_port, &maxfd,
574 &r_fds, &idle_timeout);
577 event_add_to_select_args(smbd_event_context(), &now,
578 &r_fds, &w_fds, &idle_timeout,
581 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
582 timeval_is_zero(&idle_timeout) ?
583 NULL : &idle_timeout);
585 if (num == -1 && errno == EINTR) {
587 exit_server_cleanly(NULL);
590 /* check for sighup processing */
591 if (reload_after_sighup) {
592 change_to_root_user();
593 DEBUG(1,("Reloading services after SIGHUP\n"));
594 reload_services(False);
595 reload_after_sighup = 0;
601 /* process pending nDNS responses */
602 if (dns_register_smbd_reply(dns_reg, &r_fds, &idle_timeout)) {
606 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
610 /* check if we need to reload services */
611 check_reload(time(NULL));
613 /* Find the sockets that are read-ready -
615 for( ; num > 0; num--) {
616 struct sockaddr addr;
617 socklen_t in_addrlen = sizeof(addr);
621 for(i = 0; i < num_sockets; i++) {
622 if(FD_ISSET(fd_listenset[i],&r_fds)) {
624 /* Clear this so we don't look
626 FD_CLR(fd_listenset[i],&r_fds);
631 smbd_set_server_fd(accept(s,&addr,&in_addrlen));
633 if (smbd_server_fd() == -1 && errno == EINTR)
636 if (smbd_server_fd() == -1) {
637 DEBUG(0,("open_sockets_smbd: accept: %s\n",
642 /* Ensure child is set to blocking mode */
643 set_blocking(smbd_server_fd(),True);
645 if (smbd_server_fd() != -1 && interactive)
648 if (allowable_number_of_smbd_processes() &&
649 smbd_server_fd() != -1 &&
650 ((child = sys_fork())==0)) {
651 char remaddr[INET6_ADDRSTRLEN];
655 /* Stop zombies, the parent explicitly handles
656 * them, counting worker smbds. */
659 /* close the listening socket(s) */
660 for(i = 0; i < num_sockets; i++)
661 close(fd_listenset[i]);
663 /* close our mDNS daemon handle */
664 dns_register_close(&dns_reg);
666 /* close our standard file
668 close_low_fds(False);
671 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
672 set_socket_options(smbd_server_fd(),
673 lp_socket_options());
675 /* this is needed so that we get decent entries
676 in smbstatus for port 445 connects */
677 set_remote_machine_name(get_peer_addr(smbd_server_fd(),
682 /* Reset the state of the random
683 * number generation system, so
684 * children do not get the same random
685 * numbers as each other */
687 set_need_random_reseed();
688 /* tdb needs special fork handling - remove
689 * CLEAR_IF_FIRST flags */
690 if (tdb_reopen_all(1) == -1) {
691 DEBUG(0,("tdb_reopen_all failed.\n"));
692 smb_panic("tdb_reopen_all failed");
697 /* The parent doesn't need this socket */
698 close(smbd_server_fd());
700 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
701 Clear the closed fd info out of server_fd --
702 and more importantly, out of client_fd in
703 util_sock.c, to avoid a possible
704 getpeername failure if we reopen the logs
705 and use %I in the filename.
708 smbd_set_server_fd(-1);
711 add_child_pid(child);
714 /* Force parent to check log size after
715 * spawning child. Fix from
716 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
717 * parent smbd will log to logserver.smb. It
718 * writes only two messages for each child
719 * started/finished. But each child writes,
720 * say, 50 messages also in logserver.smb,
721 * begining with the debug_count of the
722 * parent, before the child opens its own log
723 * file logserver.client. In a worst case
724 * scenario the size of logserver.smb would be
725 * checked after about 50*50=2500 messages
728 force_check_log_size();
733 /* NOTREACHED return True; */
736 /****************************************************************************
738 **************************************************************************/
739 void reload_printers(void)
742 int n_services = lp_numservices();
743 int pnum = lp_servicenumber(PRINTERS_NAME);
748 /* remove stale printers */
749 for (snum = 0; snum < n_services; snum++) {
750 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
751 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
752 lp_autoloaded(snum)))
755 pname = lp_printername(snum);
756 if (!pcap_printername_ok(pname)) {
757 DEBUG(3, ("removing stale printer %s\n", pname));
759 if (is_printer_published(NULL, snum, NULL))
760 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
761 del_a_printer(pname);
762 lp_killservice(snum);
769 /****************************************************************************
770 Reload the services file.
771 **************************************************************************/
773 bool reload_services(bool test)
778 char *fname = lp_configfile();
779 if (file_exist(fname, NULL) &&
780 !strcsequal(fname, get_dyn_CONFIGFILE())) {
781 set_dyn_CONFIGFILE(fname);
788 if (test && !lp_file_list_changed())
791 lp_killunused(conn_snum_used);
793 ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
797 /* perhaps the config filename is now set */
799 reload_services(True);
805 if (smbd_server_fd() != -1) {
806 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
807 set_socket_options(smbd_server_fd(), lp_socket_options());
810 mangle_reset_cache();
813 /* this forces service parameters to be flushed */
814 set_current_service(NULL,0,True);
819 /****************************************************************************
821 ****************************************************************************/
823 /* Reasons for shutting down a server process. */
824 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
826 static void exit_server_common(enum server_exit_reason how,
827 const char *const reason) NORETURN_ATTRIBUTE;
829 static void exit_server_common(enum server_exit_reason how,
830 const char *const reason)
832 static int firsttime=1;
838 change_to_root_user();
840 if (negprot_global_auth_context) {
841 (negprot_global_auth_context->free)(&negprot_global_auth_context);
846 invalidate_all_vuids();
848 /* 3 second timeout. */
849 print_notify_send_messages(smbd_messaging_context(), 3);
851 /* delete our entry in the connections database. */
852 yield_connection(NULL,"");
854 respond_to_all_remaining_local_messages();
857 if (dcelogin_atmost_once) {
865 if (how != SERVER_EXIT_NORMAL) {
866 int oldlevel = DEBUGLEVEL;
871 DEBUG(0,("Abnormal server exit: %s\n",
872 reason ? reason : "no explanation provided"));
877 DEBUGLEVEL = oldlevel;
881 DEBUG(3,("Server exit (%s)\n",
882 (reason ? reason : "normal exit")));
888 void exit_server(const char *const explanation)
890 exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
893 void exit_server_cleanly(const char *const explanation)
895 exit_server_common(SERVER_EXIT_NORMAL, explanation);
898 void exit_server_fault(void)
900 exit_server("critical server fault");
903 /****************************************************************************
904 Initialise connect, service and file structs.
905 ****************************************************************************/
907 static bool init_structs(void )
910 * Set the machine NETBIOS name if not already
911 * set from the config file.
932 * Send keepalive packets to our client
934 static bool keepalive_fn(const struct timeval *now, void *private_data)
936 if (!send_keepalive(smbd_server_fd())) {
937 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
944 * Do the recurring check if we're idle
946 static bool deadtime_fn(const struct timeval *now, void *private_data)
948 if ((conn_num_open() == 0)
949 || (conn_idle_all(now->tv_sec))) {
950 DEBUG( 2, ( "Closing idle connection\n" ) );
951 messaging_send(smbd_messaging_context(), procid_self(),
952 MSG_SHUTDOWN, &data_blob_null);
960 /****************************************************************************
962 ****************************************************************************/
964 /* Declare prototype for build_options() to avoid having to run it through
965 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
966 prototype generation system is too complicated. */
968 extern void build_options(bool screen);
970 int main(int argc,const char *argv[])
972 /* shall I run as a daemon */
973 static bool is_daemon = False;
974 static bool interactive = False;
975 static bool Fork = True;
976 static bool no_process_group = False;
977 static bool log_stdout = False;
978 static char *ports = NULL;
979 static char *profile_level = NULL;
982 bool print_build_options = False;
987 OPT_NO_PROCESS_GROUP,
990 struct poptOption long_options[] = {
992 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
993 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
994 {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
995 {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
996 {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
997 {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
998 {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
999 {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
1001 POPT_COMMON_DYNCONFIG
1004 TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
1008 #ifdef HAVE_SET_AUTH_PARAMETERS
1009 set_auth_parameters(argc,argv);
1012 pc = poptGetContext("smbd", argc, argv, long_options, 0);
1013 while((opt = poptGetNextOpt(pc)) != -1) {
1018 case OPT_INTERACTIVE:
1024 case OPT_NO_PROCESS_GROUP:
1025 no_process_group = true;
1027 case OPT_LOG_STDOUT:
1031 print_build_options = True;
1034 d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1035 poptBadOption(pc, 0), poptStrerror(opt));
1036 poptPrintUsage(pc, stderr, 0);
1040 poptFreeContext(pc);
1047 setup_logging(argv[0],log_stdout);
1049 if (print_build_options) {
1050 build_options(True); /* Display output to screen as well as debug */
1057 /* needed for SecureWare on SCO */
1063 set_remote_machine_name("smbd", False);
1065 if (interactive && (DEBUGLEVEL >= 9)) {
1066 talloc_enable_leak_report();
1069 if (log_stdout && Fork) {
1070 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1074 /* we want to re-seed early to prevent time delays causing
1075 client problems at a later date. (tridge) */
1076 generate_random_buffer(NULL, 0);
1078 /* make absolutely sure we run as root - to handle cases where people
1079 are crazy enough to have it setuid */
1081 gain_root_privilege();
1082 gain_root_group_privilege();
1084 fault_setup((void (*)(void *))exit_server_fault);
1085 dump_core_setup("smbd");
1087 CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
1088 CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
1090 /* we are never interested in SIGPIPE */
1091 BlockSignals(True,SIGPIPE);
1094 /* we are never interested in SIGFPE */
1095 BlockSignals(True,SIGFPE);
1098 #if defined(SIGUSR2)
1099 /* We are no longer interested in USR2 */
1100 BlockSignals(True,SIGUSR2);
1103 /* POSIX demands that signals are inherited. If the invoking process has
1104 * these signals masked, we will have problems, as we won't recieve them. */
1105 BlockSignals(False, SIGHUP);
1106 BlockSignals(False, SIGUSR1);
1107 BlockSignals(False, SIGTERM);
1109 /* we want total control over the permissions on created files,
1110 so set our umask to 0 */
1117 DEBUG(0,("smbd version %s started.\n", SAMBA_VERSION_STRING));
1118 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1120 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1121 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1123 /* Output the build options to the debug log */
1124 build_options(False);
1126 if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1127 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1132 * Do this before reload_services.
1135 if (!reload_services(False))
1141 if (!profile_setup(smbd_messaging_context(), False)) {
1142 DEBUG(0,("ERROR: failed to setup profiling\n"));
1145 if (profile_level != NULL) {
1146 int pl = atoi(profile_level);
1147 struct server_id src;
1149 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1151 set_profile_level(pl, src);
1155 DEBUG(3,( "loaded services\n"));
1157 if (!is_daemon && !is_a_socket(0)) {
1159 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1162 * Setting is_daemon here prevents us from eventually calling
1163 * the open_sockets_inetd()
1169 if (is_daemon && !interactive) {
1170 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1171 become_daemon(Fork, no_process_group);
1176 * If we're interactive we want to set our own process group for
1177 * signal management.
1179 if (interactive && !no_process_group)
1180 setpgid( (pid_t)0, (pid_t)0);
1183 if (!directory_exist(lp_lockdir(), NULL))
1184 mkdir(lp_lockdir(), 0755);
1187 pidfile_create("smbd");
1189 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1191 if (smbd_messaging_context() == NULL)
1194 if (smbd_memcache() == NULL) {
1198 memcache_set_global(smbd_memcache());
1200 /* Initialise the password backed before the global_sam_sid
1201 to ensure that we fetch from ldap before we make a domain sid up */
1203 if(!initialize_password_db(False, smbd_event_context()))
1206 if (!secrets_init()) {
1207 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1211 if(!get_global_sam_sid()) {
1212 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1216 if (!session_init())
1219 if (!connections_init(True))
1222 if (!locking_init())
1227 if (!init_registry())
1231 if (!init_svcctl_db())
1235 if (!print_backend_init(smbd_messaging_context()))
1238 if (!init_guest_info()) {
1239 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1243 /* only start the background queue daemon if we are
1244 running as a daemon -- bad things will happen if
1245 smbd is launched via inetd and we fork a copy of
1248 if ( is_daemon && !interactive )
1249 start_background_queue();
1251 /* Always attempt to initialize DMAPI. We will only use it later if
1252 * lp_dmapi_support is set on the share, but we need a single global
1253 * session to work with.
1255 dmapi_init_session();
1257 if (!open_sockets_smbd(is_daemon, interactive, ports))
1261 * everything after this point is run after the fork()
1268 /* Possibly reload the services file. Only worth doing in
1269 * daemon mode. In inetd mode, we know we only just loaded this.
1272 reload_services(True);
1275 if (!init_account_policy()) {
1276 DEBUG(0,("Could not open account policy tdb.\n"));
1280 if (*lp_rootdir()) {
1281 if (sys_chroot(lp_rootdir()) == 0)
1282 DEBUG(2,("Changed root to %s\n", lp_rootdir()));
1286 if (!init_oplocks(smbd_messaging_context()))
1289 /* Setup aio signal handler. */
1290 initialize_async_io_handler();
1293 * For clustering, we need to re-init our ctdbd connection after the
1296 if (!NT_STATUS_IS_OK(messaging_reinit(smbd_messaging_context())))
1299 /* register our message handlers */
1300 messaging_register(smbd_messaging_context(), NULL,
1301 MSG_SMB_FORCE_TDIS, msg_force_tdis);
1303 if ((lp_keepalive() != 0)
1304 && !(event_add_idle(smbd_event_context(), NULL,
1305 timeval_set(lp_keepalive(), 0),
1306 "keepalive", keepalive_fn,
1308 DEBUG(0, ("Could not add keepalive event\n"));
1312 if (!(event_add_idle(smbd_event_context(), NULL,
1313 timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1314 "deadtime", deadtime_fn, NULL))) {
1315 DEBUG(0, ("Could not add deadtime event\n"));
1323 namecache_shutdown();
1325 exit_server_cleanly(NULL);