Changeset 988 for vendor/current/source4/smbd

Timestamp:

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

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source4/smbd

Files:

• pidfile.c (deleted)
• process_model.c (modified) (2 diffs)
• process_onefork.c (deleted)
• process_prefork.c (deleted)
• process_single.c (modified) (4 diffs)
• process_standard.c (modified) (13 diffs)
• process_thread.c (deleted)
• samba.8.xml (deleted)
• server.c (modified) (14 diffs)
• service.c (modified) (1 diff)
• service_named_pipe.c (modified) (2 diffs)
• service_stream.c (modified) (12 diffs)
• service_stream.h (modified) (2 diffs)
• service_task.c (modified) (3 diffs)
• service_task.h (modified) (1 diff)
• wscript_build (modified) (2 diffs)

vendor/current/source4/smbd/process_model.c

@@ -22 +22 @@
 #include "smbd/process_model.h"
 #include "param/param.h"
+#include "lib/util/samba_modules.h"
 
 /* the list of currently registered process models */
@@ -112 +113 @@
         initialised = true;
 
-        shared_init = load_samba_modules(NULL, lp_ctx, "process_model");
+        shared_init = load_samba_modules(NULL, "process_model");
         
         run_init_functions(static_init);

vendor/current/source4/smbd/process_single.c

@@ -27 +27 @@
 #include "cluster/cluster.h"
 
+NTSTATUS process_model_single_init(void);
+
 /*
   called when the process model is selected
@@ -48 +50 @@
         NTSTATUS status;
         struct socket_context *connected_socket;
+        pid_t pid = getpid();
 
         /* accept an incoming connection. */
@@ -70 +73 @@
         talloc_steal(private_data, connected_socket);
 
-        /* The cluster_id(0, fd) cannot collide with the incrementing
-         * task below, as the first component is 0, not 1 */
+        /*
+         * We use the PID so we cannot collide in with cluster ids
+         * generated in other single mode tasks, and, and won't
+         * collide with PIDs from process model standard because a the
+         * combination of pid/fd should be unique system-wide
+         */
         new_conn(ev, lp_ctx, connected_socket,
-                 cluster_id(0, socket_get_fd(connected_socket)), private_data);
+                 cluster_id(pid, socket_get_fd(connected_socket)), private_data);
 }
 
@@ -85 +92 @@
                             void *private_data)
 {
-        /* start our taskids at 1, zero is reserved for the top
-           level samba task */
-        static uint32_t taskid = 1;
+        pid_t pid = getpid();
+        /* start our taskids at MAX_INT32, the first 2^31 tasks are is reserved for fd numbers */
+        static uint32_t taskid = INT32_MAX;
        
-        /* We use 1 so we cannot collide in with cluster ids generated
-         * in the accept connection above, and unlikly to collide with
-         * PIDs from process modal standard (don't run samba as
-         * init) */
-        new_task(ev, lp_ctx, cluster_id(1, taskid++), private_data);
+        /*
+         * We use the PID so we cannot collide in with cluster ids
+         * generated in other single mode tasks, and, and won't
+         * collide with PIDs from process model starndard because a the
+         * combination of pid/task_id should be unique system-wide
+         *
+         * Using the pid unaltered makes debugging of which process
+         * owns the messaging socket easier.
+         */
+        new_task(ev, lp_ctx, cluster_id(pid, taskid++), private_data);
 }
 

vendor/current/source4/smbd/process_standard.c

@@ -30 +30 @@
 #include "ldb_wrap.h"
 
-#ifdef HAVE_SETPROCTITLE
-#ifdef HAVE_SETPROCTITLE_H
-#include <setproctitle.h>
-#endif
-#else
-#define setproctitle none_setproctitle
-static int none_setproctitle(const char *fmt, ...) PRINTF_ATTRIBUTE(1, 2);
-static int none_setproctitle(const char *fmt, ...)
-{
-        return 0;
-}
-#endif
+struct standard_child_state {
+        const char *name;
+        pid_t pid;
+        int to_parent_fd;
+        int from_child_fd;
+        struct tevent_fd *from_child_fde;
+};
+
+NTSTATUS process_model_standard_init(void);
 
 /* we hold a pipe open in the parent, and the any child
    processes wait for EOF on that pipe. This ensures that
    children die when the parent dies */
