Changeset 988 for vendor/current/source3/smbd/server.c

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

File:

• vendor/current/source3/smbd/server.c (modified) (59 diffs)

vendor/current/source3/smbd/server.c

@@ -30 +30 @@
 #include "libcli/auth/schannel.h"
 #include "secrets.h"
-#include "memcache.h"
+#include "../lib/util/memcache.h"
 #include "ctdbd_conn.h"
-#include "printing/printer_list.h"
-#include "rpc_server/rpc_ep_setup.h"
-#include "printing/pcap.h"
-#include "printing.h"
+#include "util_cluster.h"
+#include "printing/queue_process.h"
+#include "rpc_server/rpc_service_setup.h"
+#include "rpc_server/rpc_config.h"
 #include "serverid.h"
 #include "passdb.h"
@@ -41 +41 @@
 #include "messages.h"
 #include "smbprofile.h"
+#include "lib/id_cache.h"
+#include "lib/param/param.h"
+#include "lib/background.h"
+#include "lib/conn_tdb.h"
+#include "../lib/util/pidfile.h"
+#include "lib/smbd_shim.h"
+#include "scavenger.h"
+#include "locking/leases_db.h"
+#include "smbd/notifyd/notifyd.h"
+#include "smbd/smbd_cleanupd.h"
+#include "lib/util/sys_rw.h"
+
+#ifdef CLUSTER_SUPPORT
+#include "ctdb_protocol.h"
+#endif
+
+struct smbd_open_socket;
+struct smbd_child_pid;
+
+struct smbd_parent_context {
+        bool interactive;
+
+        struct tevent_context *ev_ctx;
+        struct messaging_context *msg_ctx;
+
+        /* the list of listening sockets */
+        struct smbd_open_socket *sockets;
+
+        /* the list of current child processes */
+        struct smbd_child_pid *children;
+        size_t num_children;
+
+        struct server_id cleanupd;
+
+        struct tevent_timer *cleanup_te;
+};
+
+struct smbd_open_socket {
+        struct smbd_open_socket *prev, *next;
+        struct smbd_parent_context *parent;
+        int fd;
+        struct tevent_fd *fde;
+};
+
+struct smbd_child_pid {
+        struct smbd_child_pid *prev, *next;
+        pid_t pid;
+};
 
 extern void start_epmd(struct tevent_context *ev_ctx,
                        struct messaging_context *msg_ctx);
 
-extern void start_spoolssd(struct event_context *ev_ctx,
-                           struct messaging_context *msg_ctx);
-
-#ifdef WITH_DFS
-extern int dcelogin_atmost_once;
-#endif /* WITH_DFS */
-
-static void smbd_set_server_fd(int fd)
-{
-        struct smbd_server_connection *sconn = smbd_server_conn;
-        char addr[INET6_ADDRSTRLEN];
-        const char *name;
-
-        sconn->sock = fd;
-
-        /*
-         * Initialize sconn->client_id: If we can't find the client's
-         * name, default to its address.
-         */
-
-        if (sconn->client_id.name != NULL &&
-            sconn->client_id.name != sconn->client_id.addr) {
-                talloc_free(discard_const_p(char, sconn->client_id.name));
-                sconn->client_id.name = NULL;
-        }
-
-        client_addr(fd, sconn->client_id.addr, sizeof(sconn->client_id.addr));
-
-        name = client_name(sconn->sock);
-        if (strcmp(name, "UNKNOWN") != 0) {
-                name = talloc_strdup(sconn, name);
-        } else {
-                name = NULL;
-        }
-        sconn->client_id.name =
-                (name != NULL) ? name : sconn->client_id.addr;
-
-        sub_set_socket_ids(sconn->client_id.addr, sconn->client_id.name,
-                           client_socket_addr(sconn->sock, addr,
-                                              sizeof(addr)));
-}
-
-struct event_context *smbd_event_context(void)
-{
-        return server_event_context();
-}
+extern void start_lsasd(struct tevent_context *ev_ctx,
+                        struct messaging_context *msg_ctx);
+
+extern void start_fssd(struct tevent_context *ev_ctx,
+                       struct messaging_context *msg_ctx);
+
+extern void start_mdssd(struct tevent_context *ev_ctx,
+                        struct messaging_context *msg_ctx);
 
 /*******************************************************************
@@ -96 +106 @@
  ********************************************************************/
 
-static void smb_conf_updated(struct messaging_context *msg,
-                             void *private_data,
-                             uint32_t msg_type,
-                             struct server_id server_id,
-                             DATA_BLOB *data)
+static void smbd_parent_conf_updated(struct messaging_context *msg,
+                                     void *private_data,
+                                     uint32_t msg_type,
+                                     struct server_id server_id,
+                                     DATA_BLOB *data)
 {
         struct tevent_context *ev_ctx =
                 talloc_get_type_abort(private_data, struct tevent_context);
 
-        DEBUG(10,("smb_conf_updated: Got message saying smb.conf was "
+        DEBUG(10,("smbd_parent_conf_updated: Got message saying smb.conf was "
                   "updated. Reloading.\n"));
         change_to_root_user();
-        reload_services(msg, smbd_server_conn->sock, False);
-        /* printer reload triggered by background printing process */
-}
-
-/*******************************************************************
- What to do when printcap is updated.
- ********************************************************************/
-
-static void smb_pcap_updated(struct messaging_context *msg,
-                             void *private_data,
-                             uint32_t msg_type,
-                             struct server_id server_id,
-                             DATA_BLOB *data)
-{
-        struct tevent_context *ev_ctx =
-                talloc_get_type_abort(private_data, struct tevent_context);
-
-        DEBUG(10,("Got message saying pcap was updated. Reloading.\n"));
-        change_to_root_user();
-        reload_printers(ev_ctx, msg);
-}
-
-static void smbd_sig_term_handler(struct tevent_context *ev,
-                                  struct tevent_signal *se,
-                                  int signum,
-                                  int count,
-                                  void *siginfo,
-                                  void *private_data)
-{
-        exit_server_cleanly("termination signal");
-}
-
-static void smbd_setup_sig_term_handler(void)
-{
-        struct tevent_signal *se;
-
-        se = tevent_add_signal(smbd_event_context(),
-                               smbd_event_context(),
-                               SIGTERM, 0,
-                               smbd_sig_term_handler,
-                               NULL);
-        if (!se) {
-                exit_server("failed to setup SIGTERM handler");
-        }
-}
-
-static void smbd_sig_hup_handler(struct tevent_context *ev,
-                                 struct tevent_signal *se,
-                                 int signum,
-                                 int count,
-                                 void *siginfo,
-                                 void *private_data)
-{
-        struct messaging_context *msg_ctx = talloc_get_type_abort(
-                private_data, struct messaging_context);
-        change_to_root_user();
-        DEBUG(1,("Reloading services after SIGHUP\n"));
-        reload_services(msg_ctx, smbd_server_conn->sock, false);
-}
-
-static void smbd_setup_sig_hup_handler(struct tevent_context *ev,
-                                       struct messaging_context *msg_ctx)
-{
-        struct tevent_signal *se;
-
-        se = tevent_add_signal(ev, ev, SIGHUP, 0, smbd_sig_hup_handler,
-                               msg_ctx);
-        if (!se) {
-                exit_server("failed to setup SIGHUP handler");
-        }
-}
-
+        reload_services(NULL, NULL, false);
+        printing_subsystem_update(ev_ctx, msg, false);
+}
 
 /*******************************************************************
@@ -203 +144 @@
 {
         if(am_parent) kill(0,SIGTERM);
-}
-
-/****************************************************************************
- Process a sam sync message - not sure whether to do this here or
- somewhere else.
-****************************************************************************/
-
-static void msg_sam_sync(struct messaging_context *msg,
-                         void *private_data,
-                         uint32_t msg_type,
-                         struct server_id server_id,
-                         DATA_BLOB *data)
-{
-        DEBUG(10, ("** sam sync message received, ignoring\n"));
 }
 
@@ -237 +164 @@
 {
         int sig;
+        struct server_id_buf tmp;
 
         if (data->length != sizeof(sig)) {
                 DEBUG(0, ("Process %s sent bogus signal injection request\n",
-                          procid_str_static(&src)));
+                          server_id_str_buf(src, &tmp)));
                 return;
         }
