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 #ifdef CLUSTER_SUPPORT
63 static int client_get_tcp_info(struct sockaddr_storage *server,
64 struct sockaddr_storage *client)
67 if (server_fd == -1) {
70 length = sizeof(*server);
71 if (getsockname(server_fd, (struct sockaddr *)server, &length) != 0) {
74 length = sizeof(*client);
75 if (getpeername(server_fd, (struct sockaddr *)client, &length) != 0) {
82 struct event_context *smbd_event_context(void)
84 static struct event_context *ctx;
86 if (!ctx && !(ctx = event_context_init(talloc_autofree_context()))) {
87 smb_panic("Could not init smbd event context");
92 struct messaging_context *smbd_messaging_context(void)
94 static struct messaging_context *ctx;
97 ctx = messaging_init(talloc_autofree_context(), server_id_self(),
98 smbd_event_context());
101 DEBUG(0, ("Could not init smbd messaging context.\n"));
106 struct memcache *smbd_memcache(void)
108 static struct memcache *cache;
111 && !(cache = memcache_init(talloc_autofree_context(),
112 lp_max_stat_cache_size()*1024))) {
114 smb_panic("Could not init smbd memcache");
119 /*******************************************************************
120 What to do when smb.conf is updated.
121 ********************************************************************/
123 static void smb_conf_updated(struct messaging_context *msg,
126 struct server_id server_id,
129 DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
130 "updated. Reloading.\n"));
131 reload_services(False);
135 /*******************************************************************
136 Delete a statcache entry.
137 ********************************************************************/
139 static void smb_stat_cache_delete(struct messaging_context *msg,
142 struct server_id server_id,
145 const char *name = (const char *)data->data;
146 DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
147 stat_cache_delete(name);
150 /****************************************************************************
152 ****************************************************************************/
154 static void sig_term(void)
157 sys_select_signal(SIGTERM);
160 /****************************************************************************
162 ****************************************************************************/
164 static void sig_hup(int sig)
166 reload_after_sighup = 1;
167 sys_select_signal(SIGHUP);
170 /****************************************************************************
172 ****************************************************************************/
173 static void sig_cld(int sig)
176 sys_select_signal(SIGCLD);
179 /****************************************************************************
180 Send a SIGTERM to our process group.
181 *****************************************************************************/
183 static void killkids(void)
185 if(am_parent) kill(0,SIGTERM);
188 /****************************************************************************
189 Process a sam sync message - not sure whether to do this here or
191 ****************************************************************************/
193 static void msg_sam_sync(struct messaging_context *msg,
196 struct server_id server_id,
199 DEBUG(10, ("** sam sync message received, ignoring\n"));
203 /****************************************************************************
204 Open the socket communication - inetd.
205 ****************************************************************************/
207 static bool open_sockets_inetd(void)
209 /* Started from inetd. fd 0 is the socket. */
210 /* We will abort gracefully when the client or remote system
212 smbd_set_server_fd(dup(0));
214 /* close our standard file descriptors */
215 close_low_fds(False); /* Don't close stderr */
217 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
218 set_socket_options(smbd_server_fd(), lp_socket_options());
223 static void msg_exit_server(struct messaging_context *msg,
226 struct server_id server_id,
229 DEBUG(3, ("got a SHUTDOWN message\n"));
230 exit_server_cleanly(NULL);
234 static void msg_inject_fault(struct messaging_context *msg,
237 struct server_id src,
242 if (data->length != sizeof(sig)) {
244 DEBUG(0, ("Process %s sent bogus signal injection request\n",
245 procid_str_static(&src)));
249 sig = *(int *)data->data;
251 exit_server("internal error injected");
256 DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
257 procid_str_static(&src), sig, strsignal(sig)));
259 DEBUG(0, ("Process %s requested injection of signal %d\n",
260 procid_str_static(&src), sig));
263 kill(sys_getpid(), sig);
265 #endif /* DEVELOPER */
268 struct child_pid *prev, *next;
272 static struct child_pid *children;
273 static int num_children;
275 static void add_child_pid(pid_t pid)
277 struct child_pid *child;
279 if (lp_max_smbd_processes() == 0) {
280 /* Don't bother with the child list if we don't care anyway */
284 child = SMB_MALLOC_P(struct child_pid);
286 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
290 DLIST_ADD(children, child);
294 static void remove_child_pid(pid_t pid, bool unclean_shutdown)
296 struct child_pid *child;
298 if (unclean_shutdown) {
299 /* a child terminated uncleanly so tickle all processes to see
300 if they can grab any of the pending locks
302 DEBUG(3,(__location__ " Unclean shutdown of pid %u\n", pid));
303 messaging_send_buf(smbd_messaging_context(), procid_self(),
304 MSG_SMB_BRL_VALIDATE, NULL, 0);
305 message_send_all(smbd_messaging_context(),
306 MSG_SMB_UNLOCK, NULL, 0, NULL);
309 if (lp_max_smbd_processes() == 0) {
310 /* Don't bother with the child list if we don't care anyway */
314 for (child = children; child != NULL; child = child->next) {
315 if (child->pid == pid) {
316 struct child_pid *tmp = child;
317 DLIST_REMOVE(children, child);
324 DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid));
327 /****************************************************************************
328 Have we reached the process limit ?
329 ****************************************************************************/
331 static bool allowable_number_of_smbd_processes(void)
333 int max_processes = lp_max_smbd_processes();
338 return num_children < max_processes;
341 /****************************************************************************
342 Open the socket communication.
343 ****************************************************************************/
345 static bool open_sockets_smbd(bool is_daemon, bool interactive, const char *smb_ports)
347 int num_interfaces = iface_count();
349 int fd_listenset[FD_SETSIZE];
355 struct dns_reg_state * dns_reg = NULL;
356 unsigned dns_port = 0;
359 return open_sockets_inetd();
364 static int atexit_set;
365 if(atexit_set == 0) {
373 CatchSignal(SIGCLD, sig_cld);
375 FD_ZERO(&listen_set);
377 /* use a reasonable default set of ports - listing on 445 and 139 */
379 ports = lp_smb_ports();
380 if (!ports || !*ports) {
381 ports = smb_xstrdup(SMB_PORTS);
383 ports = smb_xstrdup(ports);
386 ports = smb_xstrdup(smb_ports);
389 if (lp_interfaces() && lp_bind_interfaces_only()) {
390 /* We have been given an interfaces line, and been
391 told to only bind to those interfaces. Create a
392 socket per interface and bind to only these.
395 /* Now open a listen socket for each of the
397 for(i = 0; i < num_interfaces; i++) {
398 TALLOC_CTX *frame = NULL;
399 const struct sockaddr_storage *ifss =
400 iface_n_sockaddr_storage(i);
405 DEBUG(0,("open_sockets_smbd: "
406 "interface %d has NULL IP address !\n",
411 frame = talloc_stackframe();
413 next_token_talloc(frame,&ptr, &tok, " \t,");) {
414 unsigned port = atoi(tok);
415 if (port == 0 || port > 0xffff) {
419 /* Keep the first port for mDNS service
426 s = fd_listenset[num_sockets] =
427 open_socket_in(SOCK_STREAM,
429 num_sockets == 0 ? 0 : 2,
436 /* ready to listen */
437 set_socket_options(s,"SO_KEEPALIVE");
438 set_socket_options(s,lp_socket_options());
440 /* Set server socket to
441 * non-blocking for the accept. */
442 set_blocking(s,False);
444 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
445 DEBUG(0,("open_sockets_smbd: listen: "
446 "%s\n", strerror(errno)));
451 FD_SET(s,&listen_set);
452 maxfd = MAX( maxfd, s);
455 if (num_sockets >= FD_SETSIZE) {
456 DEBUG(0,("open_sockets_smbd: Too "
457 "many sockets to bind to\n"));
465 /* Just bind to 0.0.0.0 - accept connections
468 TALLOC_CTX *frame = talloc_stackframe();
471 const char *sock_addr = lp_socket_address();
473 const char *sock_ptr;
475 if (strequal(sock_addr, "0.0.0.0") ||
476 strequal(sock_addr, "::")) {
478 sock_addr = "::,0.0.0.0";
480 sock_addr = "0.0.0.0";
484 for (sock_ptr=sock_addr;
485 next_token_talloc(frame, &sock_ptr, &sock_tok, " \t,"); ) {
486 for (ptr=ports; next_token_talloc(frame, &ptr, &tok, " \t,"); ) {
487 struct sockaddr_storage ss;
489 unsigned port = atoi(tok);
490 if (port == 0 || port > 0xffff) {
494 /* Keep the first port for mDNS service
501 /* open an incoming socket */
502 if (!interpret_string_addr(&ss, sock_tok,
503 AI_NUMERICHOST|AI_PASSIVE)) {
507 s = open_socket_in(SOCK_STREAM,
509 num_sockets == 0 ? 0 : 2,
516 /* ready to listen */
517 set_socket_options(s,"SO_KEEPALIVE");
518 set_socket_options(s,lp_socket_options());
520 /* Set server socket to non-blocking
522 set_blocking(s,False);
524 if (listen(s, SMBD_LISTEN_BACKLOG) == -1) {
525 DEBUG(0,("open_sockets_smbd: "
533 fd_listenset[num_sockets] = s;
534 FD_SET(s,&listen_set);
535 maxfd = MAX( maxfd, s);
539 if (num_sockets >= FD_SETSIZE) {
540 DEBUG(0,("open_sockets_smbd: Too "
541 "many sockets to bind to\n"));
552 if (num_sockets == 0) {
553 DEBUG(0,("open_sockets_smbd: No "
554 "sockets available to bind to.\n"));
558 /* Setup the main smbd so that we can get messages. Note that
559 do this after starting listening. This is needed as when in
560 clustered mode, ctdb won't allow us to start doing database
561 operations until it has gone thru a full startup, which
562 includes checking to see that smbd is listening. */
563 claim_connection(NULL,"",
564 FLAG_MSG_GENERAL|FLAG_MSG_SMBD|FLAG_MSG_DBWRAP);
566 /* Listen to messages */
568 messaging_register(smbd_messaging_context(), NULL,
569 MSG_SMB_SAM_SYNC, msg_sam_sync);
570 messaging_register(smbd_messaging_context(), NULL,
571 MSG_SHUTDOWN, msg_exit_server);
572 messaging_register(smbd_messaging_context(), NULL,
573 MSG_SMB_FILE_RENAME, msg_file_was_renamed);
574 messaging_register(smbd_messaging_context(), NULL,
575 MSG_SMB_CONF_UPDATED, smb_conf_updated);
576 messaging_register(smbd_messaging_context(), NULL,
577 MSG_SMB_STAT_CACHE_DELETE, smb_stat_cache_delete);
578 brl_register_msgs(smbd_messaging_context());
580 #ifdef CLUSTER_SUPPORT
581 if (lp_clustering()) {
582 ctdbd_register_reconfigure(messaging_ctdbd_connection());
587 messaging_register(smbd_messaging_context(), NULL,
588 MSG_SMB_INJECT_FAULT, msg_inject_fault);
591 /* now accept incoming connections - forking a new process
592 for each incoming connection */
593 DEBUG(2,("waiting for a connection\n"));
595 struct timeval now, idle_timeout;
599 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
600 message_dispatch(smbd_messaging_context());
608 while ((pid = sys_waitpid(-1, &status, WNOHANG)) > 0) {
609 bool unclean_shutdown = False;
611 /* If the child terminated normally, assume
612 it was an unclean shutdown unless the
615 if (WIFEXITED(status)) {
616 unclean_shutdown = WEXITSTATUS(status);
618 /* If the child terminated due to a signal
619 we always assume it was unclean.
621 if (WIFSIGNALED(status)) {
622 unclean_shutdown = True;
624 remove_child_pid(pid, unclean_shutdown);
628 idle_timeout = timeval_zero();
630 memcpy((char *)&r_fds, (char *)&listen_set,
635 /* Kick off our mDNS registration. */
637 dns_register_smbd(&dns_reg, dns_port, &maxfd,
638 &r_fds, &idle_timeout);
641 event_add_to_select_args(smbd_event_context(), &now,
642 &r_fds, &w_fds, &idle_timeout,
645 num = sys_select(maxfd+1,&r_fds,&w_fds,NULL,
646 timeval_is_zero(&idle_timeout) ?
647 NULL : &idle_timeout);
649 if (num == -1 && errno == EINTR) {
651 exit_server_cleanly(NULL);
654 /* check for sighup processing */
655 if (reload_after_sighup) {
656 change_to_root_user();
657 DEBUG(1,("Reloading services after SIGHUP\n"));
658 reload_services(False);
659 reload_after_sighup = 0;
666 /* If the idle timeout fired and we don't have any connected
667 * users, exit gracefully. We should be running under a process
668 * controller that will restart us if necessry.
670 if (num == 0 && count_all_current_connections() == 0) {
671 exit_server_cleanly("idle timeout");
674 /* process pending nDNS responses */
675 if (dns_register_smbd_reply(dns_reg, &r_fds, &idle_timeout)) {
679 if (run_events(smbd_event_context(), num, &r_fds, &w_fds)) {
683 /* check if we need to reload services */
684 check_reload(time(NULL));
686 /* Find the sockets that are read-ready -
688 for( ; num > 0; num--) {
689 struct sockaddr addr;
690 socklen_t in_addrlen = sizeof(addr);
694 for(i = 0; i < num_sockets; i++) {
695 if(FD_ISSET(fd_listenset[i],&r_fds)) {
697 /* Clear this so we don't look
699 FD_CLR(fd_listenset[i],&r_fds);
704 smbd_set_server_fd(accept(s,&addr,&in_addrlen));
706 if (smbd_server_fd() == -1 && errno == EINTR)
709 if (smbd_server_fd() == -1) {
710 DEBUG(2,("open_sockets_smbd: accept: %s\n",
715 /* Ensure child is set to blocking mode */
716 set_blocking(smbd_server_fd(),True);
718 if (smbd_server_fd() != -1 && interactive)
721 if (allowable_number_of_smbd_processes() &&
722 smbd_server_fd() != -1 &&
723 ((child = sys_fork())==0)) {
724 char remaddr[INET6_ADDRSTRLEN];
728 /* Stop zombies, the parent explicitly handles
729 * them, counting worker smbds. */
732 /* close the listening socket(s) */
733 for(i = 0; i < num_sockets; i++)
734 close(fd_listenset[i]);
736 /* close our mDNS daemon handle */
737 dns_register_close(&dns_reg);
739 /* close our standard file
741 close_low_fds(False);
744 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
745 set_socket_options(smbd_server_fd(),
746 lp_socket_options());
748 /* this is needed so that we get decent entries
749 in smbstatus for port 445 connects */
750 set_remote_machine_name(get_peer_addr(smbd_server_fd(),
755 if (!reinit_after_fork(
756 smbd_messaging_context(),
757 smbd_event_context(),
759 DEBUG(0,("reinit_after_fork() failed\n"));
760 smb_panic("reinit_after_fork() failed");
765 /* The parent doesn't need this socket */
766 close(smbd_server_fd());
768 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
769 Clear the closed fd info out of server_fd --
770 and more importantly, out of client_fd in
771 util_sock.c, to avoid a possible
772 getpeername failure if we reopen the logs
773 and use %I in the filename.
776 smbd_set_server_fd(-1);
779 add_child_pid(child);
782 /* Force parent to check log size after
783 * spawning child. Fix from
784 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
785 * parent smbd will log to logserver.smb. It
786 * writes only two messages for each child
787 * started/finished. But each child writes,
788 * say, 50 messages also in logserver.smb,
789 * begining with the debug_count of the
790 * parent, before the child opens its own log
791 * file logserver.client. In a worst case
792 * scenario the size of logserver.smb would be
793 * checked after about 50*50=2500 messages
796 force_check_log_size();
801 /* NOTREACHED return True; */
804 /****************************************************************************
806 **************************************************************************/
807 void reload_printers(void)
810 int n_services = lp_numservices();
811 int pnum = lp_servicenumber(PRINTERS_NAME);
816 /* remove stale printers */
817 for (snum = 0; snum < n_services; snum++) {
818 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
819 if (snum == pnum || !(lp_snum_ok(snum) && lp_print_ok(snum) &&
820 lp_autoloaded(snum)))
823 pname = lp_printername(snum);
824 if (!pcap_printername_ok(pname)) {
825 DEBUG(3, ("removing stale printer %s\n", pname));
827 if (is_printer_published(NULL, snum, NULL))
828 nt_printer_publish(NULL, snum, SPOOL_DS_UNPUBLISH);
829 del_a_printer(pname);
830 lp_killservice(snum);
837 /****************************************************************************
838 Reload the services file.
839 **************************************************************************/
841 bool reload_services(bool test)
846 char *fname = lp_configfile();
847 if (file_exist(fname) &&
848 !strcsequal(fname, get_dyn_CONFIGFILE())) {
849 set_dyn_CONFIGFILE(fname);
856 if (test && !lp_file_list_changed())
859 lp_killunused(conn_snum_used);
861 ret = lp_load(get_dyn_CONFIGFILE(), False, False, True, True);
865 /* perhaps the config filename is now set */
867 reload_services(True);
873 if (smbd_server_fd() != -1) {
874 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
875 set_socket_options(smbd_server_fd(), lp_socket_options());
878 mangle_reset_cache();
881 /* this forces service parameters to be flushed */
882 set_current_service(NULL,0,True);
887 /****************************************************************************
889 ****************************************************************************/
891 /* Reasons for shutting down a server process. */
892 enum server_exit_reason { SERVER_EXIT_NORMAL, SERVER_EXIT_ABNORMAL };
894 static void exit_server_common(enum server_exit_reason how,
895 const char *const reason) _NORETURN_;
897 static void exit_server_common(enum server_exit_reason how,
898 const char *const reason)
900 static int firsttime=1;
907 change_to_root_user();
909 if (negprot_global_auth_context) {
910 (negprot_global_auth_context->free)(&negprot_global_auth_context);
913 had_open_conn = conn_close_all();
915 invalidate_all_vuids();
917 /* 3 second timeout. */
918 print_notify_send_messages(smbd_messaging_context(), 3);
920 /* delete our entry in the connections database. */
921 yield_connection(NULL,"");
923 respond_to_all_remaining_local_messages();
926 if (dcelogin_atmost_once) {
932 /* Destroy Samba DMAPI session only if we are master smbd process */
934 if (!dmapi_destroy_session()) {
935 DEBUG(0,("Unable to close Samba DMAPI session\n"));
943 if (how != SERVER_EXIT_NORMAL) {
944 int oldlevel = DEBUGLEVEL;
949 DEBUG(0,("Abnormal server exit: %s\n",
950 reason ? reason : "no explanation provided"));
955 DEBUGLEVEL = oldlevel;
959 DEBUG(3,("Server exit (%s)\n",
960 (reason ? reason : "normal exit")));
963 /* if we had any open SMB connections when we exited then we
964 need to tell the parent smbd so that it can trigger a retry
965 of any locks we may have been holding or open files we were
974 void exit_server(const char *const explanation)
976 exit_server_common(SERVER_EXIT_ABNORMAL, explanation);
979 void exit_server_cleanly(const char *const explanation)
981 exit_server_common(SERVER_EXIT_NORMAL, explanation);
984 void exit_server_fault(void)
986 exit_server("critical server fault");
990 /****************************************************************************
991 received when we should release a specific IP
992 ****************************************************************************/
993 static void release_ip(const char *ip, void *priv)
995 char addr[INET6_ADDRSTRLEN];
997 if (strcmp(client_socket_addr(get_client_fd(),addr,sizeof(addr)), ip) == 0) {
998 /* we can't afford to do a clean exit - that involves
999 database writes, which would potentially mean we
1000 are still running after the failover has finished -
1001 we have to get rid of this process ID straight
1003 DEBUG(0,("Got release IP message for our IP %s - exiting immediately\n",
1005 /* note we must exit with non-zero status so the unclean handler gets
1006 called in the parent, so that the brl database is tickled */
1011 static void msg_release_ip(struct messaging_context *msg_ctx, void *private_data,
1012 uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)
1014 release_ip((char *)data->data, NULL);
1017 /****************************************************************************
1018 Initialise connect, service and file structs.
1019 ****************************************************************************/
1021 static bool init_structs(void )
1024 * Set the machine NETBIOS name if not already
1025 * set from the config file.
1036 init_rpc_pipe_hnd();
1040 if (!secrets_init())
1047 * Send keepalive packets to our client
1049 static bool keepalive_fn(const struct timeval *now, void *private_data)
1051 if (!send_keepalive(smbd_server_fd())) {
1052 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
1059 * Do the recurring check if we're idle
1061 static bool deadtime_fn(const struct timeval *now, void *private_data)
1063 if ((conn_num_open() == 0)
1064 || (conn_idle_all(now->tv_sec))) {
1065 DEBUG( 2, ( "Closing idle connection\n" ) );
1066 messaging_send(smbd_messaging_context(), procid_self(),
1067 MSG_SHUTDOWN, &data_blob_null);
1075 * Do the recurring log file and smb.conf reload checks.
1078 static bool housekeeping_fn(const struct timeval *now, void *private_data)
1080 change_to_root_user();
1082 /* update printer queue caches if necessary */
1083 update_monitored_printq_cache();
1085 /* check if we need to reload services */
1086 check_reload(time(NULL));
1088 /* Change machine password if neccessary. */
1089 attempt_machine_password_change();
1092 * Force a log file check.
1094 force_check_log_size();
1099 /****************************************************************************
1101 ****************************************************************************/
1103 /* Declare prototype for build_options() to avoid having to run it through
1104 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
1105 prototype generation system is too complicated. */
1107 extern void build_options(bool screen);
1109 int main(int argc,const char *argv[])
1111 /* shall I run as a daemon */
1112 static bool is_daemon = False;
1113 static bool interactive = False;
1114 static bool Fork = True;
1115 static bool no_process_group = False;
1116 static bool log_stdout = False;
1117 static char *ports = NULL;
1118 static char *profile_level = NULL;
1121 bool print_build_options = False;
1126 OPT_NO_PROCESS_GROUP,
1129 struct poptOption long_options[] = {
1131 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
1132 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
1133 {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
1134 {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
1135 {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
1136 {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
1137 {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
1138 {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
1140 POPT_COMMON_DYNCONFIG
1143 TALLOC_CTX *frame = talloc_stackframe(); /* Setup tos. */
1147 #ifdef HAVE_SET_AUTH_PARAMETERS
1148 set_auth_parameters(argc,argv);
1151 pc = poptGetContext("smbd", argc, argv, long_options, 0);
1152 while((opt = poptGetNextOpt(pc)) != -1) {
1157 case OPT_INTERACTIVE:
1163 case OPT_NO_PROCESS_GROUP:
1164 no_process_group = true;
1166 case OPT_LOG_STDOUT:
1170 print_build_options = True;
1173 d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1174 poptBadOption(pc, 0), poptStrerror(opt));
1175 poptPrintUsage(pc, stderr, 0);
1179 poptFreeContext(pc);
1186 setup_logging(argv[0],log_stdout);
1188 if (print_build_options) {
1189 build_options(True); /* Display output to screen as well as debug */
1196 /* needed for SecureWare on SCO */
1202 set_remote_machine_name("smbd", False);
1204 if (interactive && (DEBUGLEVEL >= 9)) {
1205 talloc_enable_leak_report();
1208 if (log_stdout && Fork) {
1209 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1213 /* we want to re-seed early to prevent time delays causing
1214 client problems at a later date. (tridge) */
1215 generate_random_buffer(NULL, 0);
1217 /* make absolutely sure we run as root - to handle cases where people
1218 are crazy enough to have it setuid */
1220 gain_root_privilege();
1221 gain_root_group_privilege();
1223 fault_setup((void (*)(void *))exit_server_fault);
1224 dump_core_setup("smbd");
1226 CatchSignal(SIGTERM , SIGNAL_CAST sig_term);
1227 CatchSignal(SIGHUP,SIGNAL_CAST sig_hup);
1229 /* we are never interested in SIGPIPE */
1230 BlockSignals(True,SIGPIPE);
1233 /* we are never interested in SIGFPE */
1234 BlockSignals(True,SIGFPE);
1237 #if defined(SIGUSR2)
1238 /* We are no longer interested in USR2 */
1239 BlockSignals(True,SIGUSR2);
1242 /* POSIX demands that signals are inherited. If the invoking process has
1243 * these signals masked, we will have problems, as we won't recieve them. */
1244 BlockSignals(False, SIGHUP);
1245 BlockSignals(False, SIGUSR1);
1246 BlockSignals(False, SIGTERM);
1248 /* we want total control over the permissions on created files,
1249 so set our umask to 0 */
1256 DEBUG(0,("smbd version %s started.\n", SAMBA_VERSION_STRING));
1257 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1259 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1260 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1262 /* Output the build options to the debug log */
1263 build_options(False);
1265 if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1266 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1270 if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1271 DEBUG(0, ("error opening config file\n"));
1275 if (smbd_messaging_context() == NULL)
1278 if (!reload_services(False))
1284 if (!profile_setup(smbd_messaging_context(), False)) {
1285 DEBUG(0,("ERROR: failed to setup profiling\n"));
1288 if (profile_level != NULL) {
1289 int pl = atoi(profile_level);
1290 struct server_id src;
1292 DEBUG(1, ("setting profiling level: %s\n",profile_level));
1294 set_profile_level(pl, src);
1298 DEBUG(3,( "loaded services\n"));
1300 if (!is_daemon && !is_a_socket(0)) {
1302 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1305 * Setting is_daemon here prevents us from eventually calling
1306 * the open_sockets_inetd()
1312 if (is_daemon && !interactive) {
1313 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1314 become_daemon(Fork, no_process_group);
1319 * If we're interactive we want to set our own process group for
1320 * signal management.
1322 if (interactive && !no_process_group)
1323 setpgid( (pid_t)0, (pid_t)0);
1326 if (!directory_exist(lp_lockdir()))
1327 mkdir(lp_lockdir(), 0755);
1330 pidfile_create("smbd");
1332 if (!reinit_after_fork(smbd_messaging_context(),
1333 smbd_event_context(), false)) {
1334 DEBUG(0,("reinit_after_fork() failed\n"));
1338 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1340 if (smbd_memcache() == NULL) {
1344 memcache_set_global(smbd_memcache());
1346 /* Initialise the password backed before the global_sam_sid
1347 to ensure that we fetch from ldap before we make a domain sid up */
1349 if(!initialize_password_db(False, smbd_event_context()))
1352 if (!secrets_init()) {
1353 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1357 if(!get_global_sam_sid()) {
1358 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1362 if (!session_init())
1365 if (!connections_init(True))
1368 if (!locking_init())
1373 if (!W_ERROR_IS_OK(registry_init_full()))
1377 if (!init_svcctl_db())
1381 if (!print_backend_init(smbd_messaging_context()))
1384 if (!init_guest_info()) {
1385 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1389 /* only start the background queue daemon if we are
1390 running as a daemon -- bad things will happen if
1391 smbd is launched via inetd and we fork a copy of
1394 if (is_daemon && !interactive
1395 && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1396 start_background_queue();
1399 if (!open_sockets_smbd(is_daemon, interactive, ports))
1403 * everything after this point is run after the fork()
1410 /* Possibly reload the services file. Only worth doing in
1411 * daemon mode. In inetd mode, we know we only just loaded this.
1414 reload_services(True);
1417 if (!init_account_policy()) {
1418 DEBUG(0,("Could not open account policy tdb.\n"));
1422 if (*lp_rootdir()) {
1423 if (chroot(lp_rootdir()) == 0)
1424 DEBUG(2,("Changed root to %s\n", lp_rootdir()));
1428 if (!init_oplocks(smbd_messaging_context()))
1431 /* Setup aio signal handler. */
1432 initialize_async_io_handler();
1434 /* register our message handlers */
1435 messaging_register(smbd_messaging_context(), NULL,
1436 MSG_SMB_FORCE_TDIS, msg_force_tdis);
1437 messaging_register(smbd_messaging_context(), NULL,
1438 MSG_SMB_RELEASE_IP, msg_release_ip);
1439 messaging_register(smbd_messaging_context(), NULL,
1440 MSG_SMB_CLOSE_FILE, msg_close_file);
1442 if ((lp_keepalive() != 0)
1443 && !(event_add_idle(smbd_event_context(), NULL,
1444 timeval_set(lp_keepalive(), 0),
1445 "keepalive", keepalive_fn,
1447 DEBUG(0, ("Could not add keepalive event\n"));
1451 if (!(event_add_idle(smbd_event_context(), NULL,
1452 timeval_set(IDLE_CLOSED_TIMEOUT, 0),
1453 "deadtime", deadtime_fn, NULL))) {
1454 DEBUG(0, ("Could not add deadtime event\n"));
1458 if (!(event_add_idle(smbd_event_context(), NULL,
1459 timeval_set(SMBD_SELECT_TIMEOUT, 0),
1460 "housekeeping", housekeeping_fn, NULL))) {
1461 DEBUG(0, ("Could not add housekeeping event\n"));
1465 #ifdef CLUSTER_SUPPORT
1467 if (lp_clustering()) {
1469 * We need to tell ctdb about our client's TCP
1470 * connection, so that for failover ctdbd can send
1471 * tickle acks, triggering a reconnection by the
1475 struct sockaddr_storage srv, clnt;
1477 if (client_get_tcp_info(&srv, &clnt) == 0) {
1481 status = ctdbd_register_ips(
1482 messaging_ctdbd_connection(),
1483 (struct sockaddr *)&srv,
1484 (struct sockaddr *)&clnt,
1487 if (!NT_STATUS_IS_OK(status)) {
1488 DEBUG(0, ("ctdbd_register_ips failed: %s\n",
1489 nt_errstr(status)));
1493 DEBUG(0,("Unable to get tcp info for "
1494 "CTDB_CONTROL_TCP_CLIENT: %s\n",
1505 namecache_shutdown();
1507 exit_server_cleanly(NULL);