-static int child_pipe[2];
+static int child_pipe[2] = { -1, -1 };
 
 /*
@@ -53 +50 @@
 static void standard_model_init(void)
 {
-        pipe(child_pipe);
-        signal(SIGCHLD, SIG_IGN);
-}
-
-/*
-  handle EOF on the child pipe
+        int rc;
+
+        rc = pipe(child_pipe);
+        if (rc < 0) {
+                smb_panic("Failed to initialze pipe!");
+        }
+}
+
+/*
+  handle EOF on the parent-to-all-children pipe in the child
 */
 static void standard_pipe_handler(struct tevent_context *event_ctx, struct tevent_fd *fde, 
@@ -65 +66 @@
         DEBUG(10,("Child %d exiting\n", (int)getpid()));
         exit(0);
+}
+
+/*
+  handle EOF on the child pipe in the parent, so we know when a
+  process terminates without using SIGCHLD or waiting on all possible pids.
+
+  We need to ensure we do not ignore SIGCHLD because we need it to
+  work to get a valid error code from samba_runcmd_*().
+ */
+static void standard_child_pipe_handler(struct tevent_context *ev,
+                                        struct tevent_fd *fde,
+                                        uint16_t flags,
+                                        void *private_data)
+{
+        struct standard_child_state *state
+                = talloc_get_type_abort(private_data, struct standard_child_state);
+        int status = 0;
+        pid_t pid;
+
+        /* the child has closed the pipe, assume its dead */
+        errno = 0;
+        pid = waitpid(state->pid, &status, 0);
+
+        if (pid != state->pid) {
+                if (errno == ECHILD) {
+                        /*
+                         * this happens when the
+                         * parent has set SIGCHLD to
+                         * SIG_IGN. In that case we
+                         * can only get error
+                         * information for the child
+                         * via its logging. We should
+                         * stop using SIG_IGN on
+                         * SIGCHLD in the standard
+                         * process model.
+                         */
+                        DEBUG(0, ("Error in waitpid() unexpectedly got ECHILD "
+                                  "for child %d (%s) - %s, someone has set SIGCHLD "
+                                  "to SIG_IGN!\n",
+                                  (int)state->pid, state->name,
+                                  strerror(errno)));
+                        TALLOC_FREE(state);
+                        return;
+                }
+                DEBUG(0, ("Error in waitpid() for child %d (%s) - %s \n",
+                          (int)state->pid, state->name, strerror(errno)));
+                if (errno == 0) {
+                        errno = ECHILD;
+                }
+                TALLOC_FREE(state);
+                return;
+        }
+        if (WIFEXITED(status)) {
+                status = WEXITSTATUS(status);
+                DEBUG(2, ("Child %d (%s) exited with status %d\n",
+                          (int)state->pid, state->name, status));
+        } else if (WIFSIGNALED(status)) {
+                status = WTERMSIG(status);
+                DEBUG(0, ("Child %d (%s) terminated with signal %d\n",
+                          (int)state->pid, state->name, status));
+        }
+        TALLOC_FREE(state);
+        return;
+}
+
+static struct standard_child_state *setup_standard_child_pipe(struct tevent_context *ev,
+                                                              const char *name)
+{
+        struct standard_child_state *state;
+        int parent_child_pipe[2];
+        int ret;
+
+        /*
+         * Prepare a pipe to allow us to know when the child exits,
+         * because it will trigger a read event on this private
+         * pipe.
+         *
+         * We do all this before the accept and fork(), so we can
+         * clean up if it fails.
+         */
+        state = talloc_zero(ev, struct standard_child_state);
+        if (state == NULL) {
+                return NULL;
+        }
+
+        if (name == NULL) {
+                name = "";
+        }
+
+        state->name = talloc_strdup(state, name);
+        if (state->name == NULL) {
+                TALLOC_FREE(state);
+                return NULL;
+        }
+
+        ret = pipe(parent_child_pipe);
+        if (ret == -1) {
+                DEBUG(0, ("Failed to create parent-child pipe to handle "
+                          "SIGCHLD to track new process for socket\n"));
+                TALLOC_FREE(state);
+                return NULL;
+        }
+
+        smb_set_close_on_exec(parent_child_pipe[0]);
+        smb_set_close_on_exec(parent_child_pipe[1]);
+
+        state->from_child_fd = parent_child_pipe[0];
+        state->to_parent_fd = parent_child_pipe[1];
+
+        /*
+         * The basic purpose of calling this handler is to ensure we
+         * call waitpid() and so avoid zombies (now that we no longer
+         * user SIGIGN on for SIGCHLD), but it also allows us to clean
+         * up other resources in the future.
+         */
+        state->from_child_fde = tevent_add_fd(ev, state,
+                                              state->from_child_fd,
+                                              TEVENT_FD_READ,
+                                              standard_child_pipe_handler,
+                                              state);
+        if (state->from_child_fde == NULL) {
+                TALLOC_FREE(state);
+                return NULL;
+        }
+        tevent_fd_set_auto_close(state->from_child_fde);
+
+        return state;
 }
 