@@ -252 +180 @@
 #if HAVE_STRSIGNAL
         DEBUG(0, ("Process %s requested injection of signal %d (%s)\n",
-                  procid_str_static(&src), sig, strsignal(sig)));
+                  server_id_str_buf(src, &tmp), sig, strsignal(sig)));
 #else
         DEBUG(0, ("Process %s requested injection of signal %d\n",
-                  procid_str_static(&src), sig));
+                  server_id_str_buf(src, &tmp), sig));
 #endif
 
-        kill(sys_getpid(), sig);
+        kill(getpid(), sig);
 }
 #endif /* DEVELOPER */
+
+static NTSTATUS messaging_send_to_children(struct messaging_context *msg_ctx,
+                                           uint32_t msg_type, DATA_BLOB* data)
+{
+        NTSTATUS status;
+        struct smbd_parent_context *parent = am_parent;
+        struct smbd_child_pid *child;
+
+        if (parent == NULL) {
+                return NT_STATUS_INTERNAL_ERROR;
+        }
+
+        for (child = parent->children; child != NULL; child = child->next) {
+                status = messaging_send(parent->msg_ctx,
+                                        pid_to_procid(child->pid),
+                                        msg_type, data);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+        }
+        return NT_STATUS_OK;
+}
+
+static void smb_parent_send_to_children(struct messaging_context *ctx,
+                                        void* data,
+                                        uint32_t msg_type,
+                                        struct server_id srv_id,
+                                        DATA_BLOB* msg_data)
+{
+        messaging_send_to_children(ctx, msg_type, msg_data);
+}
 
 /*
@@ -274 +233 @@
                            DATA_BLOB *data)
 {
-        struct child_pid *child;
-
         debug_message(msg_ctx, private_data, MSG_DEBUG, server_id, data);
 
-        for (child = children; child != NULL; child = child->next) {
-                messaging_send_buf(msg_ctx, pid_to_procid(child->pid),
-                                   MSG_DEBUG,
-                                   data->data,
-                                   strlen((char *) data->data) + 1);
-        }
-}
-
-static void add_child_pid(pid_t pid)
-{
-        struct child_pid *child;
-
-        child = SMB_MALLOC_P(struct child_pid);
+        messaging_send_to_children(msg_ctx, MSG_DEBUG, data);
+}
+
+static void smbd_parent_id_cache_kill(struct messaging_context *msg_ctx,
+                                      void *private_data,
+                                      uint32_t msg_type,
+                                      struct server_id server_id,
+                                      DATA_BLOB* data)
+{
+        const char *msg = (data && data->data)
+                ? (const char *)data->data : "<NULL>";
+        struct id_cache_ref id;
+
+        if (!id_cache_ref_parse(msg, &id)) {
+                DEBUG(0, ("Invalid ?ID: %s\n", msg));
+                return;
+        }
+
+        id_cache_delete_from_cache(&id);
+
+        messaging_send_to_children(msg_ctx, msg_type, data);
+}
+
+static void smbd_parent_id_cache_delete(struct messaging_context *ctx,
+                                        void* data,
+                                        uint32_t msg_type,
+                                        struct server_id srv_id,
+                                        DATA_BLOB* msg_data)
+{
+        id_cache_delete_message(ctx, data, msg_type, srv_id, msg_data);
+
+        messaging_send_to_children(ctx, msg_type, msg_data);
+}
+
+#ifdef CLUSTER_SUPPORT
+static int smbd_parent_ctdb_reconfigured(
+        uint32_t src_vnn, uint32_t dst_vnn, uint64_t dst_srvid,
+        const uint8_t *msg, size_t msglen, void *private_data)
+{
+        struct messaging_context *msg_ctx = talloc_get_type_abort(
+                private_data, struct messaging_context);
+
+        DEBUG(10, ("Got %s message\n", (dst_srvid == CTDB_SRVID_RECONFIGURE)
+                   ? "cluster reconfigure" : "SAMBA_NOTIFY"));
+
+        /*
+         * Someone from the family died, validate our locks
+         */
+
+        if (am_parent) {
+                messaging_send_buf(msg_ctx, am_parent->cleanupd,
+                                   MSG_SMB_BRL_VALIDATE, NULL, 0);
+        }
+
+        return 0;
+}
+#endif
+
+static void add_child_pid(struct smbd_parent_context *parent,
+                          pid_t pid)
+{
+        struct smbd_child_pid *child;
+
+        child = talloc_zero(parent, struct smbd_child_pid);
         if (child == NULL) {
                 DEBUG(0, ("Could not add child struct -- malloc failed\n"));
@@ -296 +304 @@
         }
         child->pid = pid;
-        DLIST_ADD(children, child);
-        num_children += 1;
+        DLIST_ADD(parent->children, child);
+        parent->num_children += 1;
+}
+
+static void smb_tell_num_children(struct messaging_context *ctx, void *data,
+                                  uint32_t msg_type, struct server_id srv_id,
+                                  DATA_BLOB *msg_data)
+{
+        uint8_t buf[sizeof(uint32_t)];
+
+        if (am_parent) {
+                SIVAL(buf, 0, am_parent->num_children);
+                messaging_send_buf(ctx, srv_id, MSG_SMB_NUM_CHILDREN,
+                                   buf, sizeof(buf));
+        }
+}
+
+static void notifyd_stopped(struct tevent_req *req);
+
+static struct tevent_req *notifyd_req(struct messaging_context *msg_ctx,
+                                      struct tevent_context *ev)
+{
+        struct tevent_req *req;
+        sys_notify_watch_fn sys_notify_watch = NULL;
+        struct sys_notify_context *sys_notify_ctx = NULL;
+
+        if (lp_kernel_change_notify()) {
+
+#ifdef HAVE_INOTIFY
+                if (lp_parm_bool(-1, "notify", "inotify", true)) {
+                        sys_notify_watch = inotify_watch;
+                }
+#endif
+
+#ifdef HAVE_FAM
+                if (lp_parm_bool(-1, "notify", "fam",
+                                 (sys_notify_watch == NULL))) {
+                        sys_notify_watch = fam_watch;
+                }
+#endif
+        }
+
+        if (sys_notify_watch != NULL) {
+                sys_notify_ctx = sys_notify_context_create(msg_ctx, ev);
+                if (sys_notify_ctx == NULL) {
+                        return NULL;
+                }
+        }
+
+        req = notifyd_send(msg_ctx, ev, msg_ctx,
+                           messaging_ctdbd_connection(),
+                           sys_notify_watch, sys_notify_ctx);
+        if (req == NULL) {
+                TALLOC_FREE(sys_notify_ctx);
+                return NULL;
+        }
+        tevent_req_set_callback(req, notifyd_stopped, msg_ctx);
+
+        return req;
+}
+
+static void notifyd_stopped(struct tevent_req *req)
+{
+        int ret;
+
+        ret = notifyd_recv(req);
+        TALLOC_FREE(req);
+        DEBUG(1, ("notifyd stopped: %s\n", strerror(ret)));
+}
+
+static bool smbd_notifyd_init(struct messaging_context *msg, bool interactive)
+{
+        struct tevent_context *ev = messaging_tevent_context(msg);
+        struct tevent_req *req;
+        pid_t pid;
+        NTSTATUS status;
+
+        if (interactive) {
+                req = notifyd_req(msg, ev);
+                return (req != NULL);
+        }
+
+        pid = fork();
+        if (pid == -1) {
+                DEBUG(1, ("%s: fork failed: %s\n", __func__,
+                          strerror(errno)));
+                return false;
+        }
+
+        if (pid != 0) {
+                return true;
+        }
+
+        status = reinit_after_fork(msg, ev, true, "smbd-notifyd");
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("%s: reinit_after_fork failed: %s\n",
+                          __func__, nt_errstr(status)));
+                exit(1);
+        }
+
+        req = notifyd_req(msg, ev);
+        if (req == NULL) {
+                exit(1);
+        }
+        tevent_req_set_callback(req, notifyd_stopped, msg);
+        return tevent_req_poll(req, ev);
+}
+
+static void cleanupd_stopped(struct tevent_req *req);
+
+static bool cleanupd_init(struct messaging_context *msg, bool interactive,
+                          struct server_id *ppid)
+{
+        struct tevent_context *ev = messaging_tevent_context(msg);
+        struct server_id parent_id = messaging_server_id(msg);
+        struct tevent_req *req;
+        pid_t pid;
+        NTSTATUS status;
+        ssize_t rwret;
+        int ret;
+        bool ok;
+        char c;
+        int up_pipe[2];
+
+        if (interactive) {
+                req = smbd_cleanupd_send(msg, ev, msg, parent_id.pid);
+                *ppid = messaging_server_id(msg);
+                return (req != NULL);
+        }
+
+        ret = pipe(up_pipe);
+        if (ret == -1) {
+                DBG_WARNING("pipe failed: %s\n", strerror(errno));
+                return false;
+        }
+
+        pid = fork();
+        if (pid == -1) {
+                DBG_WARNING("fork failed: %s\n", strerror(errno));
+                close(up_pipe[0]);
+                close(up_pipe[1]);
+                return false;
+        }
+
+        if (pid != 0) {
+
+                close(up_pipe[1]);
+                rwret = sys_read(up_pipe[0], &c, 1);
+                close(up_pipe[0]);
+
+                if (rwret == -1) {
+                        DBG_WARNING("sys_read failed: %s\n", strerror(errno));
+                        return false;
+                }
+                if (rwret == 0) {
+                        DBG_WARNING("cleanupd could not start\n");
+                        return false;
+                }
+                if (c != 0) {
+                        DBG_WARNING("cleanupd returned %d\n", (int)c);
+                        return false;
+                }
+
+                DBG_DEBUG("Started cleanupd pid=%d\n", (int)pid);
+
+                if (am_parent != NULL) {
+                        add_child_pid(am_parent, pid);
+                }
+
+                *ppid = pid_to_procid(pid);
+                return true;
+        }
+
+        close(up_pipe[0]);
+
+        status = reinit_after_fork(msg, ev, true, "cleanupd");
+        if (!NT_STATUS_IS_OK(status)) {
+                DBG_WARNING("reinit_after_fork failed: %s\n",
+                            nt_errstr(status));
+                c = 1;
+                sys_write(up_pipe[1], &c, 1);
+
+                exit(1);
+        }
+
+        req = smbd_cleanupd_send(msg, ev, msg, parent_id.pid);
+        if (req == NULL) {
+                DBG_WARNING("smbd_cleanupd_send failed\n");
+                c = 2;
+                sys_write(up_pipe[1], &c, 1);
+
+                exit(1);
+        }
+
+        tevent_req_set_callback(req, cleanupd_stopped, msg);
+
+        c = 0;
+        rwret = sys_write(up_pipe[1], &c, 1);
+        close(up_pipe[1]);
+
+        if (rwret == -1) {
+                DBG_WARNING("sys_write failed: %s\n", strerror(errno));
+                exit(1);
+        }
+        if (rwret != 1) {
+                DBG_WARNING("sys_write could not write result\n");
+                exit(1);
+        }
+
+        ok = tevent_req_poll(req, ev);
+        if (!ok) {
+                DBG_WARNING("tevent_req_poll returned %s\n", strerror(errno));
+        }
+        exit(0);
+}
+
+static void cleanupd_stopped(struct tevent_req *req)
+{
+        NTSTATUS status;
+
+        status = smbd_cleanupd_recv(req);
+        DBG_WARNING("cleanupd stopped: %s\n", nt_errstr(status));
 }
 
