dsdb-tests: Add new test samba4.user_account_control.python
[Samba.git] / source3 / smbd / server.c
blob8207bf1676f822c8649f5882351c81e7c860be45
1 /*
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/>.
24 #include "includes.h"
25 #include "system/filesys.h"
26 #include "popt_common.h"
27 #include "smbd/smbd.h"
28 #include "smbd/globals.h"
29 #include "registry/reg_init_full.h"
30 #include "libcli/auth/schannel.h"
31 #include "secrets.h"
32 #include "../lib/util/memcache.h"
33 #include "ctdbd_conn.h"
34 #include "util_cluster.h"
35 #include "printing/queue_process.h"
36 #include "rpc_server/rpc_service_setup.h"
37 #include "rpc_server/rpc_config.h"
38 #include "serverid.h"
39 #include "passdb.h"
40 #include "auth.h"
41 #include "messages.h"
42 #include "smbprofile.h"
43 #include "lib/id_cache.h"
44 #include "lib/param/param.h"
45 #include "lib/background.h"
46 #include "lib/conn_tdb.h"
47 #include "../lib/util/pidfile.h"
48 #include "lib/smbd_shim.h"
49 #include "scavenger.h"
50 #include "locking/leases_db.h"
52 struct smbd_open_socket;
53 struct smbd_child_pid;
55 struct smbd_parent_context {
56 bool interactive;
58 struct tevent_context *ev_ctx;
59 struct messaging_context *msg_ctx;
61 /* the list of listening sockets */
62 struct smbd_open_socket *sockets;
64 /* the list of current child processes */
65 struct smbd_child_pid *children;
66 size_t num_children;
68 struct tevent_timer *cleanup_te;
71 struct smbd_open_socket {
72 struct smbd_open_socket *prev, *next;
73 struct smbd_parent_context *parent;
74 int fd;
75 struct tevent_fd *fde;
78 struct smbd_child_pid {
79 struct smbd_child_pid *prev, *next;
80 pid_t pid;
83 extern void start_epmd(struct tevent_context *ev_ctx,
84 struct messaging_context *msg_ctx);
86 extern void start_lsasd(struct tevent_context *ev_ctx,
87 struct messaging_context *msg_ctx);
89 #ifdef WITH_DFS
90 extern int dcelogin_atmost_once;
91 #endif /* WITH_DFS */
93 /*******************************************************************
94 What to do when smb.conf is updated.
95 ********************************************************************/
97 static void smbd_parent_conf_updated(struct messaging_context *msg,
98 void *private_data,
99 uint32_t msg_type,
100 struct server_id server_id,
101 DATA_BLOB *data)
103 struct tevent_context *ev_ctx =
104 talloc_get_type_abort(private_data, struct tevent_context);
106 DEBUG(10,("smbd_parent_conf_updated: Got message saying smb.conf was "
107 "updated. Reloading.\n"));
108 change_to_root_user();
109 reload_services(NULL, NULL, false);
110 printing_subsystem_update(ev_ctx, msg, false);
113 /*******************************************************************
114 Delete a statcache entry.
115 ********************************************************************/
117 static void smb_stat_cache_delete(struct messaging_context *msg,
118 void *private_data,
119 uint32_t msg_tnype,
120 struct server_id server_id,
121 DATA_BLOB *data)
123 const char *name = (const char *)data->data;
124 DEBUG(10,("smb_stat_cache_delete: delete name %s\n", name));
125 stat_cache_delete(name);
128 /****************************************************************************
129 Send a SIGTERM to our process group.
130 *****************************************************************************/
132 static void killkids(void)
134 if(am_parent) kill(0,SIGTERM);
137 static void msg_exit_server(struct messaging_context *msg,
138 void *private_data,
139 uint32_t msg_type,
140 struct server_id server_id,
141 DATA_BLOB *data)
143 DEBUG(3, ("got a SHUTDOWN message\n"));
144 exit_server_cleanly(NULL);
147 #ifdef DEVELOPER
148 static void msg_inject_fault(struct messaging_context *msg,
149 void *private_data,
150 uint32_t msg_type,
151 struct server_id src,
152 DATA_BLOB *data)
154 int sig;
156 if (data->length != sizeof(sig)) {
157 DEBUG(0, ("Process %s sent bogus signal injection request\n",
158 procid_str_static(&src)));
159 return;
162 sig = *(int *)data->data;
163 if (sig == -1) {
164 exit_server("internal error injected");
165 return;
168 #if HAVE_STRSIGNAL
169 DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
170 procid_str_static(&src), sig, strsignal(sig)));
171 #else
172 DEBUG(0, ("Process %s requested injection of signal %d\n",
173 procid_str_static(&src), sig));
174 #endif
176 kill(getpid(), sig);
178 #endif /* DEVELOPER */
180 static NTSTATUS messaging_send_to_children(struct messaging_context *msg_ctx,
181 uint32_t msg_type, DATA_BLOB* data)
183 NTSTATUS status;
184 struct smbd_parent_context *parent = am_parent;
185 struct smbd_child_pid *child;
187 if (parent == NULL) {
188 return NT_STATUS_INTERNAL_ERROR;
191 for (child = parent->children; child != NULL; child = child->next) {
192 status = messaging_send(parent->msg_ctx,
193 pid_to_procid(child->pid),
194 msg_type, data);
195 if (!NT_STATUS_IS_OK(status)) {
196 return status;
199 return NT_STATUS_OK;
202 static void smb_parent_send_to_children(struct messaging_context *ctx,
203 void* data,
204 uint32_t msg_type,
205 struct server_id srv_id,
206 DATA_BLOB* msg_data)
208 messaging_send_to_children(ctx, msg_type, msg_data);
212 * Parent smbd process sets its own debug level first and then
213 * sends a message to all the smbd children to adjust their debug
214 * level to that of the parent.
217 static void smbd_msg_debug(struct messaging_context *msg_ctx,
218 void *private_data,
219 uint32_t msg_type,
220 struct server_id server_id,
221 DATA_BLOB *data)
223 debug_message(msg_ctx, private_data, MSG_DEBUG, server_id, data);
225 messaging_send_to_children(msg_ctx, MSG_DEBUG, data);
228 static void smbd_parent_id_cache_kill(struct messaging_context *msg_ctx,
229 void *private_data,
230 uint32_t msg_type,
231 struct server_id server_id,
232 DATA_BLOB* data)
234 const char *msg = (data && data->data)
235 ? (const char *)data->data : "<NULL>";
236 struct id_cache_ref id;
238 if (!id_cache_ref_parse(msg, &id)) {
239 DEBUG(0, ("Invalid ?ID: %s\n", msg));
240 return;
243 id_cache_delete_from_cache(&id);
245 messaging_send_to_children(msg_ctx, msg_type, data);
248 static void smbd_parent_id_cache_delete(struct messaging_context *ctx,
249 void* data,
250 uint32_t msg_type,
251 struct server_id srv_id,
252 DATA_BLOB* msg_data)
254 id_cache_delete_message(ctx, data, msg_type, srv_id, msg_data);
256 messaging_send_to_children(ctx, msg_type, msg_data);
259 struct smbd_parent_notify_state {
260 struct tevent_context *ev;
261 struct messaging_context *msg;
262 uint32_t msgtype;
263 struct notify_context *notify;
266 static int smbd_parent_notify_cleanup(void *private_data);
267 static void smbd_parent_notify_cleanup_done(struct tevent_req *req);
268 static void smbd_parent_notify_proxy_done(struct tevent_req *req);
270 static bool smbd_parent_notify_init(TALLOC_CTX *mem_ctx,
271 struct messaging_context *msg,
272 struct tevent_context *ev)
274 struct smbd_parent_notify_state *state;
275 struct tevent_req *req;
277 state = talloc(mem_ctx, struct smbd_parent_notify_state);
278 if (state == NULL) {
279 return false;
281 state->msg = msg;
282 state->ev = ev;
283 state->msgtype = MSG_SMB_NOTIFY_CLEANUP;
285 state->notify = notify_init(state, msg, ev);
286 if (state->notify == NULL) {
287 goto fail;
289 req = background_job_send(
290 state, state->ev, state->msg, &state->msgtype, 1,
291 lp_parm_int(-1, "smbd", "notify cleanup interval", 60),
292 smbd_parent_notify_cleanup, state->notify);
293 if (req == NULL) {
294 goto fail;
296 tevent_req_set_callback(req, smbd_parent_notify_cleanup_done, state);
298 if (!lp_clustering()) {
299 return true;
302 req = notify_cluster_proxy_send(state, ev, state->notify);
303 if (req == NULL) {
304 goto fail;
306 tevent_req_set_callback(req, smbd_parent_notify_proxy_done, state);
308 return true;
309 fail:
310 TALLOC_FREE(state);
311 return false;
314 static int smbd_parent_notify_cleanup(void *private_data)
316 struct notify_context *notify = talloc_get_type_abort(
317 private_data, struct notify_context);
318 notify_cleanup(notify);
319 return lp_parm_int(-1, "smbd", "notify cleanup interval", 60);
322 static void smbd_parent_notify_cleanup_done(struct tevent_req *req)
324 struct smbd_parent_notify_state *state = tevent_req_callback_data(
325 req, struct smbd_parent_notify_state);
326 NTSTATUS status;
328 status = background_job_recv(req);
329 TALLOC_FREE(req);
330 DEBUG(1, ("notify cleanup job ended with %s\n", nt_errstr(status)));
333 * Provide self-healing: Whatever the error condition was, it
334 * will have printed it into log.smbd. Just retrying and
335 * spamming log.smbd once a minute should be fine.
337 req = background_job_send(
338 state, state->ev, state->msg, &state->msgtype, 1, 60,
339 smbd_parent_notify_cleanup, state->notify);
340 if (req == NULL) {
341 DEBUG(1, ("background_job_send failed\n"));
342 return;
344 tevent_req_set_callback(req, smbd_parent_notify_cleanup_done, state);
347 static void smbd_parent_notify_proxy_done(struct tevent_req *req)
349 int ret;
351 ret = notify_cluster_proxy_recv(req);
352 TALLOC_FREE(req);
353 DEBUG(1, ("notify proxy job ended with %s\n", strerror(ret)));
356 static void add_child_pid(struct smbd_parent_context *parent,
357 pid_t pid)
359 struct smbd_child_pid *child;
361 child = talloc_zero(parent, struct smbd_child_pid);
362 if (child == NULL) {
363 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
364 return;
366 child->pid = pid;
367 DLIST_ADD(parent->children, child);
368 parent->num_children += 1;
371 static void smb_tell_num_children(struct messaging_context *ctx, void *data,
372 uint32_t msg_type, struct server_id srv_id,
373 DATA_BLOB *msg_data)
375 uint8_t buf[sizeof(uint32_t)];
377 if (am_parent) {
378 SIVAL(buf, 0, am_parent->num_children);
379 messaging_send_buf(ctx, srv_id, MSG_SMB_NUM_CHILDREN,
380 buf, sizeof(buf));
386 at most every smbd:cleanuptime seconds (default 20), we scan the BRL
387 and locking database for entries to cleanup. As a side effect this
388 also cleans up dead entries in the connections database (due to the
389 traversal in message_send_all()
391 Using a timer for this prevents a flood of traversals when a large
392 number of clients disconnect at the same time (perhaps due to a
393 network outage).
396 static void cleanup_timeout_fn(struct tevent_context *event_ctx,
397 struct tevent_timer *te,
398 struct timeval now,
399 void *private_data)
401 struct smbd_parent_context *parent =
402 talloc_get_type_abort(private_data,
403 struct smbd_parent_context);
405 parent->cleanup_te = NULL;
407 DEBUG(1,("Cleaning up brl and lock database after unclean shutdown\n"));
408 message_send_all(parent->msg_ctx, MSG_SMB_UNLOCK, NULL, 0, NULL);
409 messaging_send_buf(parent->msg_ctx,
410 messaging_server_id(parent->msg_ctx),
411 MSG_SMB_BRL_VALIDATE, NULL, 0);
414 static void remove_child_pid(struct smbd_parent_context *parent,
415 pid_t pid,
416 bool unclean_shutdown)
418 struct smbd_child_pid *child;
419 struct server_id child_id;
420 int ret;
422 child_id = pid_to_procid(pid);
424 ret = messaging_cleanup(parent->msg_ctx, pid);
426 if ((ret != 0) && (ret != ENOENT)) {
427 DEBUG(10, ("%s: messaging_cleanup returned %s\n",
428 __func__, strerror(ret)));
431 for (child = parent->children; child != NULL; child = child->next) {
432 if (child->pid == pid) {
433 struct smbd_child_pid *tmp = child;
434 DLIST_REMOVE(parent->children, child);
435 TALLOC_FREE(tmp);
436 parent->num_children -= 1;
437 break;
441 if (child == NULL) {
442 /* not all forked child processes are added to the children list */
443 DEBUG(2, ("Could not find child %d -- ignoring\n", (int)pid));
444 return;
447 if (unclean_shutdown) {
448 /* a child terminated uncleanly so tickle all
449 processes to see if they can grab any of the
450 pending locks
452 DEBUG(3,(__location__ " Unclean shutdown of pid %u\n",
453 (unsigned int)pid));
454 if (parent->cleanup_te == NULL) {
455 /* call the cleanup timer, but not too often */
456 int cleanup_time = lp_parm_int(-1, "smbd", "cleanuptime", 20);
457 parent->cleanup_te = tevent_add_timer(parent->ev_ctx,
458 parent,
459 timeval_current_ofs(cleanup_time, 0),
460 cleanup_timeout_fn,
461 parent);
462 DEBUG(1,("Scheduled cleanup of brl and lock database after unclean shutdown\n"));
466 if (!serverid_deregister(child_id)) {
467 DEBUG(1, ("Could not remove pid %d from serverid.tdb\n",
468 (int)pid));
472 /****************************************************************************
473 Have we reached the process limit ?
474 ****************************************************************************/
476 static bool allowable_number_of_smbd_processes(struct smbd_parent_context *parent)
478 int max_processes = lp_max_smbd_processes();
480 if (!max_processes)
481 return True;
483 return parent->num_children < max_processes;
486 static void smbd_sig_chld_handler(struct tevent_context *ev,
487 struct tevent_signal *se,
488 int signum,
489 int count,
490 void *siginfo,
491 void *private_data)
493 pid_t pid;
494 int status;
495 struct smbd_parent_context *parent =
496 talloc_get_type_abort(private_data,
497 struct smbd_parent_context);
499 while ((pid = sys_waitpid(-1, &status, WNOHANG)) > 0) {
500 bool unclean_shutdown = False;
502 /* If the child terminated normally, assume
503 it was an unclean shutdown unless the
504 status is 0
506 if (WIFEXITED(status)) {
507 unclean_shutdown = WEXITSTATUS(status);
509 /* If the child terminated due to a signal
510 we always assume it was unclean.
512 if (WIFSIGNALED(status)) {
513 unclean_shutdown = True;
515 remove_child_pid(parent, pid, unclean_shutdown);
519 static void smbd_setup_sig_chld_handler(struct smbd_parent_context *parent)
521 struct tevent_signal *se;
523 se = tevent_add_signal(parent->ev_ctx,
524 parent, /* mem_ctx */
525 SIGCHLD, 0,
526 smbd_sig_chld_handler,
527 parent);
528 if (!se) {
529 exit_server("failed to setup SIGCHLD handler");
533 static void smbd_open_socket_close_fn(struct tevent_context *ev,
534 struct tevent_fd *fde,
535 int fd,
536 void *private_data)
538 /* this might be the socket_wrapper swrap_close() */
539 close(fd);
542 static void smbd_accept_connection(struct tevent_context *ev,
543 struct tevent_fd *fde,
544 uint16_t flags,
545 void *private_data)
547 struct smbd_open_socket *s = talloc_get_type_abort(private_data,
548 struct smbd_open_socket);
549 struct messaging_context *msg_ctx = s->parent->msg_ctx;
550 struct sockaddr_storage addr;
551 socklen_t in_addrlen = sizeof(addr);
552 int fd;
553 pid_t pid = 0;
554 uint64_t unique_id;
556 fd = accept(s->fd, (struct sockaddr *)(void *)&addr,&in_addrlen);
557 if (fd == -1 && errno == EINTR)
558 return;
560 if (fd == -1) {
561 DEBUG(0,("accept: %s\n",
562 strerror(errno)));
563 return;
566 if (s->parent->interactive) {
567 reinit_after_fork(msg_ctx, ev, true);
568 smbd_process(ev, msg_ctx, fd, true);
569 exit_server_cleanly("end of interactive mode");
570 return;
573 if (!allowable_number_of_smbd_processes(s->parent)) {
574 close(fd);
575 return;
579 * Generate a unique id in the parent process so that we use
580 * the global random state in the parent.
582 unique_id = serverid_get_random_unique_id();
584 pid = fork();
585 if (pid == 0) {
586 NTSTATUS status = NT_STATUS_OK;
588 /* Child code ... */
589 am_parent = NULL;
592 * Can't use TALLOC_FREE here. Nulling out the argument to it
593 * would overwrite memory we've just freed.
595 talloc_free(s->parent);
596 s = NULL;
598 set_my_unique_id(unique_id);
600 /* Stop zombies, the parent explicitly handles
601 * them, counting worker smbds. */
602 CatchChild();
604 status = reinit_after_fork(msg_ctx,
606 true);
607 if (!NT_STATUS_IS_OK(status)) {
608 if (NT_STATUS_EQUAL(status,
609 NT_STATUS_TOO_MANY_OPENED_FILES)) {
610 DEBUG(0,("child process cannot initialize "
611 "because too many files are open\n"));
612 goto exit;
614 if (lp_clustering() &&
615 NT_STATUS_EQUAL(status,
616 NT_STATUS_INTERNAL_DB_ERROR)) {
617 DEBUG(1,("child process cannot initialize "
618 "because connection to CTDB "
619 "has failed\n"));
620 goto exit;
623 DEBUG(0,("reinit_after_fork() failed\n"));
624 smb_panic("reinit_after_fork() failed");
627 smbd_process(ev, msg_ctx, fd, false);
628 exit:
629 exit_server_cleanly("end of child");
630 return;
633 if (pid < 0) {
634 DEBUG(0,("smbd_accept_connection: fork() failed: %s\n",
635 strerror(errno)));
638 /* The parent doesn't need this socket */
639 close(fd);
641 /* Sun May 6 18:56:14 2001 ackley@cs.unm.edu:
642 Clear the closed fd info out of server_fd --
643 and more importantly, out of client_fd in
644 util_sock.c, to avoid a possible
645 getpeername failure if we reopen the logs
646 and use %I in the filename.
649 if (pid != 0) {
650 add_child_pid(s->parent, pid);
653 /* Force parent to check log size after
654 * spawning child. Fix from
655 * klausr@ITAP.Physik.Uni-Stuttgart.De. The
656 * parent smbd will log to logserver.smb. It
657 * writes only two messages for each child
658 * started/finished. But each child writes,
659 * say, 50 messages also in logserver.smb,
660 * begining with the debug_count of the
661 * parent, before the child opens its own log
662 * file logserver.client. In a worst case
663 * scenario the size of logserver.smb would be
664 * checked after about 50*50=2500 messages
665 * (ca. 100kb).
666 * */
667 force_check_log_size();
670 static bool smbd_open_one_socket(struct smbd_parent_context *parent,
671 struct tevent_context *ev_ctx,
672 const struct sockaddr_storage *ifss,
673 uint16_t port)
675 struct smbd_open_socket *s;
677 s = talloc(parent, struct smbd_open_socket);
678 if (!s) {
679 return false;
682 s->parent = parent;
683 s->fd = open_socket_in(SOCK_STREAM,
684 port,
685 parent->sockets == NULL ? 0 : 2,
686 ifss,
687 true);
688 if (s->fd == -1) {
689 DEBUG(0,("smbd_open_once_socket: open_socket_in: "
690 "%s\n", strerror(errno)));
691 TALLOC_FREE(s);
693 * We ignore an error here, as we've done before
695 return true;
698 /* ready to listen */
699 set_socket_options(s->fd, "SO_KEEPALIVE");
700 set_socket_options(s->fd, lp_socket_options());
702 /* Set server socket to
703 * non-blocking for the accept. */
704 set_blocking(s->fd, False);
706 if (listen(s->fd, SMBD_LISTEN_BACKLOG) == -1) {
707 DEBUG(0,("open_sockets_smbd: listen: "
708 "%s\n", strerror(errno)));
709 close(s->fd);
710 TALLOC_FREE(s);
711 return false;
714 s->fde = tevent_add_fd(ev_ctx,
716 s->fd, TEVENT_FD_READ,
717 smbd_accept_connection,
719 if (!s->fde) {
720 DEBUG(0,("open_sockets_smbd: "
721 "tevent_add_fd: %s\n",
722 strerror(errno)));
723 close(s->fd);
724 TALLOC_FREE(s);
725 return false;
727 tevent_fd_set_close_fn(s->fde, smbd_open_socket_close_fn);
729 DLIST_ADD_END(parent->sockets, s, struct smbd_open_socket *);
731 return true;
734 /****************************************************************************
735 Open the socket communication.
736 ****************************************************************************/
738 static bool open_sockets_smbd(struct smbd_parent_context *parent,
739 struct tevent_context *ev_ctx,
740 struct messaging_context *msg_ctx,
741 const char *smb_ports)
743 int num_interfaces = iface_count();
744 int i,j;
745 const char **ports;
746 unsigned dns_port = 0;
748 #ifdef HAVE_ATEXIT
749 atexit(killkids);
750 #endif
752 /* Stop zombies */
753 smbd_setup_sig_chld_handler(parent);
755 ports = lp_smb_ports();
757 /* use a reasonable default set of ports - listing on 445 and 139 */
758 if (smb_ports) {
759 char **l;
760 l = str_list_make_v3(talloc_tos(), smb_ports, NULL);
761 ports = discard_const_p(const char *, l);
764 for (j = 0; ports && ports[j]; j++) {
765 unsigned port = atoi(ports[j]);
767 if (port == 0 || port > 0xffff) {
768 exit_server_cleanly("Invalid port in the config or on "
769 "the commandline specified!");
773 if (lp_interfaces() && lp_bind_interfaces_only()) {
774 /* We have been given an interfaces line, and been
775 told to only bind to those interfaces. Create a
776 socket per interface and bind to only these.
779 /* Now open a listen socket for each of the
780 interfaces. */
781 for(i = 0; i < num_interfaces; i++) {
782 const struct sockaddr_storage *ifss =
783 iface_n_sockaddr_storage(i);
784 if (ifss == NULL) {
785 DEBUG(0,("open_sockets_smbd: "
786 "interface %d has NULL IP address !\n",
787 i));
788 continue;
791 for (j = 0; ports && ports[j]; j++) {
792 unsigned port = atoi(ports[j]);
794 /* Keep the first port for mDNS service
795 * registration.
797 if (dns_port == 0) {
798 dns_port = port;
801 if (!smbd_open_one_socket(parent,
802 ev_ctx,
803 ifss,
804 port)) {
805 return false;
809 } else {
810 /* Just bind to 0.0.0.0 - accept connections
811 from anywhere. */
813 const char *sock_addr;
814 char *sock_tok;
815 const char *sock_ptr;
817 #if HAVE_IPV6
818 sock_addr = "::,0.0.0.0";
819 #else
820 sock_addr = "0.0.0.0";
821 #endif
823 for (sock_ptr=sock_addr;
824 next_token_talloc(talloc_tos(), &sock_ptr, &sock_tok, " \t,"); ) {
825 for (j = 0; ports && ports[j]; j++) {
826 struct sockaddr_storage ss;
827 unsigned port = atoi(ports[j]);
829 /* Keep the first port for mDNS service
830 * registration.
832 if (dns_port == 0) {
833 dns_port = port;
836 /* open an incoming socket */
837 if (!interpret_string_addr(&ss, sock_tok,
838 AI_NUMERICHOST|AI_PASSIVE)) {
839 continue;
843 * If we fail to open any sockets
844 * in this loop the parent-sockets == NULL
845 * case below will prevent us from starting.
848 (void)smbd_open_one_socket(parent,
849 ev_ctx,
850 &ss,
851 port);
856 if (parent->sockets == NULL) {
857 DEBUG(0,("open_sockets_smbd: No "
858 "sockets available to bind to.\n"));
859 return false;
862 /* Setup the main smbd so that we can get messages. Note that
863 do this after starting listening. This is needed as when in
864 clustered mode, ctdb won't allow us to start doing database
865 operations until it has gone thru a full startup, which
866 includes checking to see that smbd is listening. */
868 if (!serverid_register(messaging_server_id(msg_ctx),
869 FLAG_MSG_GENERAL|FLAG_MSG_SMBD
870 |FLAG_MSG_PRINT_GENERAL
871 |FLAG_MSG_DBWRAP)) {
872 DEBUG(0, ("open_sockets_smbd: Failed to register "
873 "myself in serverid.tdb\n"));
874 return false;
877 /* Listen to messages */
879 messaging_register(msg_ctx, NULL, MSG_SHUTDOWN, msg_exit_server);
880 messaging_register(msg_ctx, ev_ctx, MSG_SMB_CONF_UPDATED,
881 smbd_parent_conf_updated);
882 messaging_register(msg_ctx, NULL, MSG_SMB_STAT_CACHE_DELETE,
883 smb_stat_cache_delete);
884 messaging_register(msg_ctx, NULL, MSG_DEBUG, smbd_msg_debug);
885 messaging_register(msg_ctx, NULL, MSG_SMB_BRL_VALIDATE,
886 brl_revalidate);
887 messaging_register(msg_ctx, NULL, MSG_SMB_FORCE_TDIS,
888 smb_parent_send_to_children);
889 messaging_register(msg_ctx, NULL, MSG_SMB_KILL_CLIENT_IP,
890 smb_parent_send_to_children);
891 messaging_register(msg_ctx, NULL, MSG_SMB_TELL_NUM_CHILDREN,
892 smb_tell_num_children);
894 messaging_register(msg_ctx, NULL,
895 ID_CACHE_DELETE, smbd_parent_id_cache_delete);
896 messaging_register(msg_ctx, NULL,
897 ID_CACHE_KILL, smbd_parent_id_cache_kill);
899 if (lp_clustering()) {
900 ctdbd_register_reconfigure(messaging_ctdbd_connection());
903 #ifdef DEVELOPER
904 messaging_register(msg_ctx, NULL, MSG_SMB_INJECT_FAULT,
905 msg_inject_fault);
906 #endif
908 if (lp_multicast_dns_register() && (dns_port != 0)) {
909 #ifdef WITH_DNSSD_SUPPORT
910 smbd_setup_mdns_registration(ev_ctx,
911 parent, dns_port);
912 #endif
913 #ifdef WITH_AVAHI_SUPPORT
914 void *avahi_conn;
916 avahi_conn = avahi_start_register(ev_ctx,
917 ev_ctx,
918 dns_port);
919 if (avahi_conn == NULL) {
920 DEBUG(10, ("avahi_start_register failed\n"));
922 #endif
925 return true;
930 handle stdin becoming readable when we are in --foreground mode
932 static void smbd_stdin_handler(struct tevent_context *ev,
933 struct tevent_fd *fde,
934 uint16_t flags,
935 void *private_data)
937 char c;
938 if (read(0, &c, 1) != 1) {
939 /* we have reached EOF on stdin, which means the
940 parent has exited. Shutdown the server */
941 exit_server_cleanly("EOF on stdin");
945 struct smbd_parent_tevent_trace_state {
946 TALLOC_CTX *frame;
949 static void smbd_parent_tevent_trace_callback(enum tevent_trace_point point,
950 void *private_data)
952 struct smbd_parent_tevent_trace_state *state =
953 (struct smbd_parent_tevent_trace_state *)private_data;
955 switch (point) {
956 case TEVENT_TRACE_BEFORE_WAIT:
957 break;
958 case TEVENT_TRACE_AFTER_WAIT:
959 break;
960 case TEVENT_TRACE_BEFORE_LOOP_ONCE:
961 TALLOC_FREE(state->frame);
962 state->frame = talloc_stackframe();
963 break;
964 case TEVENT_TRACE_AFTER_LOOP_ONCE:
965 TALLOC_FREE(state->frame);
966 break;
969 errno = 0;
972 static void smbd_parent_loop(struct tevent_context *ev_ctx,
973 struct smbd_parent_context *parent)
975 struct smbd_parent_tevent_trace_state trace_state = {
976 .frame = NULL,
978 int ret = 0;
980 tevent_set_trace_callback(ev_ctx, smbd_parent_tevent_trace_callback,
981 &trace_state);
983 /* now accept incoming connections - forking a new process
984 for each incoming connection */
985 DEBUG(2,("waiting for connections\n"));
987 ret = tevent_loop_wait(ev_ctx);
988 if (ret != 0) {
989 DEBUG(0, ("tevent_loop_wait failed: %d, %s, exiting\n",
990 ret, strerror(errno)));
993 TALLOC_FREE(trace_state.frame);
995 /* NOTREACHED return True; */
999 /****************************************************************************
1000 Initialise connect, service and file structs.
1001 ****************************************************************************/
1003 static bool init_structs(void )
1006 * Set the machine NETBIOS name if not already
1007 * set from the config file.
1010 if (!init_names())
1011 return False;
1013 if (!secrets_init())
1014 return False;
1016 return True;
1019 static void smbd_parent_sig_term_handler(struct tevent_context *ev,
1020 struct tevent_signal *se,
1021 int signum,
1022 int count,
1023 void *siginfo,
1024 void *private_data)
1026 exit_server_cleanly("termination signal");
1029 static void smbd_parent_sig_hup_handler(struct tevent_context *ev,
1030 struct tevent_signal *se,
1031 int signum,
1032 int count,
1033 void *siginfo,
1034 void *private_data)
1036 struct smbd_parent_context *parent =
1037 talloc_get_type_abort(private_data,
1038 struct smbd_parent_context);
1040 change_to_root_user();
1041 DEBUG(1,("parent: Reloading services after SIGHUP\n"));
1042 reload_services(NULL, NULL, false);
1044 printing_subsystem_update(parent->ev_ctx, parent->msg_ctx, true);
1047 /****************************************************************************
1048 main program.
1049 ****************************************************************************/
1051 /* Declare prototype for build_options() to avoid having to run it through
1052 mkproto.h. Mixing $(builddir) and $(srcdir) source files in the current
1053 prototype generation system is too complicated. */
1055 extern void build_options(bool screen);
1057 int main(int argc,const char *argv[])
1059 /* shall I run as a daemon */
1060 bool is_daemon = false;
1061 bool interactive = false;
1062 bool Fork = true;
1063 bool no_process_group = false;
1064 bool log_stdout = false;
1065 char *ports = NULL;
1066 char *profile_level = NULL;
1067 int opt;
1068 poptContext pc;
1069 bool print_build_options = False;
1070 enum {
1071 OPT_DAEMON = 1000,
1072 OPT_INTERACTIVE,
1073 OPT_FORK,
1074 OPT_NO_PROCESS_GROUP,
1075 OPT_LOG_STDOUT
1077 struct poptOption long_options[] = {
1078 POPT_AUTOHELP
1079 {"daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" },
1080 {"interactive", 'i', POPT_ARG_NONE, NULL, OPT_INTERACTIVE, "Run interactive (not a daemon)"},
1081 {"foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Run daemon in foreground (for daemontools, etc.)" },
1082 {"no-process-group", '\0', POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" },
1083 {"log-stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" },
1084 {"build-options", 'b', POPT_ARG_NONE, NULL, 'b', "Print build options" },
1085 {"port", 'p', POPT_ARG_STRING, &ports, 0, "Listen on the specified ports"},
1086 {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
1087 POPT_COMMON_SAMBA
1088 POPT_TABLEEND
1090 struct smbd_parent_context *parent = NULL;
1091 TALLOC_CTX *frame;
1092 NTSTATUS status;
1093 struct tevent_context *ev_ctx;
1094 struct messaging_context *msg_ctx;
1095 struct server_id server_id;
1096 struct tevent_signal *se;
1097 int profiling_level;
1098 char *np_dir = NULL;
1099 static const struct smbd_shim smbd_shim_fns =
1101 .cancel_pending_lock_requests_by_fid = smbd_cancel_pending_lock_requests_by_fid,
1102 .send_stat_cache_delete_message = smbd_send_stat_cache_delete_message,
1103 .change_to_root_user = smbd_change_to_root_user,
1104 .become_authenticated_pipe_user = smbd_become_authenticated_pipe_user,
1105 .unbecome_authenticated_pipe_user = smbd_unbecome_authenticated_pipe_user,
1107 .contend_level2_oplocks_begin = smbd_contend_level2_oplocks_begin,
1108 .contend_level2_oplocks_end = smbd_contend_level2_oplocks_end,
1110 .become_root = smbd_become_root,
1111 .unbecome_root = smbd_unbecome_root,
1113 .exit_server = smbd_exit_server,
1114 .exit_server_cleanly = smbd_exit_server_cleanly,
1118 * Do this before any other talloc operation
1120 talloc_enable_null_tracking();
1121 frame = talloc_stackframe();
1123 setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
1125 load_case_tables();
1127 set_smbd_shim(&smbd_shim_fns);
1129 smbd_init_globals();
1131 TimeInit();
1133 #ifdef HAVE_SET_AUTH_PARAMETERS
1134 set_auth_parameters(argc,argv);
1135 #endif
1137 pc = poptGetContext("smbd", argc, argv, long_options, 0);
1138 while((opt = poptGetNextOpt(pc)) != -1) {
1139 switch (opt) {
1140 case OPT_DAEMON:
1141 is_daemon = true;
1142 break;
1143 case OPT_INTERACTIVE:
1144 interactive = true;
1145 break;
1146 case OPT_FORK:
1147 Fork = false;
1148 break;
1149 case OPT_NO_PROCESS_GROUP:
1150 no_process_group = true;
1151 break;
1152 case OPT_LOG_STDOUT:
1153 log_stdout = true;
1154 break;
1155 case 'b':
1156 print_build_options = True;
1157 break;
1158 default:
1159 d_fprintf(stderr, "\nInvalid option %s: %s\n\n",
1160 poptBadOption(pc, 0), poptStrerror(opt));
1161 poptPrintUsage(pc, stderr, 0);
1162 exit(1);
1165 poptFreeContext(pc);
1167 if (interactive) {
1168 Fork = False;
1169 log_stdout = True;
1172 if (log_stdout) {
1173 setup_logging(argv[0], DEBUG_STDOUT);
1174 } else {
1175 setup_logging(argv[0], DEBUG_FILE);
1178 if (print_build_options) {
1179 build_options(True); /* Display output to screen as well as debug */
1180 exit(0);
1183 #ifdef HAVE_SETLUID
1184 /* needed for SecureWare on SCO */
1185 setluid(0);
1186 #endif
1188 set_remote_machine_name("smbd", False);
1190 if (interactive && (DEBUGLEVEL >= 9)) {
1191 talloc_enable_leak_report();
1194 if (log_stdout && Fork) {
1195 DEBUG(0,("ERROR: Can't log to stdout (-S) unless daemon is in foreground (-F) or interactive (-i)\n"));
1196 exit(1);
1199 /* we want to re-seed early to prevent time delays causing
1200 client problems at a later date. (tridge) */
1201 generate_random_buffer(NULL, 0);
1203 /* get initial effective uid and gid */
1204 sec_init();
1206 /* make absolutely sure we run as root - to handle cases where people
1207 are crazy enough to have it setuid */
1208 gain_root_privilege();
1209 gain_root_group_privilege();
1211 fault_setup();
1212 dump_core_setup("smbd", lp_logfile(talloc_tos()));
1214 /* we are never interested in SIGPIPE */
1215 BlockSignals(True,SIGPIPE);
1217 #if defined(SIGFPE)
1218 /* we are never interested in SIGFPE */
1219 BlockSignals(True,SIGFPE);
1220 #endif
1222 #if defined(SIGUSR2)
1223 /* We are no longer interested in USR2 */
1224 BlockSignals(True,SIGUSR2);
1225 #endif
1227 /* POSIX demands that signals are inherited. If the invoking process has
1228 * these signals masked, we will have problems, as we won't recieve them. */
1229 BlockSignals(False, SIGHUP);
1230 BlockSignals(False, SIGUSR1);
1231 BlockSignals(False, SIGTERM);
1233 /* Ensure we leave no zombies until we
1234 * correctly set up child handling below. */
1236 CatchChild();
1238 /* we want total control over the permissions on created files,
1239 so set our umask to 0 */
1240 umask(0);
1242 reopen_logs();
1244 DEBUG(0,("smbd version %s started.\n", samba_version_string()));
1245 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE));
1247 DEBUG(2,("uid=%d gid=%d euid=%d egid=%d\n",
1248 (int)getuid(),(int)getgid(),(int)geteuid(),(int)getegid()));
1250 /* Output the build options to the debug log */
1251 build_options(False);
1253 if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
1254 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
1255 exit(1);
1258 if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
1259 DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
1260 exit(1);
1263 if (!cluster_probe_ok()) {
1264 exit(1);
1267 /* Init the security context and global current_user */
1268 init_sec_ctx();
1271 * Initialize the event context. The event context needs to be
1272 * initialized before the messaging context, cause the messaging
1273 * context holds an event context.
1274 * FIXME: This should be s3_tevent_context_init()
1276 ev_ctx = server_event_context();
1277 if (ev_ctx == NULL) {
1278 exit(1);
1282 * Init the messaging context
1283 * FIXME: This should only call messaging_init()
1285 msg_ctx = server_messaging_context();
1286 if (msg_ctx == NULL) {
1287 exit(1);
1291 * Reloading of the printers will not work here as we don't have a
1292 * server info and rpc services set up. It will be called later.
1294 if (!reload_services(NULL, NULL, false)) {
1295 exit(1);
1298 if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
1299 && !lp_parm_bool(-1, "server role check", "inhibit", false)) {
1300 DEBUG(0, ("server role = 'active directory domain controller' not compatible with running smbd standalone. \n"));
1301 DEBUGADD(0, ("You should start 'samba' instead, and it will control starting smbd if required\n"));
1302 exit(1);
1305 /* ...NOTE... Log files are working from this point! */
1307 DEBUG(3,("loaded services\n"));
1309 init_structs();
1311 if (!profile_setup(msg_ctx, False)) {
1312 DEBUG(0,("ERROR: failed to setup profiling\n"));
1313 return -1;
1316 if (profile_level != NULL) {
1317 profiling_level = atoi(profile_level);
1318 } else {
1319 profiling_level = lp_smbd_profiling_level();
1321 set_profile_level(profiling_level, messaging_server_id(msg_ctx));
1323 if (!is_daemon && !is_a_socket(0)) {
1324 if (!interactive) {
1325 DEBUG(3, ("Standard input is not a socket, "
1326 "assuming -D option\n"));
1330 * Setting is_daemon here prevents us from eventually calling
1331 * the open_sockets_inetd()
1334 is_daemon = True;
1337 if (is_daemon && !interactive) {
1338 DEBUG(3, ("Becoming a daemon.\n"));
1339 become_daemon(Fork, no_process_group, log_stdout);
1342 set_my_unique_id(serverid_get_random_unique_id());
1344 #if HAVE_SETPGID
1346 * If we're interactive we want to set our own process group for
1347 * signal management.
1349 if (interactive && !no_process_group)
1350 setpgid( (pid_t)0, (pid_t)0);
1351 #endif
1353 if (!directory_exist(lp_lock_directory()))
1354 mkdir(lp_lock_directory(), 0755);
1356 if (!directory_exist(lp_pid_directory()))
1357 mkdir(lp_pid_directory(), 0755);
1359 if (is_daemon)
1360 pidfile_create(lp_pid_directory(), "smbd");
1362 status = reinit_after_fork(msg_ctx,
1363 ev_ctx,
1364 false);
1365 if (!NT_STATUS_IS_OK(status)) {
1366 exit_daemon("reinit_after_fork() failed", map_errno_from_nt_status(status));
1369 if (!interactive) {
1371 * Do not initialize the parent-child-pipe before becoming a
1372 * daemon: this is used to detect a died parent in the child
1373 * process.
1375 status = init_before_fork();
1376 if (!NT_STATUS_IS_OK(status)) {
1377 exit_daemon(nt_errstr(status), map_errno_from_nt_status(status));
1381 parent = talloc_zero(ev_ctx, struct smbd_parent_context);
1382 if (!parent) {
1383 exit_server("talloc(struct smbd_parent_context) failed");
1385 parent->interactive = interactive;
1386 parent->ev_ctx = ev_ctx;
1387 parent->msg_ctx = msg_ctx;
1388 am_parent = parent;
1390 se = tevent_add_signal(parent->ev_ctx,
1391 parent,
1392 SIGTERM, 0,
1393 smbd_parent_sig_term_handler,
1394 parent);
1395 if (!se) {
1396 exit_server("failed to setup SIGTERM handler");
1398 se = tevent_add_signal(parent->ev_ctx,
1399 parent,
1400 SIGHUP, 0,
1401 smbd_parent_sig_hup_handler,
1402 parent);
1403 if (!se) {
1404 exit_server("failed to setup SIGHUP handler");
1407 /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
1409 if (smbd_memcache() == NULL) {
1410 exit_daemon("no memcache available", EACCES);
1413 memcache_set_global(smbd_memcache());
1415 /* Initialise the password backed before the global_sam_sid
1416 to ensure that we fetch from ldap before we make a domain sid up */
1418 if(!initialize_password_db(false, ev_ctx))
1419 exit(1);
1421 if (!secrets_init()) {
1422 exit_daemon("smbd can not open secrets.tdb", EACCES);
1425 if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
1426 struct loadparm_context *lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
1427 if (!open_schannel_session_store(NULL, lp_ctx)) {
1428 exit_daemon("ERROR: Samba cannot open schannel store for secured NETLOGON operations.", EACCES);
1430 TALLOC_FREE(lp_ctx);
1433 if(!get_global_sam_sid()) {
1434 exit_daemon("Samba cannot create a SAM SID", EACCES);
1437 server_id = messaging_server_id(msg_ctx);
1438 status = smbXsrv_version_global_init(&server_id);
1439 if (!NT_STATUS_IS_OK(status)) {
1440 exit_daemon("Samba cannot init server context", EACCES);
1443 status = smbXsrv_session_global_init();
1444 if (!NT_STATUS_IS_OK(status)) {
1445 exit_daemon("Samba cannot init session context", EACCES);
1448 status = smbXsrv_tcon_global_init();
1449 if (!NT_STATUS_IS_OK(status)) {
1450 exit_daemon("Samba cannot init tcon context", EACCES);
1453 if (!locking_init())
1454 exit_daemon("Samba cannot init locking", EACCES);
1456 if (!leases_db_init(false)) {
1457 exit_daemon("Samba cannot init leases", EACCES);
1460 if (!smbd_parent_notify_init(NULL, msg_ctx, ev_ctx)) {
1461 exit_daemon("Samba cannot init notification", EACCES);
1464 if (!messaging_parent_dgm_cleanup_init(msg_ctx)) {
1465 exit(1);
1468 if (!smbd_scavenger_init(NULL, msg_ctx, ev_ctx)) {
1469 exit_daemon("Samba cannot init scavenging", EACCES);
1472 if (!serverid_parent_init(ev_ctx)) {
1473 exit_daemon("Samba cannot init server id", EACCES);
1476 if (!W_ERROR_IS_OK(registry_init_full()))
1477 exit_daemon("Samba cannot init registry", EACCES);
1479 /* Open the share_info.tdb here, so we don't have to open
1480 after the fork on every single connection. This is a small
1481 performance improvment and reduces the total number of system
1482 fds used. */
1483 if (!share_info_db_init()) {
1484 exit_daemon("ERROR: failed to load share info db.", EACCES);
1487 status = init_system_session_info();
1488 if (!NT_STATUS_IS_OK(status)) {
1489 DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
1490 nt_errstr(status)));
1491 return -1;
1494 if (!init_guest_info()) {
1495 DEBUG(0,("ERROR: failed to setup guest info.\n"));
1496 return -1;
1499 if (!file_init_global()) {
1500 DEBUG(0, ("ERROR: file_init_global() failed\n"));
1501 return -1;
1503 status = smbXsrv_open_global_init();
1504 if (!NT_STATUS_IS_OK(status)) {
1505 exit_daemon("Samba cannot init global open", map_errno_from_nt_status(status));
1508 /* This MUST be done before start_epmd() because otherwise
1509 * start_epmd() forks and races against dcesrv_ep_setup() to
1510 * call directory_create_or_exist() */
1511 if (!directory_create_or_exist(lp_ncalrpc_dir(), 0755)) {
1512 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
1513 lp_ncalrpc_dir(), strerror(errno)));
1514 return -1;
1517 np_dir = talloc_asprintf(talloc_tos(), "%s/np", lp_ncalrpc_dir());
1518 if (!np_dir) {
1519 DEBUG(0, ("%s: Out of memory\n", __location__));
1520 return -1;
1523 if (!directory_create_or_exist_strict(np_dir, geteuid(), 0700)) {
1524 DEBUG(0, ("Failed to create pipe directory %s - %s\n",
1525 np_dir, strerror(errno)));
1526 return -1;
1529 if (is_daemon && !interactive) {
1530 if (rpc_epmapper_daemon() == RPC_DAEMON_FORK) {
1531 start_epmd(ev_ctx, msg_ctx);
1535 if (!dcesrv_ep_setup(ev_ctx, msg_ctx)) {
1536 exit_daemon("Samba cannot setup ep pipe", EACCES);
1539 if (is_daemon && !interactive) {
1540 daemon_ready("smbd");
1543 /* only start other daemons if we are running as a daemon
1544 * -- bad things will happen if smbd is launched via inetd
1545 * and we fork a copy of ourselves here */
1546 if (is_daemon && !interactive) {
1548 if (rpc_lsasd_daemon() == RPC_DAEMON_FORK) {
1549 start_lsasd(ev_ctx, msg_ctx);
1552 if (!lp__disable_spoolss() &&
1553 (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
1554 bool bgq = lp_parm_bool(-1, "smbd", "backgroundqueue", true);
1556 if (!printing_subsystem_init(ev_ctx, msg_ctx, true, bgq)) {
1557 exit_daemon("Samba failed to init printing subsystem", EACCES);
1560 } else if (!lp__disable_spoolss() &&
1561 (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
1562 if (!printing_subsystem_init(ev_ctx, msg_ctx, false, false)) {
1563 exit(1);
1567 if (!is_daemon) {
1568 int sock;
1570 /* inetd mode */
1571 TALLOC_FREE(frame);
1573 /* Started from inetd. fd 0 is the socket. */
1574 /* We will abort gracefully when the client or remote system
1575 goes away */
1576 sock = dup(0);
1578 /* close stdin, stdout (if not logging to it), but not stderr */
1579 close_low_fds(true, !debug_get_output_is_stdout(), false);
1581 #ifdef HAVE_ATEXIT
1582 atexit(killkids);
1583 #endif
1585 /* Stop zombies */
1586 smbd_setup_sig_chld_handler(parent);
1588 smbd_process(ev_ctx, msg_ctx, sock, true);
1590 exit_server_cleanly(NULL);
1591 return(0);
1594 if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
1595 exit_server("open_sockets_smbd() failed");
1597 /* do a printer update now that all messaging has been set up,
1598 * before we allow clients to start connecting */
1599 if (!lp__disable_spoolss() &&
1600 (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
1601 printing_subsystem_update(ev_ctx, msg_ctx, false);
1604 TALLOC_FREE(frame);
1605 /* make sure we always have a valid stackframe */
1606 frame = talloc_stackframe();
1608 if (!Fork) {
1609 /* if we are running in the foreground then look for
1610 EOF on stdin, and exit if it happens. This allows
1611 us to die if the parent process dies
1612 Only do this on a pipe or socket, no other device.
1614 struct stat st;
1615 if (fstat(0, &st) != 0) {
1616 return false;
1618 if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
1619 tevent_add_fd(ev_ctx,
1620 parent,
1622 TEVENT_FD_READ,
1623 smbd_stdin_handler,
1624 NULL);
1628 smbd_parent_loop(ev_ctx, parent);
1630 exit_server_cleanly(NULL);
1631 TALLOC_FREE(frame);
1632 return(0);