@@ -82 +210 @@
         pid_t pid;
         struct socket_address *c, *s;
+        struct standard_child_state *state;
+
+        state = setup_standard_child_pipe(ev, NULL);
+        if (state == NULL) {
+                return;
+        }
 
         /* accept an incoming connection. */
@@ -91 +225 @@
                    the system clears enough resources to handle this new socket */
                 sleep(1);
+                close(state->to_parent_fd);
+                state->to_parent_fd = -1;
+                TALLOC_FREE(state);
                 return;
         }
@@ -97 +234 @@
 
         if (pid != 0) {
+                close(state->to_parent_fd);
+                state->to_parent_fd = -1;
+
+                if (pid > 0) {
+                        state->pid = pid;
+                } else {
+                        TALLOC_FREE(state);
+                }
+
                 /* parent or error code ... */
                 talloc_free(sock2);
@@ -102 +248 @@
                 return;
         }
+
+        /* this leaves state->to_parent_fd open */
+        TALLOC_FREE(state);
 
         pid = getpid();
@@ -124 +273 @@
         tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
                       standard_pipe_handler, NULL);
-        close(child_pipe[1]);
-
-        /* Ensure that the forked children do not expose identical random streams */
-        set_need_random_reseed();
+        if (child_pipe[1] != -1) {
+                close(child_pipe[1]);
+                child_pipe[1] = -1;
+        }
 
         /* setup the process title */
@@ -139 +288 @@
         talloc_free(s);
 
-        /* setup this new connection.  Cluster ID is PID based for this process modal */
+        /* setup this new connection.  Cluster ID is PID based for this process model */
         new_conn(ev, lp_ctx, sock2, cluster_id(pid, 0), private_data);
 
@@ -145 +294 @@
            so we now process events in the new event context until there are no
            more to process */      
-        event_loop_wait(ev);
+        tevent_loop_wait(ev);
 
         talloc_free(ev);
@@ -161 +310 @@
 {
         pid_t pid;
+        struct standard_child_state *state;
+
+        state = setup_standard_child_pipe(ev, service_name);
+        if (state == NULL) {
+                return;
+        }
 
         pid = fork();
 
         if (pid != 0) {
+                close(state->to_parent_fd);
+                state->to_parent_fd = -1;
+
+                if (pid > 0) {
+                        state->pid = pid;
+                } else {
+                        TALLOC_FREE(state);
+                }
+
                 /* parent or error code ... go back to the event loop */
                 return;
         }
+
+        /* this leaves state->to_parent_fd open */
+        TALLOC_FREE(state);
 
         pid = getpid();
@@ -182 +349 @@
         tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
                       standard_pipe_handler, NULL);
-        close(child_pipe[1]);
-
-        /* Ensure that the forked children do not expose identical random streams */
-        set_need_random_reseed();
+        if (child_pipe[1] != -1) {
+                close(child_pipe[1]);
+                child_pipe[1] = -1;
+        }
 
         setproctitle("task %s server_id[%d]", service_name, (int)pid);
 
-        /* setup this new task.  Cluster ID is PID based for this process modal */
+        /* setup this new task.  Cluster ID is PID based for this process model */
         new_task(ev, lp_ctx, cluster_id(pid, 0), private_data);
 
@@ -195 +362 @@
            so we now process events in the new event context until there are no
            more to process */      
-        event_loop_wait(ev);
+        tevent_loop_wait(ev);
 
         talloc_free(ev);

vendor/current/source4/smbd/server.c

@@ -35 +35 @@
 #include "smbd/process_model.h"
 #include "param/secrets.h"
-#include "smbd/pidfile.h"
+#include "lib/util/pidfile.h"
 #include "param/param.h"
 #include "dsdb/samdb/samdb.h"
@@ -43 +43 @@
 #include "cluster/cluster.h"
 #include "dynconfig/dynconfig.h"
