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/>.
25 #include "popt_common.h"
26 #include "smbd/globals.h"
27 #include "librpc/gen_ndr/messaging.h"
29 #include "libcli/auth/schannel.h"
32 #include "../librpc/gen_ndr/srv_dfs.h"
33 #include "../librpc/gen_ndr/srv_dssetup.h"
34 #include "../librpc/gen_ndr/srv_echo.h"
35 #include "../librpc/gen_ndr/srv_eventlog.h"
36 #include "../librpc/gen_ndr/srv_initshutdown.h"
37 #include "../librpc/gen_ndr/srv_lsa.h"
38 #include "../librpc/gen_ndr/srv_netlogon.h"
39 #include "../librpc/gen_ndr/srv_ntsvcs.h"
40 #include "../librpc/gen_ndr/srv_samr.h"
41 #include "../librpc/gen_ndr/srv_spoolss.h"
42 #include "../librpc/gen_ndr/srv_srvsvc.h"
43 #include "../librpc/gen_ndr/srv_svcctl.h"
44 #include "../librpc/gen_ndr/srv_winreg.h"
45 #include "../librpc/gen_ndr/srv_wkssvc.h"
47 #include "printing/nt_printing_migrate.h"
52 extern int dcelogin_atmost_once
;
55 int smbd_server_fd(void)
60 static void smbd_set_server_fd(int fd
)
65 int get_client_fd(void)
70 struct event_context
*smbd_event_context(void)
72 return server_event_context();
75 /*******************************************************************
76 What to do when smb.conf is updated.
77 ********************************************************************/
79 static void smb_conf_updated(struct messaging_context
*msg
,
82 struct server_id server_id
,
85 DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
86 "updated. Reloading.\n"));
87 change_to_root_user();
88 reload_services(msg
, False
);
92 /*******************************************************************
93 Delete a statcache entry.
94 ********************************************************************/
96 static void smb_stat_cache_delete(struct messaging_context
*msg
,
99 struct server_id server_id
,
102 const char *name
= (const char *)data
->data
;
103 DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name
));
104 stat_cache_delete(name
);
107 /****************************************************************************
108 Send a SIGTERM to our process group.
109 *****************************************************************************/
111 static void killkids(void)
113 if(am_parent
) kill(0,SIGTERM
);
116 /****************************************************************************
117 Process a sam sync message - not sure whether to do this here or
119 ****************************************************************************/
121 static void msg_sam_sync(struct messaging_context
*msg
,
124 struct server_id server_id
,
127 DEBUG(10, ("** sam sync message received, ignoring\n"));
130 static void msg_exit_server(struct messaging_context
*msg
,
133 struct server_id server_id
,
136 DEBUG(3, ("got a SHUTDOWN message\n"));
137 exit_server_cleanly(NULL
);
141 static void msg_inject_fault(struct messaging_context
*msg
,
144 struct server_id src
,
149 if (data
->length
!= sizeof(sig
)) {
150 DEBUG(0, ("Process %s sent bogus signal injection request\n",
151 procid_str_static(&src
)));
155 sig
= *(int *)data
->data
;
157 exit_server("internal error injected");
162 DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
163 procid_str_static(&src
), sig
, strsignal(sig
)));
165 DEBUG(0, ("Process %s requested injection of signal %d\n",
166 procid_str_static(&src
), sig
));
169 kill(sys_getpid(), sig
);
171 #endif /* DEVELOPER */
174 * Parent smbd process sets its own debug level first and then
175 * sends a message to all the smbd children to adjust their debug
176 * level to that of the parent.
179 static void smbd_msg_debug(struct messaging_context
*msg_ctx
,
182 struct server_id server_id
,
185 struct child_pid
*child
;
187 debug_message(msg_ctx
, private_data
, MSG_DEBUG
, server_id
, data
);
189 for (child
= children
; child
!= NULL
; child
= child
->next
) {
190 messaging_send_buf(msg_ctx
, pid_to_procid(child
->pid
),
193 strlen((char *) data
->data
) + 1);
197 static void add_child_pid(pid_t pid
)
199 struct child_pid
*child
;
201 child
= SMB_MALLOC_P(struct child_pid
);
203 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
207 DLIST_ADD(children
, child
);
212 at most every smbd:cleanuptime seconds (default 20), we scan the BRL
213 and locking database for entries to cleanup. As a side effect this
214 also cleans up dead entries in the connections database (due to the
215 traversal in message_send_all()
217 Using a timer for this prevents a flood of traversals when a large
218 number of clients disconnect at the same time (perhaps due to a
222 static void cleanup_timeout_fn(struct event_context
*event_ctx
,
223 struct timed_event
*te
,
227 struct timed_event
**cleanup_te
= (struct timed_event
**)private_data
;
229 DEBUG(1,("Cleaning up brl and lock database after unclean shutdown\n"));
230 message_send_all(smbd_messaging_context(), MSG_SMB_UNLOCK
, NULL
, 0, NULL
);
231 messaging_send_buf(smbd_messaging_context(), procid_self(),
232 MSG_SMB_BRL_VALIDATE
, NULL
, 0);
233 /* mark the cleanup as having been done */
234 (*cleanup_te
) = NULL
;
237 static void remove_child_pid(pid_t pid
, bool unclean_shutdown
)
239 struct child_pid
*child
;
240 static struct timed_event
*cleanup_te
;
241 struct server_id child_id
;
243 if (unclean_shutdown
) {
244 /* a child terminated uncleanly so tickle all
245 processes to see if they can grab any of the
248 DEBUG(3,(__location__
" Unclean shutdown of pid %u\n",
251 /* call the cleanup timer, but not too often */
252 int cleanup_time
= lp_parm_int(-1, "smbd", "cleanuptime", 20);
253 cleanup_te
= event_add_timed(smbd_event_context(), NULL
,
254 timeval_current_ofs(cleanup_time
, 0),
257 DEBUG(1,("Scheduled cleanup of brl and lock database after unclean shutdown\n"));
261 child_id
= procid_self(); /* Just initialize pid and potentially vnn */
264 if (!serverid_deregister(child_id
)) {
265 DEBUG(1, ("Could not remove pid %d from serverid.tdb\n",
269 for (child
= children
; child
!= NULL
; child
= child
->next
) {
270 if (child
->pid
== pid
) {
271 struct child_pid
*tmp
= child
;
272 DLIST_REMOVE(children
, child
);
279 DEBUG(0, ("Could not find child %d -- ignoring\n", (int)pid
));
282 /****************************************************************************
283 Have we reached the process limit ?
284 ****************************************************************************/
286 static bool allowable_number_of_smbd_processes(void)
288 int max_processes
= lp_max_smbd_processes();
293 return num_children
< max_processes
;
296 static void smbd_sig_chld_handler(struct tevent_context
*ev
,
297 struct tevent_signal
*se
,
306 while ((pid
= sys_waitpid(-1, &status
, WNOHANG
)) > 0) {
307 bool unclean_shutdown
= False
;
309 /* If the child terminated normally, assume
310 it was an unclean shutdown unless the
313 if (WIFEXITED(status
)) {
314 unclean_shutdown
= WEXITSTATUS(status
);
316 /* If the child terminated due to a signal
317 we always assume it was unclean.
319 if (WIFSIGNALED(status
)) {
320 unclean_shutdown
= True
;
322 remove_child_pid(pid
, unclean_shutdown
);
326 static void smbd_setup_sig_chld_handler(void)
328 struct tevent_signal
*se
;
330 se
= tevent_add_signal(smbd_event_context(),
331 smbd_event_context(),
333 smbd_sig_chld_handler
,
336 exit_server("failed to setup SIGCHLD handler");
340 struct smbd_open_socket
;
342 struct smbd_parent_context
{
345 /* the list of listening sockets */
346 struct smbd_open_socket
*sockets
;
349 struct smbd_open_socket
{
350 struct smbd_open_socket
*prev
, *next
;
351 struct smbd_parent_context
*parent
;
353 struct tevent_fd
*fde
;
356 static void smbd_open_socket_close_fn(struct tevent_context
*ev
,
357 struct tevent_fd
*fde
,
361 /* this might be the socket_wrapper swrap_close() */
365 static void smbd_accept_connection(struct tevent_context
*ev
,
366 struct tevent_fd
*fde
,
370 struct smbd_open_socket
*s
= talloc_get_type_abort(private_data
,
371 struct smbd_open_socket
);
372 struct sockaddr_storage addr
;
373 socklen_t in_addrlen
= sizeof(addr
);
377 smbd_set_server_fd(accept(s
->fd
, (struct sockaddr
*)(void *)&addr
,&in_addrlen
));
379 if (smbd_server_fd() == -1 && errno
== EINTR
)
382 if (smbd_server_fd() == -1) {
383 DEBUG(0,("open_sockets_smbd: accept: %s\n",
388 if (s
->parent
->interactive
) {
389 smbd_process(smbd_server_conn
);
390 exit_server_cleanly("end of interactive mode");
394 if (!allowable_number_of_smbd_processes()) {
395 close(smbd_server_fd());
396 smbd_set_server_fd(-1);
401 * Generate a unique id in the parent process so that we use
402 * the global random state in the parent.
404 generate_random_buffer((uint8_t *)&unique_id
, sizeof(unique_id
));
408 NTSTATUS status
= NT_STATUS_OK
;
413 set_my_unique_id(unique_id
);
415 /* Stop zombies, the parent explicitly handles
416 * them, counting worker smbds. */
419 /* close our standard file
421 close_low_fds(False
);
424 * Can't use TALLOC_FREE here. Nulling out the argument to it
425 * would overwrite memory we've just freed.
427 talloc_free(s
->parent
);
430 status
= reinit_after_fork(smbd_messaging_context(),
431 smbd_event_context(), procid_self(),
433 if (!NT_STATUS_IS_OK(status
)) {
434 if (NT_STATUS_EQUAL(status
,
435 NT_STATUS_TOO_MANY_OPENED_FILES
)) {
436 DEBUG(0,("child process cannot initialize "
437 "because too many files are open\n"));
440 DEBUG(0,("reinit_after_fork() failed\n"));
441 smb_panic("reinit_after_fork() failed");
444 smbd_setup_sig_term_handler();
445 smbd_setup_sig_hup_handler(server_event_context(),
446 server_messaging_context());
448 if (!serverid_register(procid_self(),
449 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
451 |FLAG_MSG_PRINT_GENERAL
)) {
452 exit_server_cleanly("Could not register myself in "
456 smbd_process(smbd_server_conn
);
458 exit_server_cleanly("end of child");
463 DEBUG(0,("smbd_accept_connection: sys_fork() failed: %s\n",
467 /* The parent doesn't need this socket */
468 close(smbd_server_fd());
470 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
471 Clear the closed fd info out of server_fd --
472 and more importantly, out of client_fd in
473 util_sock.c, to avoid a possible
474 getpeername failure if we reopen the logs
475 and use %I in the filename.
478 smbd_set_server_fd(-1);
484 /* Force parent to check log size after
485 * spawning child. Fix from
486 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
487 * parent smbd will log to logserver.smb. It
488 * writes only two messages for each child
489 * started/finished. But each child writes,
490 * say, 50 messages also in logserver.smb,
491 * begining with the debug_count of the
492 * parent, before the child opens its own log
493 * file logserver.client. In a worst case
494 * scenario the size of logserver.smb would be
495 * checked after about 50*50=2500 messages
498 force_check_log_size();
501 static bool smbd_open_one_socket(struct smbd_parent_context
*parent
,
502 const struct sockaddr_storage
*ifss
,
505 struct smbd_open_socket
*s
;
507 s
= talloc(parent
, struct smbd_open_socket
);
513 s
->fd
= open_socket_in(SOCK_STREAM
,
515 parent
->sockets
== NULL
? 0 : 2,
519 DEBUG(0,("smbd_open_once_socket: open_socket_in: "
520 "%s\n", strerror(errno
)));
523 * We ignore an error here, as we've done before
528 /* ready to listen */
529 set_socket_options(s
->fd
, "SO_KEEPALIVE");
530 set_socket_options(s
->fd
, lp_socket_options());
532 /* Set server socket to
533 * non-blocking for the accept. */
534 set_blocking(s
->fd
, False
);
536 if (listen(s
->fd
, SMBD_LISTEN_BACKLOG
) == -1) {
537 DEBUG(0,("open_sockets_smbd: listen: "
538 "%s\n", strerror(errno
)));
544 s
->fde
= tevent_add_fd(smbd_event_context(),
546 s
->fd
, TEVENT_FD_READ
,
547 smbd_accept_connection
,
550 DEBUG(0,("open_sockets_smbd: "
551 "tevent_add_fd: %s\n",
557 tevent_fd_set_close_fn(s
->fde
, smbd_open_socket_close_fn
);
559 DLIST_ADD_END(parent
->sockets
, s
, struct smbd_open_socket
*);
564 /****************************************************************************
565 Open the socket communication.
566 ****************************************************************************/
568 static bool open_sockets_smbd(struct smbd_parent_context
*parent
,
569 const char *smb_ports
)
571 int num_interfaces
= iface_count();
574 unsigned dns_port
= 0;
581 smbd_setup_sig_chld_handler();
583 /* use a reasonable default set of ports - listing on 445 and 139 */
585 ports
= lp_smb_ports();
586 if (!ports
|| !*ports
) {
587 ports
= talloc_strdup(talloc_tos(), SMB_PORTS
);
589 ports
= talloc_strdup(talloc_tos(), ports
);
592 ports
= talloc_strdup(talloc_tos(), smb_ports
);
595 if (lp_interfaces() && lp_bind_interfaces_only()) {
596 /* We have been given an interfaces line, and been
597 told to only bind to those interfaces. Create a
598 socket per interface and bind to only these.
601 /* Now open a listen socket for each of the
603 for(i
= 0; i
< num_interfaces
; i
++) {
604 const struct sockaddr_storage
*ifss
=
605 iface_n_sockaddr_storage(i
);
610 DEBUG(0,("open_sockets_smbd: "
611 "interface %d has NULL IP address !\n",
617 next_token_talloc(talloc_tos(),&ptr
, &tok
, " \t,");) {
618 unsigned port
= atoi(tok
);
619 if (port
== 0 || port
> 0xffff) {
623 if (!smbd_open_one_socket(parent
, ifss
, port
)) {
629 /* Just bind to 0.0.0.0 - accept connections
634 const char *sock_addr
= lp_socket_address();
636 const char *sock_ptr
;
638 if (strequal(sock_addr
, "0.0.0.0") ||
639 strequal(sock_addr
, "::")) {
641 sock_addr
= "::,0.0.0.0";
643 sock_addr
= "0.0.0.0";
647 for (sock_ptr
=sock_addr
;
648 next_token_talloc(talloc_tos(), &sock_ptr
, &sock_tok
, " \t,"); ) {
649 for (ptr
=ports
; next_token_talloc(talloc_tos(), &ptr
, &tok
, " \t,"); ) {
650 struct sockaddr_storage ss
;
652 unsigned port
= atoi(tok
);
653 if (port
== 0 || port
> 0xffff) {
657 /* Keep the first port for mDNS service
664 /* open an incoming socket */
665 if (!interpret_string_addr(&ss
, sock_tok
,
666 AI_NUMERICHOST
|AI_PASSIVE
)) {
670 if (!smbd_open_one_socket(parent
, &ss
, port
)) {
677 if (parent
->sockets
== NULL
) {
678 DEBUG(0,("open_sockets_smbd: No "
679 "sockets available to bind to.\n"));
683 /* Setup the main smbd so that we can get messages. Note that
684 do this after starting listening. This is needed as when in
685 clustered mode, ctdb won't allow us to start doing database
686 operations until it has gone thru a full startup, which
687 includes checking to see that smbd is listening. */
689 if (!serverid_register(procid_self(),
690 FLAG_MSG_GENERAL
|FLAG_MSG_SMBD
692 DEBUG(0, ("open_sockets_smbd: Failed to register "
693 "myself in serverid.tdb\n"));
697 /* Listen to messages */
699 messaging_register(smbd_messaging_context(), NULL
,
700 MSG_SMB_SAM_SYNC
, msg_sam_sync
);
701 messaging_register(smbd_messaging_context(), NULL
,
702 MSG_SHUTDOWN
, msg_exit_server
);
703 messaging_register(smbd_messaging_context(), NULL
,
704 MSG_SMB_FILE_RENAME
, msg_file_was_renamed
);
705 messaging_register(smbd_messaging_context(), NULL
,
706 MSG_SMB_CONF_UPDATED
, smb_conf_updated
);
707 messaging_register(smbd_messaging_context(), NULL
,
708 MSG_SMB_STAT_CACHE_DELETE
, smb_stat_cache_delete
);
709 messaging_register(smbd_messaging_context(), NULL
,
710 MSG_DEBUG
, smbd_msg_debug
);
711 brl_register_msgs(smbd_messaging_context());
713 #ifdef CLUSTER_SUPPORT
714 if (lp_clustering()) {
715 ctdbd_register_reconfigure(
716 messaging_ctdbd_connection(procid_self()));
721 messaging_register(smbd_messaging_context(), NULL
,
722 MSG_SMB_INJECT_FAULT
, msg_inject_fault
);
726 #ifdef WITH_DNSSD_SUPPORT
727 smbd_setup_mdns_registration(smbd_event_context(),
730 #ifdef WITH_AVAHI_SUPPORT
733 avahi_conn
= avahi_start_register(
734 smbd_event_context(), smbd_event_context(), dns_port
);
735 if (avahi_conn
== NULL
) {
736 DEBUG(10, ("avahi_start_register failed\n"));
744 static void smbd_parent_loop(struct smbd_parent_context
*parent
)
746 /* now accept incoming connections - forking a new process
747 for each incoming connection */
748 DEBUG(2,("waiting for connections\n"));
751 TALLOC_CTX
*frame
= talloc_stackframe();
753 ret
= tevent_loop_once(smbd_event_context());
755 exit_server_cleanly("tevent_loop_once() error");
761 /* NOTREACHED return True; */
765 /****************************************************************************
766 Initialise connect, service and file structs.
767 ****************************************************************************/
769 static bool init_structs(void )
772 * Set the machine NETBIOS name if not already
773 * set from the config file.
787 static bool spoolss_init_cb(void *ptr
)
789 struct messaging_context
*msg_ctx
= talloc_get_type_abort(
790 ptr
, struct messaging_context
);
791 return nt_printing_tdb_migrate(msg_ctx
);
794 /****************************************************************************
796 ****************************************************************************/
798 /* Declare prototype for build_options() to avoid having to run it through
799 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
800 prototype generation system is too complicated. */
802 extern void build_options(bool screen
);
804 int main(int argc
,const char *argv
[])
806 /* shall I run as a daemon */
807 bool is_daemon
= false;
808 bool interactive
= false;
810 bool no_process_group
= false;
811 bool log_stdout
= false;
813 char *profile_level
= NULL
;
816 bool print_build_options
= False
;
821 OPT_NO_PROCESS_GROUP
,
824 struct poptOption long_options
[] = {
826 {"daemon", 'D', POPT_ARG_NONE
, NULL
, OPT_DAEMON
, "Become a daemon (default)" },
827 {"interactive", 'i', POPT_ARG_NONE
, NULL
, OPT_INTERACTIVE
, "Run interactive (not a daemon)"},
828 {"foreground", 'F', POPT_ARG_NONE
, NULL
, OPT_FORK
, "Run daemon in foreground (for daemontools, etc.)" },
829 {"no-process-group", '\0', POPT_ARG_NONE
, NULL
, OPT_NO_PROCESS_GROUP
, "Don't create a new process group" },
830 {"log-stdout", 'S', POPT_ARG_NONE
, NULL
, OPT_LOG_STDOUT
, "Log to stdout" },
831 {"build-options", 'b', POPT_ARG_NONE
, NULL
, 'b', "Print build options" },
832 {"port", 'p', POPT_ARG_STRING
, &ports
, 0, "Listen on the specified ports"},
833 {"profiling-level", 'P', POPT_ARG_STRING
, &profile_level
, 0, "Set profiling level","PROFILE_LEVEL"},
835 POPT_COMMON_DYNCONFIG
838 struct smbd_parent_context
*parent
= NULL
;
839 TALLOC_CTX
*frame
= talloc_stackframe(); /* Setup tos. */
842 struct rpc_srv_callbacks spoolss_cb
;
844 /* Initialize the event context, it will panic on error */
845 smbd_event_context();
851 #ifdef HAVE_SET_AUTH_PARAMETERS
852 set_auth_parameters(argc
,argv
);
855 pc
= poptGetContext("smbd", argc
, argv
, long_options
, 0);
856 while((opt
= poptGetNextOpt(pc
)) != -1) {
861 case OPT_INTERACTIVE
:
867 case OPT_NO_PROCESS_GROUP
:
868 no_process_group
= true;
874 print_build_options
= True
;
877 d_fprintf(stderr
, "\nInvalid option %s: %s\n\n",
878 poptBadOption(pc
, 0), poptStrerror(opt
));
879 poptPrintUsage(pc
, stderr
, 0);
890 setup_logging(argv
[0],log_stdout
);
892 if (print_build_options
) {
893 build_options(True
); /* Display output to screen as well as debug */
900 /* needed for SecureWare on SCO */
904 set_remote_machine_name("smbd", False
);
906 if (interactive
&& (DEBUGLEVEL
>= 9)) {
907 talloc_enable_leak_report();
910 if (log_stdout
&& Fork
) {
911 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
915 /* we want to re-seed early to prevent time delays causing
916 client problems at a later date. (tridge) */
917 generate_random_buffer(NULL
, 0);
919 /* get initial effective uid and gid */
922 /* make absolutely sure we run as root - to handle cases where people
923 are crazy enough to have it setuid */
924 gain_root_privilege();
925 gain_root_group_privilege();
927 fault_setup((void (*)(void *))exit_server_fault
);
928 dump_core_setup("smbd");
930 /* we are never interested in SIGPIPE */
931 BlockSignals(True
,SIGPIPE
);
934 /* we are never interested in SIGFPE */
935 BlockSignals(True
,SIGFPE
);
939 /* We are no longer interested in USR2 */
940 BlockSignals(True
,SIGUSR2
);
943 /* POSIX demands that signals are inherited. If the invoking process has
944 * these signals masked, we will have problems, as we won't recieve them. */
945 BlockSignals(False
, SIGHUP
);
946 BlockSignals(False
, SIGUSR1
);
947 BlockSignals(False
, SIGTERM
);
949 /* Ensure we leave no zombies until we
950 * correctly set up child handling below. */
954 /* we want total control over the permissions on created files,
955 so set our umask to 0 */
960 DEBUG(0,("smbd version %s started.\n", samba_version_string()));
961 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE
));
963 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
964 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
966 /* Output the build options to the debug log */
967 build_options(False
);
969 if (sizeof(uint16
) < 2 || sizeof(uint32
) < 4) {
970 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
974 if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
975 DEBUG(0, ("error opening config file\n"));
979 /* Init the security context and global current_user */
982 if (smbd_messaging_context() == NULL
)
986 * Reloading of the printers will not work here as we don't have a
987 * server info and rpc services set up. It will be called later.
989 if (!reload_services(smbd_messaging_context(), False
)) {
993 /* ...NOTE... Log files are working from this point! */
995 DEBUG(3,("loaded services\n"));
1000 if (!profile_setup(smbd_messaging_context(), False
)) {
1001 DEBUG(0,("ERROR: failed to setup profiling\n"));
1004 if (profile_level
!= NULL
) {
1005 int pl
= atoi(profile_level
);
1006 struct server_id src
;
1008 DEBUG(1, ("setting profiling level: %s\n",profile_level
));
1010 set_profile_level(pl
, src
);
1014 if (!is_daemon
&& !is_a_socket(0)) {
1016 DEBUG(0,("standard input is not a socket, assuming -D option\n"));
1019 * Setting is_daemon here prevents us from eventually calling
1020 * the open_sockets_inetd()
1026 if (is_daemon
&& !interactive
) {
1027 DEBUG( 3, ( "Becoming a daemon.\n" ) );
1028 become_daemon(Fork
, no_process_group
, log_stdout
);
1031 generate_random_buffer((uint8_t *)&unique_id
, sizeof(unique_id
));
1032 set_my_unique_id(unique_id
);
1036 * If we're interactive we want to set our own process group for
1037 * signal management.
1039 if (interactive
&& !no_process_group
)
1040 setpgid( (pid_t
)0, (pid_t
)0);
1043 if (!directory_exist(lp_lockdir()))
1044 mkdir(lp_lockdir(), 0755);
1047 pidfile_create("smbd");
1049 status
= reinit_after_fork(smbd_messaging_context(),
1050 smbd_event_context(),
1051 procid_self(), false);
1052 if (!NT_STATUS_IS_OK(status
)) {
1053 DEBUG(0,("reinit_after_fork() failed\n"));
1057 smbd_server_conn
->msg_ctx
= smbd_messaging_context();
1059 smbd_setup_sig_term_handler();
1060 smbd_setup_sig_hup_handler(smbd_event_context(),
1061 smbd_server_conn
->msg_ctx
);
1063 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1065 if (smbd_memcache() == NULL
) {
1069 memcache_set_global(smbd_memcache());
1071 /* Initialise the password backed before the global_sam_sid
1072 to ensure that we fetch from ldap before we make a domain sid up */
1074 if(!initialize_password_db(False
, smbd_event_context()))
1077 if (!secrets_init()) {
1078 DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
1082 if (lp_server_role() == ROLE_DOMAIN_BDC
|| lp_server_role() == ROLE_DOMAIN_PDC
) {
1083 if (!open_schannel_session_store(NULL
, lp_private_dir())) {
1084 DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
1089 if(!get_global_sam_sid()) {
1090 DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
1094 if (!sessionid_init()) {
1098 if (!connections_init(True
))
1101 if (!locking_init())
1104 if (!messaging_tdb_parent_init()) {
1108 if (!notify_internal_parent_init()) {
1112 if (!serverid_parent_init()) {
1116 if (!W_ERROR_IS_OK(registry_init_full()))
1119 if (!print_backend_init(smbd_messaging_context()))
1123 if (!init_svcctl_db())
1127 /* Open the share_info.tdb here, so we don't have to open
1128 after the fork on every single connection. This is a small
1129 performance improvment and reduces the total number of system
1131 if (!share_info_db_init()) {
1132 DEBUG(0,("ERROR: failed to load share info db.\n"));
1136 if (!init_system_info()) {
1137 DEBUG(0,("ERROR: failed to setup system user info.\n"));
1141 if (!init_guest_info()) {
1142 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1147 * Initialize spoolss with an init function to convert printers first.
1148 * static_init_rpc will try to initialize the spoolss server too but you
1149 * can't register it twice.
1151 spoolss_cb
.init
= spoolss_init_cb
;
1152 spoolss_cb
.shutdown
= NULL
;
1153 spoolss_cb
.private_data
= smbd_server_conn
->msg_ctx
;
1155 /* Spoolss depends on a winreg pipe, so start it first. */
1156 if (!NT_STATUS_IS_OK(rpc_winreg_init(NULL
))) {
1160 if (!NT_STATUS_IS_OK(rpc_spoolss_init(&spoolss_cb
))) {
1166 /* Publish nt printers, this requires a working winreg pipe */
1167 reload_printers(smbd_messaging_context());
1169 /* only start the background queue daemon if we are
1170 running as a daemon -- bad things will happen if
1171 smbd is launched via inetd and we fork a copy of
1174 if (is_daemon
&& !interactive
1175 && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
1176 start_background_queue(smbd_event_context(),
1177 smbd_messaging_context());
1184 /* Started from inetd. fd 0 is the socket. */
1185 /* We will abort gracefully when the client or remote system
1187 smbd_set_server_fd(dup(0));
1189 /* close our standard file descriptors */
1190 close_low_fds(False
); /* Don't close stderr */
1197 smbd_setup_sig_chld_handler();
1199 smbd_process(smbd_server_conn
);
1201 exit_server_cleanly(NULL
);
1205 parent
= talloc_zero(smbd_event_context(), struct smbd_parent_context
);
1207 exit_server("talloc(struct smbd_parent_context) failed");
1209 parent
->interactive
= interactive
;
1211 if (!open_sockets_smbd(parent
, ports
))
1212 exit_server("open_sockets_smbd() failed");
1215 /* make sure we always have a valid stackframe */
1216 frame
= talloc_stackframe();
1218 smbd_parent_loop(parent
);
1220 exit_server_cleanly(NULL
);