@@ -311 +539 @@
 */
 
-static void cleanup_timeout_fn(struct event_context *event_ctx,
-                                struct timed_event *te,
+static void cleanup_timeout_fn(struct tevent_context *event_ctx,
+                                struct tevent_timer *te,
                                 struct timeval now,
                                 void *private_data)
 {
-        struct timed_event **cleanup_te = (struct timed_event **)private_data;
-
-        DEBUG(1,("Cleaning up brl and lock database after unclean shutdown\n"));
-        message_send_all(smbd_messaging_context(), MSG_SMB_UNLOCK, NULL, 0, NULL);
-        messaging_send_buf(smbd_messaging_context(), procid_self(),
-                                MSG_SMB_BRL_VALIDATE, NULL, 0);
-        /* mark the cleanup as having been done */
-        (*cleanup_te) = NULL;
-}
-
-static void remove_child_pid(pid_t pid, bool unclean_shutdown)
-{
-        struct child_pid *child;
-        static struct timed_event *cleanup_te;
-        struct server_id child_id;
-
-        child_id = procid_self(); /* Just initialize pid and potentially vnn */
-        child_id.pid = pid;
-
-        for (child = children; child != NULL; child = child->next) {
+        struct smbd_parent_context *parent =
+                talloc_get_type_abort(private_data,
+                struct smbd_parent_context);
+
+        parent->cleanup_te = NULL;
+
+        messaging_send_buf(parent->msg_ctx, parent->cleanupd,
+                           MSG_SMB_UNLOCK, NULL, 0);
+}
+
+static void remove_child_pid(struct smbd_parent_context *parent,
+                             pid_t pid,
+                             bool unclean_shutdown)
+{
+        struct smbd_child_pid *child;
+        struct iovec iov[2];
+        NTSTATUS status;
+
+        for (child = parent->children; child != NULL; child = child->next) {
                 if (child->pid == pid) {
-                        struct child_pid *tmp = child;
-                        DLIST_REMOVE(children, child);
-                        SAFE_FREE(tmp);
-                        num_children -= 1;
+                        struct smbd_child_pid *tmp = child;
+                        DLIST_REMOVE(parent->children, child);
+                        TALLOC_FREE(tmp);
+                        parent->num_children -= 1;
                         break;
                 }
@@ -350 +577 @@
                 return;
         }
+
+        if (child->pid == procid_to_pid(&parent->cleanupd)) {
+                bool ok;
+
+                DBG_WARNING("Restarting cleanupd\n");
+                ok = cleanupd_init(parent->msg_ctx, false, &parent->cleanupd);
+                if (!ok) {
+                        DBG_ERR("Failed to restart cleanupd\n");
+                }
+                return;
+        }
+
+        iov[0] = (struct iovec) { .iov_base = (uint8_t *)&pid,
+                                  .iov_len = sizeof(pid) };
+        iov[1] = (struct iovec) { .iov_base = (uint8_t *)&unclean_shutdown,
+                                  .iov_len = sizeof(bool) };
+
+        status = messaging_send_iov(parent->msg_ctx, parent->cleanupd,
+                                    MSG_SMB_NOTIFY_CLEANUP,
+                                    iov, ARRAY_SIZE(iov), NULL, 0);
+        DEBUG(10, ("messaging_send_iov returned %s\n", nt_errstr(status)));
 
         if (unclean_shutdown) {
@@ -358 +606 @@
                 DEBUG(3,(__location__ " Unclean shutdown of pid %u\n",
                         (unsigned int)pid));
-                if (!cleanup_te) {
+                if (parent->cleanup_te == NULL) {
                         /* call the cleanup timer, but not too often */
                         int cleanup_time = lp_parm_int(-1, "smbd", "cleanuptime", 20);
-                        cleanup_te = event_add_timed(smbd_event_context(), NULL,
+                        parent->cleanup_te = tevent_add_timer(parent->ev_ctx,
+                                                parent,
                                                 timeval_current_ofs(cleanup_time, 0),
                                                 cleanup_timeout_fn,
-                                                &cleanup_te);
+                                                parent);
                         DEBUG(1,("Scheduled cleanup of brl and lock database after unclean shutdown\n"));
                 }
-        }
-
-        if (!serverid_deregister(child_id)) {
-                DEBUG(1, ("Could not remove pid %d from serverid.tdb\n",
-                          (int)pid));
         }
 }
@@ -379 +623 @@
 ****************************************************************************/
 
-static bool allowable_number_of_smbd_processes(void)
+static bool allowable_number_of_smbd_processes(struct smbd_parent_context *parent)
 {
         int max_processes = lp_max_smbd_processes();
@@ -386 +630 @@
                 return True;
 
-        return num_children < max_processes;
+        return parent->num_children < max_processes;
 }
 
@@ -398 +642 @@
         pid_t pid;
         int status;
+        struct smbd_parent_context *parent =
+                talloc_get_type_abort(private_data,
+                struct smbd_parent_context);
 
         while ((pid = sys_waitpid(-1, &status, WNOHANG)) > 0) {
@@ -415 +662 @@
                         unclean_shutdown = True;
                 }
-                remove_child_pid(pid, unclean_shutdown);
-        }
-}
-
-static void smbd_setup_sig_chld_handler(void)
+                remove_child_pid(parent, pid, unclean_shutdown);
+        }
+}
+
+static void smbd_setup_sig_chld_handler(struct smbd_parent_context *parent)
 {
         struct tevent_signal *se;
 
-        se = tevent_add_signal(smbd_event_context(),
-                               smbd_event_context(),
+        se = tevent_add_signal(parent->ev_ctx,
+                               parent, /* mem_ctx */
                                SIGCHLD, 0,
                                smbd_sig_chld_handler,
-                               NULL);
+                               parent);
         if (!se) {
                 exit_server("failed to setup SIGCHLD handler");
         }
 }