+#include "lib/util/samba_modules.h"
+#include "nsswitch/winbind_client.h"
+#include "libds/common/roles.h"
 
 /*
@@ -179 +182 @@
 {
         const char *binary_name = (const char *)private_data;
-        struct timeval tv;
-        struct timezone tz;
-        if (gettimeofday(&tv, &tz) == 0) {
-                DEBUG(0,("%s: maximum runtime exceeded - terminating, current ts: %d\n", binary_name, (int)tv.tv_sec));
-        } else {
-                DEBUG(0,("%s: maximum runtime exceeded - terminating\n", binary_name));
-        }
+        DEBUG(0,("%s: maximum runtime exceeded - terminating at %llu, current ts: %llu\n",
+                 binary_name, (unsigned long long)t.tv_sec, (unsigned long long) time(NULL)));
         exit(0);
 }
@@ -222 +220 @@
                                        struct loadparm_context *lp_ctx)
 {
-        struct messaging_context *msg;
+        struct imessaging_context *msg;
         NTSTATUS status;
 
-        msg = messaging_init(talloc_autofree_context(), 
-                             lpcfg_messaging_path(event_ctx, lp_ctx),
-                             cluster_id(0, SAMBA_PARENT_TASKID), event_ctx);
+        msg = imessaging_init(talloc_autofree_context(),
+                              lp_ctx,
+                              cluster_id(0, SAMBA_PARENT_TASKID), event_ctx, false);
         NT_STATUS_HAVE_NO_MEMORY(msg);
 
-        irpc_add_name(msg, "samba");
+        status = irpc_add_name(msg, "samba");
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
 
         status = IRPC_REGISTER(msg, irpc, SAMBA_TERMINATE,
@@ -258 +259 @@
                 CONFIG_OPTION(MODULESDIR),
                 CONFIG_OPTION(LOCKDIR),
+                CONFIG_OPTION(STATEDIR),
+                CONFIG_OPTION(CACHEDIR),
                 CONFIG_OPTION(PIDDIR),
                 CONFIG_OPTION(PRIVATE_DIR),
-                CONFIG_OPTION(SWATDIR),
                 CONFIG_OPTION(CODEPAGEDIR),
                 CONFIG_OPTION(SETUPDIR),
@@ -302 +304 @@
         const char *model = "standard";
         int max_runtime = 0;
+        struct stat st;
         enum {
                 OPT_DAEMON = 1000,
@@ -359 +362 @@
         poptFreeContext(pc);
 
+        talloc_enable_null_tracking();
+
         setup_logging(binary_name, opt_interactive?DEBUG_STDOUT:DEBUG_FILE);
         setup_signals();
@@ -367 +372 @@
 
         DEBUG(0,("%s version %s started.\n", binary_name, SAMBA_VERSION_STRING));
-        DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team 1992-2011\n"));
+        DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team 1992-2016\n"));
 
         if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4 || sizeof(uint64_t) < 8) {
@@ -383 +388 @@
         cleanup_tmp_files(cmdline_lp_ctx);
 
-        if (!directory_exist(lpcfg_lockdir(cmdline_lp_ctx))) {
-                mkdir(lpcfg_lockdir(cmdline_lp_ctx), 0755);
-        }
-
-        pidfile_create(lpcfg_piddir(cmdline_lp_ctx), binary_name);
-
-        /* Do *not* remove this, until you have removed
-         * passdb/secrets.c, and proved that Samba still builds... */
-        /* Setup the SECRETS subsystem */
-        if (secrets_init(talloc_autofree_context(), cmdline_lp_ctx) == NULL) {
-                return 1;
-        }
-
-        if (lpcfg_server_role(cmdline_lp_ctx) == ROLE_DOMAIN_CONTROLLER) {
-                if (!open_schannel_session_store(talloc_autofree_context(), lpcfg_private_dir(cmdline_lp_ctx))) {
-                        DEBUG(0,("ERROR: Samba cannot open schannel store for secured NETLOGON operations.\n"));
-                        exit(1);
-                }
-        }
-
-        gensec_init(cmdline_lp_ctx); /* FIXME: */
-
-        ntptr_init(cmdline_lp_ctx);     /* FIXME: maybe run this in the initialization function 
+        if (!directory_exist(lpcfg_lock_directory(cmdline_lp_ctx))) {
+                mkdir(lpcfg_lock_directory(cmdline_lp_ctx), 0755);
+        }
+
+        pidfile_create(lpcfg_pid_directory(cmdline_lp_ctx), binary_name);
+
+        if (lpcfg_server_role(cmdline_lp_ctx) == ROLE_ACTIVE_DIRECTORY_DC) {
+                if (!open_schannel_session_store(talloc_autofree_context(), cmdline_lp_ctx)) {
+                        exit_daemon("Samba cannot open schannel store for secured NETLOGON operations.", EACCES);
+                }
+        }
+
+        /* make sure we won't go through nss_winbind */
+        if (!winbind_off()) {
+                exit_daemon("Samba failed to disable recusive winbindd calls.", EACCES);
+        }
+
+        gensec_init(); /* FIXME: */
+
+        ntptr_init();   /* FIXME: maybe run this in the initialization function 
                                                 of the spoolss RPC server instead? */
 
