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", (unsigned int)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 /* Kick off our mDNS registration. */
593 #ifdef WITH_AVAHI_SUPPORT
595 avahi_conn
= avahi_start_register(
596 smbd_event_context(), smbd_event_context(),
598 if (avahi_conn
== NULL
) {
599 DEBUG(10, ("avahi_start_register failed\n"));
604 /* now accept incoming connections - forking a new process
605 for each incoming connection */
606 DEBUG(2,("waiting for a connection\n"));
608 struct timeval now
, idle_timeout
;
612 /* Ensure we respond to PING and DEBUG messages from the main smbd. */
613 message_dispatch(smbd_messaging_context());
621 while ((pid
= sys_waitpid(-1, &status
, WNOHANG
)) > 0) {
622 bool unclean_shutdown
= False
;
624 /* If the child terminated normally, assume
625 it was an unclean shutdown unless the
628 if (WIFEXITED(status
)) {
629 unclean_shutdown
= WEXITSTATUS(status
);
631 /* If the child terminated due to a signal
632 we always assume it was unclean.
634 if (WIFSIGNALED(status
)) {
635 unclean_shutdown
= True
;
637 remove_child_pid(pid
, unclean_shutdown
);
641 idle_timeout
= timeval_zero();
643 memcpy((char *)&r_fds
, (char *)&listen_set
,
648 event_add_to_select_args(smbd_event_context(), &now
,
649 &r_fds
, &w_fds
, &idle_timeout
,
652 num
= sys_select(maxfd
+1,&r_fds
,&w_fds
,NULL
,
653 timeval_is_zero(&idle_timeout
) ?
654 NULL
: &idle_timeout
);
656 if (num
== -1 && errno
== EINTR
) {
658 exit_server_cleanly(NULL
);
661 /* check for sighup processing */
662 if (reload_after_sighup
) {
663 change_to_root_user();
664 DEBUG(1,("Reloading services after SIGHUP\n"));
665 reload_services(False
);
666 reload_after_sighup
= 0;
673 /* If the idle timeout fired and we don't have any connected
674 * users, exit gracefully. We should be running under a process
675 * controller that will restart us if necessry.
677 if (num
== 0 && count_all_current_connections() == 0) {
678 exit_server_cleanly("idle timeout");
681 /* process pending nDNS responses */
682 if (dns_register_smbd_reply(dns_reg
, &r_fds
, &idle_timeout
)) {
686 if (run_events(smbd_event_context(), num
, &r_fds
, &w_fds
)) {
690 /* check if we need to reload services */
691 check_reload(time(NULL
));
693 /* Find the sockets that are read-ready -
695 for( ; num
> 0; num
--) {
696 struct sockaddr addr
;
697 socklen_t in_addrlen
= sizeof(addr
);
701 for(i
= 0; i
< num_sockets
; i
++) {
702 if(FD_ISSET(fd_listenset
[i
],&r_fds
)) {
704 /* Clear this so we don't look
706 FD_CLR(fd_listenset
[i
],&r_fds
);
711 smbd_set_server_fd(accept(s
,&addr
,&in_addrlen
));
713 if (smbd_server_fd() == -1 && errno
== EINTR
)
716 if (smbd_server_fd() == -1) {
717 DEBUG(2,("open_sockets_smbd: accept: %s\n",
722 /* Ensure child is set to blocking mode */
723 set_blocking(smbd_server_fd(),True
);
725 if (smbd_server_fd() != -1 && interactive
)
728 if (allowable_number_of_smbd_processes() &&
729 smbd_server_fd() != -1 &&
730 ((child
= sys_fork())==0)) {
731 char remaddr
[INET6_ADDRSTRLEN
];
735 /* Stop zombies, the parent explicitly handles
736 * them, counting worker smbds. */
739 /* close the listening socket(s) */
740 for(i
= 0; i
< num_sockets
; i
++)
741 close(fd_listenset
[i
]);
743 /* close our mDNS daemon handle */
744 dns_register_close(&dns_reg
);
746 /* close our standard file
748 close_low_fds(False
);
751 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
752 set_socket_options(smbd_server_fd(),
753 lp_socket_options());
755 /* this is needed so that we get decent entries
756 in smbstatus for port 445 connects */
757 set_remote_machine_name(get_peer_addr(smbd_server_fd(),
762 if (!reinit_after_fork(
763 smbd_messaging_context(),
764 smbd_event_context(),
766 DEBUG(0,("reinit_after_fork() failed\n"));
767 smb_panic("reinit_after_fork() failed");
772 /* The parent doesn't need this socket */
773 close(smbd_server_fd());
775 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
776 Clear the closed fd info out of server_fd --
777 and more importantly, out of client_fd in
778 util_sock.c, to avoid a possible
779 getpeername failure if we reopen the logs
780 and use %I in the filename.
783 smbd_set_server_fd(-1);
786 add_child_pid(child
);
789 /* Force parent to check log size after
790 * spawning child. Fix from
791 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
792 * parent smbd will log to logserver.smb. It
793 * writes only two messages for each child
794 * started/finished. But each child writes,
795 * say, 50 messages also in logserver.smb,
796 * begining with the debug_count of the
797 * parent, before the child opens its own log
798 * file logserver.client. In a worst case
799 * scenario the size of logserver.smb would be
800 * checked after about 50*50=2500 messages
803 force_check_log_size();
808 /* NOTREACHED return True; */
811 /****************************************************************************
813 **************************************************************************/
814 void reload_printers(void)
817 int n_services
= lp_numservices();
818 int pnum
= lp_servicenumber(PRINTERS_NAME
);
823 /* remove stale printers */
824 for (snum
= 0; snum
< n_services
; snum
++) {
825 /* avoid removing PRINTERS_NAME or non-autoloaded printers */
826 if (snum
== pnum
|| !(lp_snum_ok(snum
) && lp_print_ok(snum
) &&
827 lp_autoloaded(snum
)))
830 pname
= lp_printername(snum
);
831 if (!pcap_printername_ok(pname
)) {
832 DEBUG(3, ("removing stale printer %s\n", pname
));
834 if (is_printer_published(NULL
, snum
, NULL
))
835 nt_printer_publish(NULL
, snum
, SPOOL_DS_UNPUBLISH
);
836 del_a_printer(pname
);
837 lp_killservice(snum
);
844 /****************************************************************************
845 Reload the services file.
846 **************************************************************************/
848 bool reload_services(bool test
)
853 char *fname
= lp_configfile();
854 if (file_exist(fname
, NULL
) &&
855 !strcsequal(fname
, get_dyn_CONFIGFILE())) {
856 set_dyn_CONFIGFILE(fname
);
863 if (test
&& !lp_file_list_changed())
866 lp_killunused(conn_snum_used
);
868 ret
= lp_load(get_dyn_CONFIGFILE(), False
, False
, True
, True
);
872 /* perhaps the config filename is now set */
874 reload_services(True
);
880 if (smbd_server_fd() != -1) {
881 set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
882 set_socket_options(smbd_server_fd(), lp_socket_options());
885 mangle_reset_cache();
888 /* this forces service parameters to be flushed */
889 set_current_service(NULL
,0,True
);
894 /****************************************************************************
896 ****************************************************************************/
898 /* Reasons for shutting down a server process. */
899 enum server_exit_reason
{ SERVER_EXIT_NORMAL
, SERVER_EXIT_ABNORMAL
};
901 static void exit_server_common(enum server_exit_reason how
,
902 const char *const reason
) NORETURN_ATTRIBUTE
;
904 static void exit_server_common(enum server_exit_reason how
,
905 const char *const reason
)
907 static int firsttime
=1;
914 change_to_root_user();
916 if (negprot_global_auth_context
) {
917 (negprot_global_auth_context
->free
)(&negprot_global_auth_context
);
920 had_open_conn
= conn_close_all();
922 invalidate_all_vuids();
924 /* 3 second timeout. */
925 print_notify_send_messages(smbd_messaging_context(), 3);
927 /* delete our entry in the connections database. */
928 yield_connection(NULL
,"");
930 respond_to_all_remaining_local_messages();
933 if (dcelogin_atmost_once
) {
939 /* Destroy Samba DMAPI session only if we are master smbd process */
941 if (!dmapi_destroy_session()) {
942 DEBUG(0,("Unable to close Samba DMAPI session\n"));
950 if (how
!= SERVER_EXIT_NORMAL
) {
951 int oldlevel
= DEBUGLEVEL
;
956 DEBUG(0,("Abnormal server exit: %s\n",
957 reason
? reason
: "no explanation provided"));
962 DEBUGLEVEL
= oldlevel
;
966 DEBUG(3,("Server exit (%s)\n",
967 (reason
? reason
: "normal exit")));
970 /* if we had any open SMB connections when we exited then we
971 need to tell the parent smbd so that it can trigger a retry
972 of any locks we may have been holding or open files we were
981 void exit_server(const char *const explanation
)
983 exit_server_common(SERVER_EXIT_ABNORMAL
, explanation
);
986 void exit_server_cleanly(const char *const explanation
)
988 exit_server_common(SERVER_EXIT_NORMAL
, explanation
);
991 void exit_server_fault(void)
993 exit_server("critical server fault");
997 /****************************************************************************
998 received when we should release a specific IP
999 ****************************************************************************/
1000 static void release_ip(const char *ip
, void *priv
)
1002 char addr
[INET6_ADDRSTRLEN
];
1004 if (strcmp(client_socket_addr(get_client_fd(),addr
,sizeof(addr
)), ip
) == 0) {
1005 /* we can't afford to do a clean exit - that involves
1006 database writes, which would potentially mean we
1007 are still running after the failover has finished -
1008 we have to get rid of this process ID straight
1010 DEBUG(0,("Got release IP message for our IP %s - exiting immediately\n",
1012 /* note we must exit with non-zero status so the unclean handler gets
1013 called in the parent, so that the brl database is tickled */
1018 static void msg_release_ip(struct messaging_context
*msg_ctx
, void *private_data
,
1019 uint32_t msg_type
, struct server_id server_id
, DATA_BLOB
*data
)
1021 release_ip((char *)data
->data
, NULL
);
1024 /****************************************************************************
1025 Initialise connect, service and file structs.
1026 ****************************************************************************/
1028 static bool init_structs(void )
1031 * Set the machine NETBIOS name if not already
1032 * set from the config file.
1043 init_rpc_pipe_hnd();
1047 if (!secrets_init())
1054 * Send keepalive packets to our client
1056 static bool keepalive_fn(const struct timeval
*now
, void *private_data
)
1058 if (!send_keepalive(smbd_server_fd())) {
1059 DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
1066 * Do the recurring check if we're idle
1068 static bool deadtime_fn(const struct timeval
*now
, void *private_data
)
1070 if ((conn_num_open() == 0)
1071 || (conn_idle_all(now
->tv_sec
))) {
1072 DEBUG( 2, ( "Closing idle connection\n" ) );
1073 messaging_send(smbd_messaging_context(), procid_self(),
1074 MSG_SHUTDOWN
, &data_blob_null
);
1082 * Do the recurring log file and smb.conf reload checks.
1085 static bool housekeeping_fn(const struct timeval
*now
, void *private_data
)
1087 change_to_root_user();
1089 /* update printer queue caches if necessary */
1090 update_monitored_printq_cache();
1092 /* check if we need to reload services */
1093 check_reload(time(NULL
));
1095 /* Change machine password if neccessary. */
1096 attempt_machine_password_change();
1099 * Force a log file check.
1101 force_check_log_size();
1106 /****************************************************************************
1108 ****************************************************************************/
1110 /* Declare prototype for build_options() to avoid having to run it through
1111 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
1112 prototype generation system is too complicated. */
1114 extern void build_options(bool screen
);
1116 int main(int argc
,const char *argv
[])
1118 /* shall I run as a daemon */
1119 static bool is_daemon
= False
;
1120 static bool interactive
= False
;
1121 static bool Fork
= True
;
1122 static bool no_process_group
= False
;
1123 static bool log_stdout
= False
;
1124 static char *ports
= NULL
;
1125 static char *profile_level
= NULL
;
1128 bool print_build_options
= False
;
1133 OPT_NO_PROCESS_GROUP
,
1136 struct poptOption long_options
[] = {
1138 {"daemon", 'D', POPT_ARG_NONE
, NULL
, OPT_DAEMON
, "Become a daemon (default)" },
1139 {"interactive", 'i', POPT_ARG_NONE
, NULL
, OPT_INTERACTIVE
, "Run interactive (not a daemon)"},
1140 {"foreground", 'F', POPT_ARG_NONE
, NULL
, OPT_FORK
, "Run daemon in foreground (for daemontools, etc.)" },
1141 {"no-process-group", '\0', POPT_ARG_NONE
, NULL
, OPT_NO_PROCESS_GROUP
, "Don't create a new process group" },
1142 {"log-stdout", 'S', POPT_ARG_NONE
, NULL
, OPT_LOG_STDOUT
, "Log to stdout" },
1143 {"build-options", 'b', POPT_ARG_NONE
, NULL
, 'b', "Print build options" },
1144 {"port", 'p', POPT_ARG_STRING
, &ports
, 0, "Listen on the specified ports"},
1145 {"profiling-level", 'P', POPT_ARG_STRING
, &profile_level
, 0, "Set profiling level","PROFILE_LEVEL"},
1147 POPT_COMMON_DYNCONFIG
1150 TALLOC_CTX
*frame
= talloc_stackframe(); /* Setup tos. */
1154 #ifdef HAVE_SET_AUTH_PARAMETERS
1155 set_auth_parameters(argc
,argv
);
1158 pc
= poptGetContext("smbd", argc
, argv
, long_options
, 0);
1159 while((opt
= poptGetNextOpt(pc
)) != -1) {
1164 case OPT_INTERACTIVE
:
1170 case OPT_NO_PROCESS_GROUP
:
1171 no_process_group
= true;
1173 case OPT_LOG_STDOUT
:
1177 print_build_options
= True
;
1180 d_fprintf(stderr
, "\nInvalid option %s: %s\n\n",
1181 poptBadOption(pc
, 0), poptStrerror(opt
));
1182 poptPrintUsage(pc
, stderr
, 0);
1186 poptFreeContext(pc
);
1193 setup_logging(argv
[0],log_stdout
);
1195 if (print_build_options
) {
1196 build_options(True
); /* Display output to screen as well as debug */
1203 /* needed for SecureWare on SCO */
1209 set_remote_machine_name("smbd", False
);
1211 if (interactive
&& (DEBUGLEVEL
>= 9)) {
1212 talloc_enable_leak_report();
1215 if (log_stdout
&& Fork
) {
1216 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1220 /* we want to re-seed early to prevent time delays causing
1221 client problems at a later date. (tridge) */
1222 generate_random_buffer(NULL
, 0);
1224 /* make absolutely sure we run as root - to handle cases where people
1225 are crazy enough to have it setuid */
1227 gain_root_privilege();
1228 gain_root_group_privilege();
1230 fault_setup((void (*)(void *))exit_server_fault
);
1231 dump_core_setup("smbd");
1233 CatchSignal(SIGTERM
, SIGNAL_CAST sig_term
);
1234 CatchSignal(SIGHUP
,SIGNAL_CAST sig_hup
);
1236 /* we are never interested in SIGPIPE */
1237 BlockSignals(True
,SIGPIPE
);
1240 /* we are never interested in SIGFPE */
1241 BlockSignals(True
,SIGFPE
);
1244 #if defined(SIGUSR2)
1245 /* We are no longer interested in USR2 */
1246 BlockSignals(True
,SIGUSR2
);
1249 /* POSIX demands that signals are inherited. If the invoking process has
1250 * these signals masked, we will have problems, as we won't recieve them. */
1251 BlockSignals(False
, SIGHUP
);
1252 BlockSignals(False
, SIGUSR1
);
1253 BlockSignals(False
, SIGTERM
);
1255 /* we want total control over the permissions on created files,
1256 so set our umask to 0 */
1263 DEBUG(0,("smbd version %s started.\n", SAMBA_VERSION_STRING
));
1264 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE
));
1266 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1267 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1269 /* Output the build options to the debug log */
1270 build_options(False
);
1272 if (sizeof(uint16
) < 2 || sizeof(uint32
) < 4) {
1273 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1277 if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1278 DEBUG(0, ("error opening config file\n"));
1282 if (smbd_messaging_context() == NULL
)
1285 if (!reload_services(False
))
1291 if (!profile_setup(smbd_messaging_context(), False
)) {
1292 DEBUG(0,("ERROR: failed to setup profiling\n"));
1295 if (profile_level
!= NULL
) {
1296 int pl
= atoi(profile_level
);
1297 struct server_id src
;
1299 DEBUG(1, ("setting profiling level: %s\n",profile_level
));
1301 set_profile_level(pl
, src
);
1305 DEBUG(3,( "loaded services\n"));
1307 if (!is_daemon
&& !is_a_socket(0)) {
1309 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1312 * Setting is_daemon here prevents us from eventually calling
1313 * the open_sockets_inetd()
1319 if (is_daemon
&& !interactive
) {
1320 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1321 become_daemon(Fork
, no_process_group
);
1326 * If we're interactive we want to set our own process group for
1327 * signal management.
1329 if (interactive
&& !no_process_group
)
1330 setpgid( (pid_t
)0, (pid_t
)0);
1333 if (!directory_exist(lp_lockdir(), NULL
))
1334 mkdir(lp_lockdir(), 0755);
1337 pidfile_create("smbd");
1339 if (!reinit_after_fork(smbd_messaging_context(),
1340 smbd_event_context(), false)) {
1341 DEBUG(0,("reinit_after_fork() failed\n"));
1345 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1347 if (smbd_memcache() == NULL
) {
1351 memcache_set_global(smbd_memcache());
1353 /* Initialise the password backed before the global_sam_sid
1354 to ensure that we fetch from ldap before we make a domain sid up */
1356 if(!initialize_password_db(False
, smbd_event_context()))
1359 if (!secrets_init()) {
1360 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1364 if(!get_global_sam_sid()) {
1365 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1369 if (!session_init())
1372 if (!connections_init(True
))
1375 if (!locking_init())
1380 if (!W_ERROR_IS_OK(registry_init_full()))
1384 if (!init_svcctl_db())
1388 if (!print_backend_init(smbd_messaging_context()))
1391 if (!init_guest_info()) {
1392 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1396 /* only start the background queue daemon if we are
1397 running as a daemon -- bad things will happen if
1398 smbd is launched via inetd and we fork a copy of
1401 if (is_daemon
&& !interactive
1402 && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1403 start_background_queue();
1406 if (!open_sockets_smbd(is_daemon
, interactive
, ports
))
1410 * everything after this point is run after the fork()
1417 /* Possibly reload the services file. Only worth doing in
1418 * daemon mode. In inetd mode, we know we only just loaded this.
1421 reload_services(True
);
1424 if (!init_account_policy()) {
1425 DEBUG(0,("Could not open account policy tdb.\n"));
1429 if (*lp_rootdir()) {
1430 if (sys_chroot(lp_rootdir()) != 0) {
1431 DEBUG(0,("Failed to change root to %s\n", lp_rootdir()));
1434 if (chdir("/") == -1) {
1435 DEBUG(0,("Failed to chdir to / on chroot to %s\n", lp_rootdir()));
1438 DEBUG(0,("Changed root to %s\n", lp_rootdir()));
1442 if (!init_oplocks(smbd_messaging_context()))
1445 /* Setup aio signal handler. */
1446 initialize_async_io_handler();
1448 /* register our message handlers */
1449 messaging_register(smbd_messaging_context(), NULL
,
1450 MSG_SMB_FORCE_TDIS
, msg_force_tdis
);
1451 messaging_register(smbd_messaging_context(), NULL
,
1452 MSG_SMB_RELEASE_IP
, msg_release_ip
);
1453 messaging_register(smbd_messaging_context(), NULL
,
1454 MSG_SMB_CLOSE_FILE
, msg_close_file
);
1456 if ((lp_keepalive() != 0)
1457 && !(event_add_idle(smbd_event_context(), NULL
,
1458 timeval_set(lp_keepalive(), 0),
1459 "keepalive", keepalive_fn
,
1461 DEBUG(0, ("Could not add keepalive event\n"));
1465 if (!(event_add_idle(smbd_event_context(), NULL
,
1466 timeval_set(IDLE_CLOSED_TIMEOUT
, 0),
1467 "deadtime", deadtime_fn
, NULL
))) {
1468 DEBUG(0, ("Could not add deadtime event\n"));
1472 if (!(event_add_idle(smbd_event_context(), NULL
,
1473 timeval_set(SMBD_SELECT_TIMEOUT
, 0),
1474 "housekeeping", housekeeping_fn
, NULL
))) {
1475 DEBUG(0, ("Could not add housekeeping event\n"));
1479 #ifdef CLUSTER_SUPPORT
1481 if (lp_clustering()) {
1483 * We need to tell ctdb about our client's TCP
1484 * connection, so that for failover ctdbd can send
1485 * tickle acks, triggering a reconnection by the
1489 struct sockaddr_storage srv
, clnt
;
1491 if (client_get_tcp_info(&srv
, &clnt
) == 0) {
1495 status
= ctdbd_register_ips(
1496 messaging_ctdbd_connection(),
1497 &srv
, &clnt
, release_ip
, NULL
);
1499 if (!NT_STATUS_IS_OK(status
)) {
1500 DEBUG(0, ("ctdbd_register_ips failed: %s\n",
1501 nt_errstr(status
)));
1505 DEBUG(0,("Unable to get tcp info for "
1506 "CTDB_CONTROL_TCP_CLIENT: %s\n",
1517 namecache_shutdown();
1519 exit_server_cleanly(NULL
);