-
-struct smbd_open_socket;
-
-struct smbd_parent_context {
-        bool interactive;
-
-        /* the list of listening sockets */
-        struct smbd_open_socket *sockets;
-};
-
-struct smbd_open_socket {
-        struct smbd_open_socket *prev, *next;
-        struct smbd_parent_context *parent;
-        int fd;
-        struct tevent_fd *fde;
-};
 
 static void smbd_open_socket_close_fn(struct tevent_context *ev,
@@ -465 +696 @@
         struct smbd_open_socket *s = talloc_get_type_abort(private_data,
                                      struct smbd_open_socket);
+        struct messaging_context *msg_ctx = s->parent->msg_ctx;
         struct sockaddr_storage addr;
         socklen_t in_addrlen = sizeof(addr);
         int fd;
         pid_t pid = 0;
-        uint64_t unique_id;
 
         fd = accept(s->fd, (struct sockaddr *)(void *)&addr,&in_addrlen);
-        smbd_set_server_fd(fd);
-
         if (fd == -1 && errno == EINTR)
                 return;
 
         if (fd == -1) {
-                DEBUG(0,("open_sockets_smbd: accept: %s\n",
+                DEBUG(0,("accept: %s\n",
                          strerror(errno)));
                 return;
@@ -484 +713 @@
 
         if (s->parent->interactive) {
-                smbd_process(smbd_server_conn);
+                reinit_after_fork(msg_ctx, ev, true, NULL);
+                smbd_process(ev, msg_ctx, fd, true);
                 exit_server_cleanly("end of interactive mode");
                 return;
         }
 
-        if (!allowable_number_of_smbd_processes()) {
+        if (!allowable_number_of_smbd_processes(s->parent)) {
                 close(fd);
-                smbd_set_server_fd(-1);
                 return;
         }
 
-        /*
-         * Generate a unique id in the parent process so that we use
-         * the global random state in the parent.
-         */
-        unique_id = serverid_get_random_unique_id();
-
-        pid = sys_fork();
+        pid = fork();
         if (pid == 0) {
                 NTSTATUS status = NT_STATUS_OK;
-
-                /* Child code ... */
-                am_parent = 0;
-
-                set_my_unique_id(unique_id);
-
-                /* Stop zombies, the parent explicitly handles
-                 * them, counting worker smbds. */
-                CatchChild();
-
-                /* close our standard file
-                   descriptors */
-                close_low_fds(False);
 
                 /*
@@ -525 +735 @@
                 s = NULL;
 
-                status = reinit_after_fork(smbd_messaging_context(),
-                                           smbd_event_context(), procid_self(),
-                                           true);
+                /* Stop zombies, the parent explicitly handles
+                 * them, counting worker smbds. */
+                CatchChild();
+
+                status = smbd_reinit_after_fork(msg_ctx, ev, true, NULL);
                 if (!NT_STATUS_IS_OK(status)) {
                         if (NT_STATUS_EQUAL(status,
@@ -548 +760 @@
                 }
 
-                smbd_setup_sig_term_handler();
-                smbd_setup_sig_hup_handler(server_event_context(),
-                                           server_messaging_context());
-
-                if (!serverid_register(procid_self(),
-                                       FLAG_MSG_GENERAL|FLAG_MSG_SMBD
-                                       |FLAG_MSG_DBWRAP
-                                       |FLAG_MSG_PRINT_GENERAL)) {
-                        exit_server_cleanly("Could not register myself in "
-                                            "serverid.tdb");
-                }
-
-                smbd_process(smbd_server_conn);
+                smbd_process(ev, msg_ctx, fd, false);
          exit:
                 exit_server_cleanly("end of child");
@@ -567 +767 @@
 
         if (pid < 0) {
-                DEBUG(0,("smbd_accept_connection: sys_fork() failed: %s\n",
+                DEBUG(0,("smbd_accept_connection: fork() failed: %s\n",
                          strerror(errno)));
         }
@@ -582 +782 @@
         */
 
-        smbd_set_server_fd(-1);
-
         if (pid != 0) {
-                add_child_pid(pid);
+                add_child_pid(s->parent, pid);
         }
 
@@ -606 +804 @@
 
 static bool smbd_open_one_socket(struct smbd_parent_context *parent,
+                                 struct tevent_context *ev_ctx,
                                  const struct sockaddr_storage *ifss,
                                  uint16_t port)
@@ -623 +822 @@
                                true);
         if (s->fd == -1) {
-                DEBUG(0,("smbd_open_once_socket: open_socket_in: "
+                DEBUG(0,("smbd_open_one_socket: open_socket_in: "
                         "%s\n", strerror(errno)));
                 TALLOC_FREE(s);
@@ -641 +840 @@
 
         if (listen(s->fd, SMBD_LISTEN_BACKLOG) == -1) {
-                DEBUG(0,("open_sockets_smbd: listen: "
+                DEBUG(0,("smbd_open_one_socket: listen: "
                         "%s\n", strerror(errno)));
                         close(s->fd);
@@ -648 +847 @@
         }
 
-        s->fde = tevent_add_fd(smbd_event_context(),
+        s->fde = tevent_add_fd(ev_ctx,
                                s,
                                s->fd, TEVENT_FD_READ,
@@ -654 +853 @@
                                s);
         if (!s->fde) {
-                DEBUG(0,("open_sockets_smbd: "
+                DEBUG(0,("smbd_open_one_socket: "
                          "tevent_add_fd: %s\n",
                          strerror(errno)));
@@ -663 +862 @@
         tevent_fd_set_close_fn(s->fde, smbd_open_socket_close_fn);
 
-        DLIST_ADD_END(parent->sockets, s, struct smbd_open_socket *);
+        DLIST_ADD_END(parent->sockets, s);
 
         return true;
@@ -673 +872 @@
 
 static bool open_sockets_smbd(struct smbd_parent_context *parent,
+                              struct tevent_context *ev_ctx,
                               struct messaging_context *msg_ctx,
                               const char *smb_ports)
 {
         int num_interfaces = iface_count();
-        int i;
-        char *ports;
-        char *tok;
-        const char *ptr;
+        int i,j;
+        const char **ports;
         unsigned dns_port = 0;
 
@@ -688 +886 @@
 
         /* Stop zombies */
-        smbd_setup_sig_chld_handler();
+        smbd_setup_sig_chld_handler(parent);
+
+        ports = lp_smb_ports();
 
         /* use a reasonable default set of ports - listing on 445 and 139 */
-        if (!smb_ports) {
-                ports = lp_smb_ports();
-                if (!ports || !*ports) {
-                        ports = talloc_strdup(talloc_tos(), SMB_PORTS);
-                } else {
-                        ports = talloc_strdup(talloc_tos(), ports);
-                }
-        } else {
-                ports = talloc_strdup(talloc_tos(), smb_ports);
-        }
-
-        for (ptr = ports;
-             next_token_talloc(talloc_tos(),&ptr, &tok, " \t,");) {
-                unsigned port = atoi(tok);
+        if (smb_ports) {
+                char **l;
+                l = str_list_make_v3(talloc_tos(), smb_ports, NULL);
+                ports = discard_const_p(const char *, l);
+        }
+
+        for (j = 0; ports && ports[j]; j++) {
+                unsigned port = atoi(ports[j]);
 
                 if (port == 0 || port > 0xffff) {
@@ -723 +917 @@
                         const struct sockaddr_storage *ifss =
                                         iface_n_sockaddr_storage(i);
-
                         if (ifss == NULL) {
                                 DEBUG(0,("open_sockets_smbd: "
@@ -731 +924 @@
                         }
 
-                        for (ptr=ports;
-                             next_token_talloc(talloc_tos(),&ptr, &tok, " \t,");) {
-                                unsigned port = atoi(tok);
+                        for (j = 0; ports && ports[j]; j++) {
+                                unsigned port = atoi(ports[j]);
 
                                 /* Keep the first port for mDNS service
@@ -742 +934 @@
                                 }
 
-                                if (!smbd_open_one_socket(parent, ifss, port)) {
+                                if (!smbd_open_one_socket(parent,
+                                                          ev_ctx,
+                                                          ifss,
+                                                          port)) {
                                         return false;
                                 }
@@ -751 +946 @@
                    from anywhere. */
 
-                const char *sock_addr = lp_socket_address();
+                const char *sock_addr;
                 char *sock_tok;
                 const char *sock_ptr;
 
-                if (strequal(sock_addr, "0.0.0.0") ||
-                    strequal(sock_addr, "::")) {
 #if HAVE_IPV6
-                        sock_addr = "::,0.0.0.0";
+                sock_addr = "::,0.0.0.0";
 #else
-                        sock_addr = "0.0.0.0";
+                sock_addr = "0.0.0.0";
 #endif
-                }
 
                 for (sock_ptr=sock_addr;
                      next_token_talloc(talloc_tos(), &sock_ptr, &sock_tok, " \t,"); ) {
-                        for (ptr=ports; next_token_talloc(talloc_tos(), &ptr, &tok, " \t,"); ) {
+                        for (j = 0; ports && ports[j]; j++) {
                                 struct sockaddr_storage ss;
-                                unsigned port = atoi(tok);
+                                unsigned port = atoi(ports[j]);
 
                                 /* Keep the first port for mDNS service
@@ -783 +975 @@
                                 }
 
-                                if (!smbd_open_one_socket(parent, &ss, port)) {
-                                        return false;
-                                }
+                                /*
+                                 * If we fail to open any sockets
+                                 * in this loop the parent-sockets == NULL
+                                 * case below will prevent us from starting.
+                                 */
+
+                                (void)smbd_open_one_socket(parent,
+                                                  ev_ctx,
+                                                  &ss,
+                                                  port);
                         }
                 }
@@ -802 +1001 @@
            includes checking to see that smbd is listening. */
 
-        if (!serverid_register(procid_self(),
+        if (!serverid_register(messaging_server_id(msg_ctx),
                                FLAG_MSG_GENERAL|FLAG_MSG_SMBD
+                               |FLAG_MSG_PRINT_GENERAL
                                |FLAG_MSG_DBWRAP)) {
                 DEBUG(0, ("open_sockets_smbd: Failed to register "
@@ -812 +1012 @@
         /* Listen to messages */
 
-        messaging_register(msg_ctx, NULL, MSG_SMB_SAM_SYNC, msg_sam_sync);
         messaging_register(msg_ctx, NULL, MSG_SHUTDOWN, msg_exit_server);
-        messaging_register(msg_ctx, NULL, MSG_SMB_FILE_RENAME,
-                           msg_file_was_renamed);
-        messaging_register(msg_ctx, server_event_context(), MSG_SMB_CONF_UPDATED,
-                           smb_conf_updated);
+        messaging_register(msg_ctx, ev_ctx, MSG_SMB_CONF_UPDATED,
+                           smbd_parent_conf_updated);
         messaging_register(msg_ctx, NULL, MSG_SMB_STAT_CACHE_DELETE,
                            smb_stat_cache_delete);
         messaging_register(msg_ctx, NULL, MSG_DEBUG, smbd_msg_debug);
-        brl_register_msgs(msg_ctx);
-
-        msg_idmap_register_msgs(msg_ctx);
+        messaging_register(msg_ctx, NULL, MSG_SMB_FORCE_TDIS,
+                           smb_parent_send_to_children);
+        messaging_register(msg_ctx, NULL, MSG_SMB_KILL_CLIENT_IP,
+                           smb_parent_send_to_children);
+        messaging_register(msg_ctx, NULL, MSG_SMB_TELL_NUM_CHILDREN,
+                           smb_tell_num_children);
+
+        messaging_register(msg_ctx, NULL,
+                           ID_CACHE_DELETE, smbd_parent_id_cache_delete);
+        messaging_register(msg_ctx, NULL,
+                           ID_CACHE_KILL, smbd_parent_id_cache_kill);
 
 #ifdef CLUSTER_SUPPORT
         if (lp_clustering()) {
-                ctdbd_register_reconfigure(messaging_ctdbd_connection());
+                struct ctdbd_connection *conn = messaging_ctdbd_connection();
+
+                register_with_ctdbd(conn, CTDB_SRVID_RECONFIGURE,
+                                    smbd_parent_ctdb_reconfigured, msg_ctx);
+                register_with_ctdbd(conn, CTDB_SRVID_SAMBA_NOTIFY,
+                                    smbd_parent_ctdb_reconfigured, msg_ctx);
         }
 #endif
@@ -838 +1048 @@
         if (lp_multicast_dns_register() && (dns_port != 0)) {
 #ifdef WITH_DNSSD_SUPPORT
-                smbd_setup_mdns_registration(smbd_event_context(),
+                smbd_setup_mdns_registration(ev_ctx,
                                              parent, dns_port);
 #endif
@@ -844 +1054 @@
                 void *avahi_conn;
 
-                avahi_conn = avahi_start_register(
-                        smbd_event_context(), smbd_event_context(), dns_port);
+                avahi_conn = avahi_start_register(ev_ctx,
+                                                  ev_ctx,
+                                                  dns_port);
                 if (avahi_conn == NULL) {
                         DEBUG(10, ("avahi_start_register failed\n"));
@@ -855 +1066 @@
 }
 
-static void smbd_parent_loop(struct smbd_parent_context *parent)
-{
+
+/*
+  handle stdin becoming readable when we are in --foreground mode
+ */
+static void smbd_stdin_handler(struct tevent_context *ev,
+                               struct tevent_fd *fde,
+                               uint16_t flags,
+                               void *private_data)
+{
+        char c;
+        if (read(0, &c, 1) != 1) {
+                /* we have reached EOF on stdin, which means the
+                   parent has exited. Shutdown the server */
+                exit_server_cleanly("EOF on stdin");
+        }
+}
+
+struct smbd_parent_tevent_trace_state {
+        TALLOC_CTX *frame;
+};
+
+static void smbd_parent_tevent_trace_callback(enum tevent_trace_point point,
+                                              void *private_data)
+{
+        struct smbd_parent_tevent_trace_state *state =
+                (struct smbd_parent_tevent_trace_state *)private_data;
+
+        switch (point) {
+        case TEVENT_TRACE_BEFORE_WAIT:
+                break;
+        case TEVENT_TRACE_AFTER_WAIT:
+                break;
+        case TEVENT_TRACE_BEFORE_LOOP_ONCE:
+                TALLOC_FREE(state->frame);
+                state->frame = talloc_stackframe();
+                break;
+        case TEVENT_TRACE_AFTER_LOOP_ONCE:
+                TALLOC_FREE(state->frame);
+                break;
+        }
+
+        errno = 0;
+}
+
+static void smbd_parent_loop(struct tevent_context *ev_ctx,
+                             struct smbd_parent_context *parent)
+{
+        struct smbd_parent_tevent_trace_state trace_state = {
+                .frame = NULL,
+        };
+        int ret = 0;
+
+        tevent_set_trace_callback(ev_ctx, smbd_parent_tevent_trace_callback,
+                                  &trace_state);
+
         /* now accept incoming connections - forking a new process
            for each incoming connection */
         DEBUG(2,("waiting for connections\n"));
-        while (1) {
-                int ret;
-                TALLOC_CTX *frame = talloc_stackframe();
-
-                ret = tevent_loop_once(smbd_event_context());
-                if (ret != 0) {
-                        exit_server_cleanly("tevent_loop_once() error");
-                }
-
-                TALLOC_FREE(frame);
-        } /* end while 1 */
+
+        ret = tevent_loop_wait(ev_ctx);
+        if (ret != 0) {
+                DEBUG(0, ("tevent_loop_wait failed: %d, %s, exiting\n",
+                          ret, strerror(errno)));
+        }
+
+        TALLOC_FREE(trace_state.frame);
 
 /* NOTREACHED   return True; */
@@ -894 +1155 @@
 
         return True;
+}
+
+static void smbd_parent_sig_term_handler(struct tevent_context *ev,
+                                         struct tevent_signal *se,
+                                         int signum,
+                                         int count,
+                                         void *siginfo,
+                                         void *private_data)
+{
+        exit_server_cleanly("termination signal");
+}
+
+static void smbd_parent_sig_hup_handler(struct tevent_context *ev,
+                                        struct tevent_signal *se,
+                                        int signum,
+                                        int count,
+                                        void *siginfo,
+                                        void *private_data)
+{
+        struct smbd_parent_context *parent =
+                talloc_get_type_abort(private_data,
+                struct smbd_parent_context);
+
+        change_to_root_user();
+        DEBUG(1,("parent: Reloading services after SIGHUP\n"));
+        reload_services(NULL, NULL, false);
+
+        printing_subsystem_update(parent->ev_ctx, parent->msg_ctx, true);
 }
 
@@ -937 +1226 @@
         {"profiling-level", 'P', POPT_ARG_STRING, &profile_level, 0, "Set profiling level","PROFILE_LEVEL"},
         POPT_COMMON_SAMBA
-        POPT_COMMON_DYNCONFIG
         POPT_TABLEEND
         };
@@ -943 +1231 @@
         TALLOC_CTX *frame;
         NTSTATUS status;
+        struct tevent_context *ev_ctx;
+        struct messaging_context *msg_ctx;
+        struct server_id server_id;
+        struct tevent_signal *se;
+        int profiling_level;
+        char *np_dir = NULL;
+        static const struct smbd_shim smbd_shim_fns =
+        {
+                .cancel_pending_lock_requests_by_fid = smbd_cancel_pending_lock_requests_by_fid,
+                .send_stat_cache_delete_message = smbd_send_stat_cache_delete_message,
+                .change_to_root_user = smbd_change_to_root_user,
+                .become_authenticated_pipe_user = smbd_become_authenticated_pipe_user,
+                .unbecome_authenticated_pipe_user = smbd_unbecome_authenticated_pipe_user,
+
+                .contend_level2_oplocks_begin = smbd_contend_level2_oplocks_begin,
+                .contend_level2_oplocks_end = smbd_contend_level2_oplocks_end,
+
+                .become_root = smbd_become_root,
+                .unbecome_root = smbd_unbecome_root,
+
+                .exit_server = smbd_exit_server,
+                .exit_server_cleanly = smbd_exit_server_cleanly,
+        };
 
         /*
@@ -950 +1261 @@
         frame = talloc_stackframe();
 
-        load_case_tables();
-
-        /* Initialize the event context, it will panic on error */
-        smbd_event_context();
+        setup_logging(argv[0], DEBUG_DEFAULT_STDOUT);
+
+        smb_init_locale();
+
+        set_smbd_shim(&smbd_shim_fns);
 
         smbd_init_globals();
@@ -1025 +1337 @@
         }
 
-        /* we want to re-seed early to prevent time delays causing
-           client problems at a later date. (tridge) */
+        /*
+         * We want to die early if we can't open /dev/urandom
+         */
         generate_random_buffer(NULL, 0);
 
@@ -1037 +1350 @@
         gain_root_group_privilege();
 
-        fault_setup((void (*)(void *))exit_server_fault);
-        dump_core_setup("smbd");
+        fault_setup();
+        dump_core_setup("smbd", lp_logfile(talloc_tos()));
 
         /* we are never interested in SIGPIPE */
@@ -1079 +1392 @@
         build_options(False);
 
-        if (sizeof(uint16) < 2 || sizeof(uint32) < 4) {
+        if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4) {
                 DEBUG(0,("ERROR: Samba is not configured correctly for the word size on your machine\n"));
                 exit(1);
@@ -1085 +1398 @@
 
         if (!lp_load_initial_only(get_dyn_CONFIGFILE())) {
-                DEBUG(0, ("error opening config file\n"));
+                DEBUG(0, ("error opening config file '%s'\n", get_dyn_CONFIGFILE()));
+                exit(1);
+        }
+
+        if (!cluster_probe_ok()) {
                 exit(1);
         }
@@ -1092 +1409 @@
         init_sec_ctx();
 
-        if (smbd_messaging_context() == NULL)
+        /*
+         * Initialize the event context. The event context needs to be
+         * initialized before the messaging context, cause the messaging
+         * context holds an event context.
+         * FIXME: This should be s3_tevent_context_init()
+         */
+        ev_ctx = server_event_context();
+        if (ev_ctx == NULL) {
                 exit(1);
+        }
+
+        /*
+         * Init the messaging context
+         * FIXME: This should only call messaging_init()
+         */
+        msg_ctx = server_messaging_context();
+        if (msg_ctx == NULL) {
+                exit(1);
+        }
 
         /*
@@ -1099 +1433 @@
          * server info and rpc services set up. It will be called later.
          */
-        if (!reload_services(smbd_messaging_context(), -1, False)) {
+        if (!reload_services(NULL, NULL, false)) {
                 exit(1);
         }
 
+        if (lp_server_role() == ROLE_ACTIVE_DIRECTORY_DC
+            && !lp_parm_bool(-1, "server role check", "inhibit", false)) {
+                DEBUG(0, ("server role = 'active directory domain controller' not compatible with running smbd standalone. \n"));
+                DEBUGADD(0, ("You should start 'samba' instead, and it will control starting smbd if required\n"));
+                exit(1);
+        }
+
         /* ...NOTE... Log files are working from this point! */
 
@@ -1109 +1450 @@
         init_structs();
 
-#ifdef WITH_PROFILE
-        if (!profile_setup(smbd_messaging_context(), False)) {
+        if (!profile_setup(msg_ctx, False)) {
                 DEBUG(0,("ERROR: failed to setup profiling\n"));
                 return -1;
         }
+
         if (profile_level != NULL) {
-                int pl = atoi(profile_level);
-                struct server_id src;
-
-                DEBUG(1, ("setting profiling level: %s\n",profile_level));
-                src.pid = getpid();
-                set_profile_level(pl, src);
-        }
-#endif
+                profiling_level = atoi(profile_level);
+        } else {
+                profiling_level = lp_smbd_profiling_level();
+        }
+        set_profile_level(profiling_level, messaging_server_id(msg_ctx));
 
         if (!is_daemon && !is_a_socket(0)) {
-                if (!interactive)
-                        DEBUG(0,("standard input is not a socket, assuming -D option\n"));
+                if (!interactive) {
+                        DEBUG(3, ("Standard input is not a socket, "
+                                  "assuming -D option\n"));
+                }
 
                 /*
@@ -1137 +1477 @@
 
         if (is_daemon && !interactive) {
-                DEBUG( 3, ( "Becoming a daemon.\n" ) );
+                DEBUG(3, ("Becoming a daemon.\n"));
                 become_daemon(Fork, no_process_group, log_stdout);
         }
-
-        set_my_unique_id(serverid_get_random_unique_id());
 
 #if HAVE_SETPGID
@@ -1152 +1490 @@
 #endif
 
-        if (!directory_exist(lp_lockdir()))
-                mkdir(lp_lockdir(), 0755);
+        if (!directory_exist(lp_lock_directory()))
+                mkdir(lp_lock_directory(), 0755);
+
+        if (!directory_exist(lp_pid_directory()))
+                mkdir(lp_pid_directory(), 0755);
 
         if (is_daemon)
-                pidfile_create("smbd");
-
-        status = reinit_after_fork(smbd_messaging_context(),
-                                   smbd_event_context(),
-                                   procid_self(), false);
+                pidfile_create(lp_pid_directory(), "smbd");
+
+        status = reinit_after_fork(msg_ctx, ev_ctx, false, NULL);
         if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0,("reinit_after_fork() failed\n"));
-                exit(1);
-        }
-
-        smbd_server_conn->msg_ctx = smbd_messaging_context();
-
-        smbd_setup_sig_term_handler();
-        smbd_setup_sig_hup_handler(smbd_event_context(),
-                                   smbd_server_conn->msg_ctx);
+                exit_daemon("reinit_after_fork() failed", map_errno_from_nt_status(status));
+        }
+
+        if (!interactive) {
+                /*
+                 * Do not initialize the parent-child-pipe before becoming a
+                 * daemon: this is used to detect a died parent in the child
+                 * process.
+                 */
+                status = init_before_fork();
+                if (!NT_STATUS_IS_OK(status)) {
+                        exit_daemon(nt_errstr(status), map_errno_from_nt_status(status));
+                }
+        }
+
+        parent = talloc_zero(ev_ctx, struct smbd_parent_context);
+        if (!parent) {
+                exit_server("talloc(struct smbd_parent_context) failed");
+        }
+        parent->interactive = interactive;
+        parent->ev_ctx = ev_ctx;
+        parent->msg_ctx = msg_ctx;
+        am_parent = parent;
+
+        se = tevent_add_signal(parent->ev_ctx,
+                               parent,
+                               SIGTERM, 0,
+                               smbd_parent_sig_term_handler,
+                               parent);
+        if (!se) {
+                exit_server("failed to setup SIGTERM handler");
+        }
+        se = tevent_add_signal(parent->ev_ctx,
+                               parent,
+                               SIGHUP, 0,
+                               smbd_parent_sig_hup_handler,
+                               parent);
+        if (!se) {
+                exit_server("failed to setup SIGHUP handler");
+        }
 
         /* Setup all the TDB's - including CLEAR_IF_FIRST tdb's. */
 
         if (smbd_memcache() == NULL) {
-                exit(1);
+                exit_daemon("no memcache available", EACCES);
         }
 
@@ -1183 +1553 @@
            to ensure that we fetch from ldap before we make a domain sid up */
 
-        if(!initialize_password_db(False, smbd_event_context()))
+        if(!initialize_password_db(false, ev_ctx))
                 exit(1);
 
         if (!secrets_init()) {
-                DEBUG(0, ("ERROR: smbd can not open secrets.tdb\n"));
+                exit_daemon("smbd can not open secrets.tdb", EACCES);
+        }
+
+        if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
+                struct loadparm_context *lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
+                if (!open_schannel_session_store(NULL, lp_ctx)) {
+                        exit_daemon("ERROR: Samba cannot open schannel store for secured NETLOGON operations.", EACCES);
+                }
+                TALLOC_FREE(lp_ctx);
+        }
+
+        if(!get_global_sam_sid()) {
+                exit_daemon("Samba cannot create a SAM SID", EACCES);
+        }
+
+        server_id = messaging_server_id(msg_ctx);
+        status = smbXsrv_version_global_init(&server_id);
+        if (!NT_STATUS_IS_OK(status)) {
+                exit_daemon("Samba cannot init server context", EACCES);
+        }
+
+        status = smbXsrv_session_global_init();
+        if (!NT_STATUS_IS_OK(status)) {
+                exit_daemon("Samba cannot init session context", EACCES);
+        }
+
+        status = smbXsrv_tcon_global_init();
+        if (!NT_STATUS_IS_OK(status)) {
+                exit_daemon("Samba cannot init tcon context", EACCES);
+        }
+
+        if (!locking_init())
+                exit_daemon("Samba cannot init locking", EACCES);
+
+        if (!leases_db_init(false)) {
+                exit_daemon("Samba cannot init leases", EACCES);
+        }
+
+        if (!smbd_notifyd_init(msg_ctx, interactive)) {
+                exit_daemon("Samba cannot init notification", EACCES);
+        }
+
+        if (!cleanupd_init(msg_ctx, interactive, &parent->cleanupd)) {
+                exit_daemon("Samba cannot init the cleanupd", EACCES);
+        }
+
+        if (!messaging_parent_dgm_cleanup_init(msg_ctx)) {
                 exit(1);
         }
 
-        if (lp_server_role() == ROLE_DOMAIN_BDC || lp_server_role() == ROLE_DOMAIN_PDC) {
-                if (!open_schannel_session_store(NULL, lp_private_dir())) {
-                        DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
-                        exit(1);
-                }
-        }
-
-        if(!get_global_sam_sid()) {
-                DEBUG(0,("ERROR: Samba cannot create a SAM SID.\n"));
-                exit(1);
-        }
-
-        if (!sessionid_init()) {
-                exit(1);
-        }
-
-        if (!connections_init(True))
-                exit(1);
-
-        if (!locking_init())
-                exit(1);
-
-        if (!messaging_tdb_parent_init(smbd_event_context())) {
-                exit(1);
-        }
-
-        if (!notify_internal_parent_init(smbd_event_context())) {
-                exit(1);
-        }
-
-        if (!serverid_parent_init(smbd_event_context())) {
-                exit(1);
-        }
-
-        if (!printer_list_parent_init()) {
-                exit(1);
+        if (!smbd_scavenger_init(NULL, msg_ctx, ev_ctx)) {
+                exit_daemon("Samba cannot init scavenging", EACCES);
+        }
+
+        if (!serverid_parent_init(ev_ctx)) {
+                exit_daemon("Samba cannot init server id", EACCES);
         }
 
         if (!W_ERROR_IS_OK(registry_init_full()))
-                exit(1);
+                exit_daemon("Samba cannot init registry", EACCES);
 
         /* Open the share_info.tdb here, so we don't have to open
@@ -1237 +1623 @@
            fds used. */
         if (!share_info_db_init()) {
-                DEBUG(0,("ERROR: failed to load share info db.\n"));
-                exit(1);
-        }
-
-        status = init_system_info();
+                exit_daemon("ERROR: failed to load share info db.", EACCES);
+        }
+
+        status = init_system_session_info();
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1, ("ERROR: failed to setup system user info: %s.\n",
@@ -1253 +1638 @@
         }
 
-        if (!file_init(smbd_server_conn)) {
-                DEBUG(0, ("ERROR: file_init failed\n"));
+        if (!file_init_global()) {
+                DEBUG(0, ("ERROR: file_init_global() failed\n"));
                 return -1;
         }
+        status = smbXsrv_open_global_init();
+        if (!NT_STATUS_IS_OK(status)) {
+                exit_daemon("Samba cannot init global open", map_errno_from_nt_status(status));
+        }
+
+        /* This MUST be done before start_epmd() because otherwise
+         * start_epmd() forks and races against dcesrv_ep_setup() to
+         * call directory_create_or_exist() */
+        if (!directory_create_or_exist(lp_ncalrpc_dir(), 0755)) {
+                DEBUG(0, ("Failed to create pipe directory %s - %s\n",
+                          lp_ncalrpc_dir(), strerror(errno)));
+                return -1;
+        }
+
+        np_dir = talloc_asprintf(talloc_tos(), "%s/np", lp_ncalrpc_dir());
+        if (!np_dir) {
+                DEBUG(0, ("%s: Out of memory\n", __location__));
+                return -1;
+        }
+
+        if (!directory_create_or_exist_strict(np_dir, geteuid(), 0700)) {
+                DEBUG(0, ("Failed to create pipe directory %s - %s\n",
+                          np_dir, strerror(errno)));
+                return -1;
+        }
 
         if (is_daemon && !interactive) {
-                const char *rpcsrv_type;
-
-                rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
-                                                   "rpc_server", "epmapper",
-                                                   "none");
-                if (StrCaseCmp(rpcsrv_type, "daemon") == 0) {
-                        start_epmd(smbd_event_context(),
-                                   smbd_server_conn->msg_ctx);
-                }
-        }
-
-        if (!dcesrv_ep_setup(smbd_event_context(), smbd_server_conn->msg_ctx)) {
-                exit(1);
-        }
-
-        /*
-         * The print backend init also migrates the printing tdb's,
-         * this requires a winreg pipe.
-         */
-        if (!print_backend_init(smbd_messaging_context()))
-                exit(1);
-
-        /* only start the background queue daemon if we are 
-           running as a daemon -- bad things will happen if
-           smbd is launched via inetd and we fork a copy of 
-           ourselves here */
-
-        if (is_daemon && !interactive
-            && lp_parm_bool(-1, "smbd", "backgroundqueue", true)) {
-                /* background queue is responsible for printcap cache updates */
-                messaging_register(smbd_server_conn->msg_ctx,
-                                   smbd_event_context(),
-                                   MSG_PRINTER_PCAP, smb_pcap_updated);
-                start_background_queue(server_event_context(),
-                                       smbd_server_conn->msg_ctx);
-        } else {
-                DEBUG(3, ("running without background printer process, dynamic "
-                          "printer updates disabled\n"));
-                /* Publish nt printers, this requires a working winreg pipe */
-                pcap_cache_reload(server_event_context(),
-                                  smbd_messaging_context(),
-                                  &reload_printers_full);
-        }
-
-        if (is_daemon && !_lp_disable_spoolss()) {
-                const char *rpcsrv_type;
-
-                /* start spoolss daemon */
-                /* start as a separate daemon only if enabled */
-                rpcsrv_type = lp_parm_const_string(GLOBAL_SECTION_SNUM,
-                                                   "rpc_server", "spoolss",
-                                                   "embedded");
-                if (StrCaseCmp(rpcsrv_type, "daemon") == 0) {
-                        start_spoolssd(smbd_event_context(),
-                                       smbd_messaging_context());
+                if (rpc_epmapper_daemon() == RPC_DAEMON_FORK) {
+                        start_epmd(ev_ctx, msg_ctx);
+                }
+        }
+
+        if (!dcesrv_ep_setup(ev_ctx, msg_ctx)) {
+                exit_daemon("Samba cannot setup ep pipe", EACCES);
+        }
+
+        if (is_daemon && !interactive) {
+                daemon_ready("smbd");
+        }
+
+        /* only start other daemons if we are running as a daemon
+         * -- bad things will happen if smbd is launched via inetd
+         *  and we fork a copy of ourselves here */
+        if (is_daemon && !interactive) {
+
+                if (rpc_lsasd_daemon() == RPC_DAEMON_FORK) {
+                        start_lsasd(ev_ctx, msg_ctx);
+                }
+
+                if (rpc_fss_daemon() == RPC_DAEMON_FORK) {
+                        start_fssd(ev_ctx, msg_ctx);
+                }
+
+                if (!lp__disable_spoolss() &&
+                    (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
+                        bool bgq = lp_parm_bool(-1, "smbd", "backgroundqueue", true);
+
+                        if (!printing_subsystem_init(ev_ctx, msg_ctx, true, bgq)) {
+                                exit_daemon("Samba failed to init printing subsystem", EACCES);
+                        }
+                }
+
+#ifdef WITH_SPOTLIGHT
+                if ((rpc_mdssvc_mode() == RPC_SERVICE_MODE_EXTERNAL) &&
+                    (rpc_mdssd_daemon() == RPC_DAEMON_FORK)) {
+                        start_mdssd(ev_ctx, msg_ctx);
+                }
+#endif
+        } else if (!lp__disable_spoolss() &&
+                   (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
+                if (!printing_subsystem_init(ev_ctx, msg_ctx, false, false)) {
+                        exit(1);
                 }
         }
 
         if (!is_daemon) {
+                int sock;
+
                 /* inetd mode */
                 TALLOC_FREE(frame);
@@ -1324 +1726 @@
                 /* We will abort gracefully when the client or remote system
                    goes away */
-                smbd_set_server_fd(dup(0));
-
-                /* close our standard file descriptors */
-                close_low_fds(False); /* Don't close stderr */
+                sock = dup(0);
+
+                /* close stdin, stdout (if not logging to it), but not stderr */
+                close_low_fds(true, !debug_get_output_is_stdout(), false);
 
 #ifdef HAVE_ATEXIT
@@ -1334 +1736 @@
 
                 /* Stop zombies */
-                smbd_setup_sig_chld_handler();
-
-                smbd_process(smbd_server_conn);
+                smbd_setup_sig_chld_handler(parent);
+
+                smbd_process(ev_ctx, msg_ctx, sock, true);
 
                 exit_server_cleanly(NULL);
@@ -1342 +1744 @@
         }
 
-        parent = talloc_zero(smbd_event_context(), struct smbd_parent_context);
-        if (!parent) {
-                exit_server("talloc(struct smbd_parent_context) failed");
-        }
-        parent->interactive = interactive;
-
-        if (!open_sockets_smbd(parent, smbd_messaging_context(), ports))
+        if (!open_sockets_smbd(parent, ev_ctx, msg_ctx, ports))
                 exit_server("open_sockets_smbd() failed");
+
+        /* do a printer update now that all messaging has been set up,
+         * before we allow clients to start connecting */
+        if (!lp__disable_spoolss() &&
+            (rpc_spoolss_daemon() != RPC_DAEMON_DISABLED)) {
+                printing_subsystem_update(ev_ctx, msg_ctx, false);
+        }
 
         TALLOC_FREE(frame);
@@ -1355 +1758 @@
         frame = talloc_stackframe();
 
-        smbd_parent_loop(parent);
+        if (!Fork) {
+                /* if we are running in the foreground then look for
+                   EOF on stdin, and exit if it happens. This allows
+                   us to die if the parent process dies
+                   Only do this on a pipe or socket, no other device.
+                */
+                struct stat st;
+                if (fstat(0, &st) != 0) {
+                        return false;
+                }
+                if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
+                        tevent_add_fd(ev_ctx,
+                                        parent,
+                                        0,
+                                        TEVENT_FD_READ,
+                                        smbd_stdin_handler,
+                                        NULL);
+                }
+        }
+
+        smbd_parent_loop(ev_ctx, parent);
 
         exit_server_cleanly(NULL);