@@ -413 +415 @@
         process_model_init(cmdline_lp_ctx); 
 
-        shared_init = load_samba_modules(NULL, cmdline_lp_ctx, "service");
+        shared_init = load_samba_modules(NULL, "service");
 
         run_init_functions(static_init);
@@ -425 +427 @@
 
         if (event_ctx == NULL) {
-                DEBUG(0,("Initializing event context failed\n"));
-                return 1;
+                exit_daemon("Initializing event context failed", EACCES);
         }
 
@@ -441 +442 @@
         signal(SIGTTIN, SIG_IGN);
 #endif
-        tevent_add_fd(event_ctx, event_ctx, 0, stdin_event_flags,
-                      server_stdin_handler,
-                      discard_const(binary_name));
+
+        if (fstat(0, &st) != 0) {
+                exit_daemon("Samba failed to set standard input handler", ENOTTY);
+        }
+
+        if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode)) {
+                tevent_add_fd(event_ctx,
+                                event_ctx,
+                                0,
+                                stdin_event_flags,
+                                server_stdin_handler,
+                                discard_const(binary_name));
+        }
 
         if (max_runtime) {
-                struct timeval tv;
-                struct timezone tz;
-
-                if (gettimeofday(&tv, &tz) == 0) {
-                        DEBUG(0,("Called with maxruntime %d - current ts %d\n", max_runtime, (int)tv.tv_sec));
-                } else {
-                        DEBUG(0,("Called with maxruntime %d\n", max_runtime));
-                }
+                DEBUG(0,("Called with maxruntime %d - current ts %llu\n",
+                      max_runtime, (unsigned long long) time(NULL)));
                 tevent_add_timer(event_ctx, event_ctx,
                                  timeval_current_ofs(max_runtime, 0),
@@ -460 +465 @@
         }
 
+        if (lpcfg_server_role(cmdline_lp_ctx) != ROLE_ACTIVE_DIRECTORY_DC
+            && !lpcfg_parm_bool(cmdline_lp_ctx, NULL, "server role check", "inhibit", false)
+            && !str_list_check_ci(lpcfg_server_services(cmdline_lp_ctx), "smb") 
+            && !str_list_check_ci(lpcfg_dcerpc_endpoint_servers(cmdline_lp_ctx), "remote")
+            && !str_list_check_ci(lpcfg_dcerpc_endpoint_servers(cmdline_lp_ctx), "mapiproxy")) {
+                DEBUG(0, ("At this time the 'samba' binary should only be used for either:\n"));
+                DEBUGADD(0, ("'server role = active directory domain controller' or to access the ntvfs file server with 'server services = +smb' or the rpc proxy with 'dcerpc endpoint servers = remote'\n"));
+                DEBUGADD(0, ("You should start smbd/nmbd/winbindd instead for domain member and standalone file server tasks\n"));
+                exit_daemon("Samba detected misconfigured 'server role' and exited. Check logs for details", EINVAL);
+        };
+
         prime_ldb_databases(event_ctx);
 
         status = setup_parent_messaging(event_ctx, cmdline_lp_ctx);
         if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0,("Failed to setup parent messaging - %s\n", nt_errstr(status)));
-                return 1;
+                exit_daemon("Samba failed to setup parent messaging", NT_STATUS_V(status));
         }
 
@@ -473 +488 @@
                                         lpcfg_server_services(cmdline_lp_ctx));
         if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0,("Starting Services failed - %s\n", nt_errstr(status)));
-                return 1;
+                exit_daemon("Samba failed to start services", NT_STATUS_V(status));
+        }
+
+        if (opt_daemon) {
+                daemon_ready("samba");
         }
 

vendor/current/source4/smbd/service.c

@@ -45 +45 @@
         srv->service_name = name;
         srv->task_init = task_init;
-        DLIST_ADD_END(registered_servers, srv, struct registered_server *);
+        DLIST_ADD_END(registered_servers, srv);
         return NT_STATUS_OK;
 }

vendor/current/source4/smbd/service_named_pipe.c

@@ -201 +201 @@
         }
 
-        if (!directory_create_or_exist(lpcfg_ncalrpc_dir(lp_ctx), geteuid(), 0755)) {
-                status = map_nt_error_from_unix(errno);
+        if (!directory_create_or_exist(lpcfg_ncalrpc_dir(lp_ctx), 0755)) {
+                status = map_nt_error_from_unix_common(errno);
                 DEBUG(0,(__location__ ": Failed to create ncalrpc pipe directory '%s' - %s\n",
                          lpcfg_ncalrpc_dir(lp_ctx), nt_errstr(status)));
@@ -213 +213 @@
         }
 
-        if (!directory_create_or_exist(dirname, geteuid(), 0700)) {
-                status = map_nt_error_from_unix(errno);
-                DEBUG(0,(__location__ ": Failed to create stream pipe directory %s - %s\n",
+        if (!directory_create_or_exist_strict(dirname, geteuid(), 0700)) {
+                status = map_nt_error_from_unix_common(errno);
+                DEBUG(0,(__location__ ": Failed to create stream pipe directory '%s' - %s\n",
                          dirname, nt_errstr(status)));
                 goto fail;

vendor/current/source4/smbd/service_stream.c

@@ -28 +28 @@
 #include "param/param.h"
 #include "../lib/tsocket/tsocket.h"
+#include "lib/util/util_net.h"
 
 /* the range of ports to try for dcerpc over tcp endpoints */
@@ -60 +61 @@
         if (!reason) reason = "unknown reason";
 
-        DEBUG(3,("Terminating connection - '%s'\n", reason));
+        if (srv_conn->processing) {
+                DEBUG(3,("Terminating connection deferred - '%s'\n", reason));
+        } else {
+                DEBUG(3,("Terminating connection - '%s'\n", reason));
+        }
 
         srv_conn->terminate = reason;
@@ -77 +82 @@
         talloc_free(srv_conn->event.fde);
         srv_conn->event.fde = NULL;
+        imessaging_cleanup(srv_conn->msg_ctx);
         model_ops->terminate(event_ctx, srv_conn->lp_ctx, reason);
         talloc_free(srv_conn);
@@ -123 +129 @@
                                      const struct model_ops *model_ops,
                                      const struct stream_server_ops *stream_ops,
-                                     struct messaging_context *msg_ctx,
+                                     struct imessaging_context *msg_ctx,
                                      void *private_data,
                                      struct stream_connection **_srv_conn)
@@ -174 +180 @@
         srv_conn->lp_ctx        = lp_ctx;
 
-        if (!socket_check_access(sock, "smbd", lpcfg_hostsallow(NULL, lpcfg_default_service(lp_ctx)), lpcfg_hostsdeny(NULL, lpcfg_default_service(lp_ctx)))) {
+        if (!socket_check_access(sock, "smbd", lpcfg_hosts_allow(NULL, lpcfg_default_service(lp_ctx)), lpcfg_hosts_deny(NULL, lpcfg_default_service(lp_ctx)))) {
                 stream_terminate_connection(srv_conn, "denied by access rules");
                 return;
@@ -187 +193 @@
 
         /* setup to receive internal messages on this connection */
-        srv_conn->msg_ctx = messaging_init(srv_conn, 
-                                           lpcfg_messaging_path(srv_conn, lp_ctx),
-                                           srv_conn->server_id, ev);
+        srv_conn->msg_ctx = imessaging_init(srv_conn,
+                                            lp_ctx,
+                                            srv_conn->server_id, ev, false);
         if (!srv_conn->msg_ctx) {
-                stream_terminate_connection(srv_conn, "messaging_init() failed");
+                stream_terminate_connection(srv_conn, "imessaging_init() failed");
                 return;
         }
@@ -210 +216 @@
                 TALLOC_CTX *tmp_ctx;
                 const char *title;
+                struct server_id_buf idbuf;
 
                 tmp_ctx = talloc_new(srv_conn);
@@ -217 +224 @@
                                         tsocket_address_string(srv_conn->remote_address, tmp_ctx),
                                         tsocket_address_string(srv_conn->local_address, tmp_ctx),
-                                        cluster_id_string(tmp_ctx, server_id));
+                                        server_id_str_buf(server_id, &idbuf));
                 if (title) {
                         stream_connection_set_title(srv_conn, title);
@@ -272 +279 @@
         struct tevent_fd *fde;
         int i;
+        struct sockaddr_storage ss;
 
         stream_socket = talloc_zero(mem_ctx, struct stream_socket);
         NT_STATUS_HAVE_NO_MEMORY(stream_socket);
 
-        status = socket_create(family, SOCKET_TYPE_STREAM, &stream_socket->sock, 0);
-        NT_STATUS_NOT_OK_RETURN(status);
+        if (strcmp(family, "ip") == 0) {
+                /* we will get the real family from the address itself */
+                if (!interpret_string_addr(&ss, sock_addr, 0)) {
+                        talloc_free(stream_socket);
+                        return NT_STATUS_INVALID_ADDRESS;
+                }
+
+                socket_address = socket_address_from_sockaddr_storage(stream_socket, &ss, port?*port:0);
+                if (socket_address == NULL) {
+                        TALLOC_FREE(stream_socket);
+                        return NT_STATUS_NO_MEMORY;
+                }
+
+                status = socket_create(socket_address->family, SOCKET_TYPE_STREAM, &stream_socket->sock, 0);
+                NT_STATUS_NOT_OK_RETURN(status);
+        } else {
+                status = socket_create(family, SOCKET_TYPE_STREAM, &stream_socket->sock, 0);
+                NT_STATUS_NOT_OK_RETURN(status);
+
+                /* this is for non-IP sockets, eg. unix domain sockets */
+                socket_address = socket_address_from_strings(stream_socket,
+                                                             stream_socket->sock->backend_name,
+                                                             sock_addr, port?*port:0);
+                NT_STATUS_HAVE_NO_MEMORY(socket_address);
+        }
+
 
         talloc_steal(stream_socket, stream_socket->sock);
@@ -298 +330 @@
          * the string.  We are indicating this by having port == NULL */
         if (!port) {
-                socket_address = socket_address_from_strings(stream_socket, 
-                                                             stream_socket->sock->backend_name,
-                                                             sock_addr, 0);
-                NT_STATUS_HAVE_NO_MEMORY(socket_address);
                 status = socket_listen(stream_socket->sock, socket_address, SERVER_LISTEN_BACKLOG, 0);
-                talloc_free(socket_address);
-
         } else if (*port == 0) {
                 for (i=SERVER_TCP_LOW_PORT;i<= SERVER_TCP_HIGH_PORT;i++) {
-                        socket_address = socket_address_from_strings(stream_socket, 
-                                                                     stream_socket->sock->backend_name,
-                                                                     sock_addr, i);
-                        NT_STATUS_HAVE_NO_MEMORY(socket_address);
+                        socket_address->port = i;
                         status = socket_listen(stream_socket->sock, socket_address, 
                                                SERVER_LISTEN_BACKLOG, 0);
-                        talloc_free(socket_address);
                         if (NT_STATUS_IS_OK(status)) {
                                 *port = i;
@@ -320 +342 @@
                 }
         } else {
-                socket_address = socket_address_from_strings(stream_socket, 
-                                                             stream_socket->sock->backend_name,
-                                                             sock_addr, *port);
-                NT_STATUS_HAVE_NO_MEMORY(socket_address);
                 status = socket_listen(stream_socket->sock, socket_address, SERVER_LISTEN_BACKLOG, 0);
-                talloc_free(socket_address);
         }
 
@@ -363 +380 @@
 }
 
+
 /*
   setup a connection title 

vendor/current/source4/smbd/service_stream.h

@@ -24 +24 @@
 #define __SERVICE_STREAM_H__
 
-#include "librpc/gen_ndr/server_id4.h"
+#include "librpc/gen_ndr/server_id.h"
 
 /* modules can use the following to determine if the interface has changed
@@ -48 +48 @@
 
         struct socket_context *socket;
-        struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
         struct loadparm_context *lp_ctx;
 

vendor/current/source4/smbd/service_task.c

@@ -35 +35 @@
         DEBUG(0,("task_server_terminate: [%s]\n", reason));
 
-        if (fatal) {
+        if (fatal && task->msg_ctx != NULL) {
                 struct dcerpc_binding_handle *irpc_handle;
                 struct samba_terminate r;
@@ -42 +42 @@
                                                           "samba", &ndr_table_irpc);
                 if (irpc_handle != NULL) {
+                        /* Note: this makes use of nested event loops... */
+                        dcerpc_binding_handle_set_sync_ev(irpc_handle, event_ctx);
                         r.in.reason = reason;
                         dcerpc_samba_terminate_r(irpc_handle, task, &r);
                 }
         }
+
+        imessaging_cleanup(task->msg_ctx);
 
         model_ops->terminate(event_ctx, task->lp_ctx, reason);
@@ -79 +83 @@
         task->lp_ctx = lp_ctx;
 
-        task->msg_ctx = messaging_init(task, 
-                                       lpcfg_messaging_path(task, task->lp_ctx),
-                                       task->server_id, 
-                                       task->event_ctx);
+        task->msg_ctx = imessaging_init(task,
+                                        task->lp_ctx,
+                                        task->server_id,
+                                        task->event_ctx, false);
         if (!task->msg_ctx) {
-                task_server_terminate(task, "messaging_init() failed", true);
+                task_server_terminate(task, "imessaging_init() failed", true);
                 return;
         }

vendor/current/source4/smbd/service_task.h

@@ -23 +23 @@
 #define __SERVICE_TASK_H__ 
 
-#include "librpc/gen_ndr/server_id4.h"
+#include "librpc/gen_ndr/server_id.h"
 
 struct task_server {
         struct tevent_context *event_ctx;
         const struct model_ops *model_ops;
-        struct messaging_context *msg_ctx;
+        struct imessaging_context *msg_ctx;
         struct loadparm_context *lp_ctx;
         struct server_id server_id;

vendor/current/source4/smbd/wscript_build

@@ -4 +4 @@
         source='service.c service_stream.c service_named_pipe.c service_task.c',
         autoproto='service_proto.h',
-        deps='tevent MESSAGING samba_socket RPC_NDR_IRPC NDR_NAMED_PIPE_AUTH NAMED_PIPE_AUTH_TSTREAM gssapi credentials LIBTSOCKET LIBSAMBA_TSOCKET process_model',
-        private_library=True
+        deps='tevent MESSAGING samba_socket RPC_NDR_IRPC NDR_NAMED_PIPE_AUTH npa_tstream gssapi samba-credentials LIBTSOCKET LIBSAMBA_TSOCKET process_model',
+        private_library=True,
+        enabled=bld.AD_DC_BUILD_IS_ENABLED()
         )
 
 
-bld.SAMBA_SUBSYSTEM('PIDFILE',
-        source='pidfile.c',
-        deps='talloc',
-        autoproto='pidfile.h'
-        )
-
+bld.SAMBA_LIBRARY('process_model',
+                  source='process_model.c',
+                  autoproto='process_model_proto.h',
+                  deps='samba-util samba-hostconfig samba-modules',
+                  private_library=True,
+                  enabled=bld.AD_DC_BUILD_IS_ENABLED()
+                  )
 
 bld.SAMBA_BINARY('samba',
         source='server.c',
-        manpages='samba.8',
         subsystem_name='service',
-        deps='''events process_model service samba-hostconfig samba-util POPT_SAMBA PIDFILE
+        deps='''events process_model service samba-hostconfig samba-util POPT_SAMBA
                 popt gensec registry ntptr ntvfs share cluster COMMON_SCHANNEL SECRETS''',
         pyembed=True,
-        install_path='${SBINDIR}'
+        install_path='${SBINDIR}',
+        enabled=bld.AD_DC_BUILD_IS_ENABLED()
         )
-
-
-
 
 bld.SAMBA_MODULE('process_model_single',
@@ -46 +45 @@
                  )
 
-
-bld.SAMBA_MODULE('process_model_thread',
-                 source='process_thread.c',
-                 subsystem='process_model',
-                 init_function='process_model_thread_init',
-                 enabled=False,
-                 deps='pthread samba-sockets cluster process_model',
-                 internal_module=False
-                 )
-
-
-bld.SAMBA_MODULE('process_model_prefork',
-                 source='process_prefork.c',
-                 subsystem='process_model',
-                 init_function='process_model_prefork_init',
-                 deps='events ldbsamba cluster samba-sockets process_model',
-                 internal_module=False
-                 )
-
-bld.SAMBA_MODULE('process_model_onefork',
-                 source='process_onefork.c',
-                 subsystem='process_model',
-                 init_function='process_model_onefork_init',
-                 deps='events ldbsamba process_model cluster samba-sockets',
-                 internal_module=False
-                 )
-
-
-bld.SAMBA_LIBRARY('process_model',
-                  source='process_model.c',
-                  autoproto='process_model_proto.h',
-                  deps='samba-util samba-hostconfig',
-                  private_library=True
-                  )
-