Changeset 740 for vendor/current/source4/smbd

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/source4/smbd

Files:

• config.mk (deleted)
• pidfile.c (modified) (2 diffs)
• process_model.c (modified) (4 diffs)
• process_model.h (modified) (5 diffs)
• process_model.m4 (deleted)
• process_model.mk (deleted)
• process_onefork.c (added)
• process_prefork.c (modified) (9 diffs)
• process_single.c (modified) (5 diffs)
• process_standard.c (modified) (11 diffs)
• process_thread.c (modified) (11 diffs)
• samba.8.xml (modified) (1 diff)
• server.c (modified) (18 diffs)
• service.c (modified) (1 diff)
• service_named_pipe.c (modified) (9 diffs)
• service_stream.c (modified) (12 diffs)
• service_stream.h (modified) (3 diffs)
• service_task.c (modified) (3 diffs)
• service_task.h (modified) (1 diff)
• wscript_build (added)

vendor/current/source4/smbd/pidfile.c

@@ -39 +39 @@
         char *pidFile;
 
-        asprintf(&pidFile, "%s/%s.pid", piddir, name);
+        if (asprintf(&pidFile, "%s/%s.pid", piddir, name) < 0) {
+                return 0;
+        }
 
         fd = open(pidFile, O_NONBLOCK | O_RDONLY, 0644);
@@ -86 +88 @@
         pid_t pid;
 
-        asprintf(&pidFile, "%s/%s.pid", piddir, name);
+        if (asprintf(&pidFile, "%s/%s.pid", piddir, name) < 0) {
+                DEBUG(0,("ERROR: Out of memory\n"));
+                exit(1);
+        }
 
         pid = pidfile_pid(piddir, name);

vendor/current/source4/smbd/process_model.c

@@ -23 +23 @@
 #include "param/param.h"
 
-static const struct model_ops *process_model_byname(const char *name);
+/* the list of currently registered process models */
+static struct process_model {
+        const struct model_ops *ops;
+        bool initialised;
+} *models = NULL;
+static int num_models;
+
+
+/*
+  return the operations structure for a named backend of the specified type
+*/
+static struct process_model *process_model_byname(const char *name)
+{
+        int i;
+
+        for (i=0;i<num_models;i++) {
+                if (strcmp(models[i].ops->name, name) == 0) {
+                        return &models[i];
+                }
+        }
+
+        return NULL;
+}
+
 
 /*
   setup the events for the chosen process model
 */
-_PUBLIC_ const struct model_ops *process_model_startup(struct tevent_context *ev, const char *model)
+_PUBLIC_ const struct model_ops *process_model_startup(const char *model)
 {
-        const struct model_ops *ops;
+        struct process_model *m;
 
-        ops = process_model_byname(model);
-        if (!ops) {
+        m = process_model_byname(model);
+        if (m == NULL) {
                 DEBUG(0,("Unknown process model '%s'\n", model));
                 exit(-1);
         }
 
-        ops->model_init(ev);
+        if (!m->initialised) {
+                m->initialised = true;
+                m->ops->model_init();
+        }
 
-        return ops;
+        return m->ops;
 }
-
-/* the list of currently registered process models */
-static struct process_model {
-        struct model_ops *ops;
-} *models = NULL;
-static int num_models;
 
 /*
@@ -55 +75 @@
   structure for this backend.  
 */
-_PUBLIC_ NTSTATUS register_process_model(const void *_ops)
+_PUBLIC_ NTSTATUS register_process_model(const struct model_ops *ops)
 {
-        const struct model_ops *ops = _ops;
-
         if (process_model_byname(ops->name) != NULL) {
                 /* its already registered! */
@@ -66 +84 @@
         }
 
-        models = realloc_p(models, struct process_model, num_models+1);
+        models = talloc_realloc(NULL, models, struct process_model, num_models+1);
         if (!models) {
                 smb_panic("out of memory in register_process_model");
         }
 
-        models[num_models].ops = smb_xmemdup(ops, sizeof(*ops));
-        models[num_models].ops->name = smb_xstrdup(ops->name);
+        models[num_models].ops = ops;
+        models[num_models].initialised = false;
 
         num_models++;
 
-        DEBUG(3,("PROCESS_MODEL '%s' registered\n", 
-                 ops->name));
+        DEBUG(3,("PROCESS_MODEL '%s' registered\n", ops->name));
 
         return NT_STATUS_OK;
@@ -84 +101 @@
 _PUBLIC_ NTSTATUS process_model_init(struct loadparm_context *lp_ctx)
 {
-        extern NTSTATUS process_model_thread_init(void);
-        extern NTSTATUS process_model_standard_init(void);
-        extern NTSTATUS process_model_prefork_init(void);
-        extern NTSTATUS process_model_single_init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+        STATIC_process_model_MODULES_PROTO;
         init_module_fn static_init[] = { STATIC_process_model_MODULES };
-        init_module_fn *shared_init = load_samba_modules(NULL, lp_ctx, "process_model");
+        init_module_fn *shared_init;
+        static bool initialised;
 
+        if (initialised) {
+                return NT_STATUS_OK;
+        }
+        initialised = true;
+
+        shared_init = load_samba_modules(NULL, lp_ctx, "process_model");
+        
         run_init_functions(static_init);
         run_init_functions(shared_init);
 
         talloc_free(shared_init);
-        
+
         return NT_STATUS_OK;
-}
-
-/*
-  return the operations structure for a named backend of the specified type
-*/
-static const struct model_ops *process_model_byname(const char *name)
-{
-        int i;
-
-        for (i=0;i<num_models;i++) {
-                if (strcmp(models[i].ops->name, name) == 0) {
-                        return models[i].ops;
-                }
-        }
-
-        return NULL;
 }
 

vendor/current/source4/smbd/process_model.h

@@ -27 +27 @@
 #include "lib/socket/socket.h"
 #include "smbd/service.h"
+#include "smbd/process_model_proto.h"
 
 /* modules can use the following to determine if the interface has changed
@@ -42 +43 @@
 
         /* called at startup when the model is selected */
-        void (*model_init)(struct tevent_context *);
+        void (*model_init)(void);
 
         /* function to accept new connection */
@@ -56 +57 @@
         /* function to create a task */
         void (*new_task)(struct tevent_context *, 
-                         struct loadparm_context *lp_ctx, 
+                         struct loadparm_context *lp_ctx,
                          const char *service_name,
                          void (*)(struct tevent_context *, 
@@ -64 +65 @@
 
         /* function to terminate a connection or task */
-        void (*terminate)(struct tevent_context *, struct loadparm_context *lp_ctx, 
+        void (*terminate)(struct tevent_context *, struct loadparm_context *lp_ctx,
                           const char *reason);
 
@@ -79 +80 @@
 extern const struct model_ops single_ops;
 
-const struct model_ops *process_model_startup(struct tevent_context *ev, const char *model);
-NTSTATUS register_process_model(const void *_ops);
+const struct model_ops *process_model_startup(const char *model);
+NTSTATUS register_process_model(const struct model_ops *ops);
 NTSTATUS process_model_init(struct loadparm_context *lp_ctx);
 

vendor/current/source4/smbd/process_prefork.c

@@ -26 +26 @@
 #include "includes.h"
 #include "lib/events/events.h"
-#include "../tdb/include/tdb.h"
 #include "lib/socket/socket.h"
 #include "smbd/process_model.h"
-#include "param/secrets.h"
 #include "system/filesys.h"
 #include "cluster/cluster.h"
 #include "param/param.h"
+#include "ldb_wrap.h"
 
 #ifdef HAVE_SETPROCTITLE
@@ -50 +49 @@
   called when the process model is selected
 */
-static void prefork_model_init(struct tevent_context *ev)
+static void prefork_model_init(void)
 {
         signal(SIGCHLD, SIG_IGN);
@@ -57 +56 @@
 static void prefork_reload_after_fork(void)
 {
-        /* tdb needs special fork handling */
-        if (tdb_reopen_all(1) == -1) {
-                DEBUG(0,("prefork_reload_after_fork: tdb_reopen_all failed.\n"));
-        }
+        ldb_wrap_fork_hook();
 
         /* Ensure that the forked children do not expose identical random streams */
@@ -98 +94 @@
                              struct loadparm_context *lp_ctx,
                              const char *service_name,
-                             void (*new_task_fn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *), 
+                             void (*new_task_fn)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
                              void *private_data)
 {
@@ -127 +123 @@
         talloc_free(ev);
 
-        setproctitle("task %s server_id[%d]", service_name, pid);
+        setproctitle("task %s server_id[%d]", service_name, (int)pid);
 
         prefork_reload_after_fork();
@@ -134 +130 @@
         new_task_fn(ev2, lp_ctx, cluster_id(pid, 0), private_data);
 
-        num_children = lp_parm_int(lp_ctx, NULL, "prefork children", service_name, 0);
+        num_children = lpcfg_parm_int(lp_ctx, NULL, "prefork children", service_name, 0);
         if (num_children == 0) {
 
@@ -156 +152 @@
                 } else {
                         pid = getpid();
-                        setproctitle("task %s server_id[%d]", service_name, pid);
+                        setproctitle("task %s server_id[%d]", service_name, (int)pid);
 
                         prefork_reload_after_fork();
@@ -175 +171 @@
         /* But we need a events system to handle reaping children */
         ev_parent = s4_event_context_init(NULL);
-        
+
         /* TODO: Handle some events... */
         
@@ -190 +186 @@
 
 /* called when a task goes down */
-_NORETURN_ static void prefork_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason) 
+static void prefork_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason)
 {
         DEBUG(2,("prefork_terminate: reason[%s]\n",reason));

vendor/current/source4/smbd/process_single.c

@@ -30 +30 @@
   called when the process model is selected
 */
-static void single_model_init(struct tevent_context *ev)
+static void single_model_init(void)
 {
 }
@@ -56 +56 @@
 
                    We can only be here if woken up from select, due to
-                   an incomming connection.
+                   an incoming connection.
 
                    We need to throttle things until the system clears
@@ -72 +72 @@
         /* The cluster_id(0, fd) cannot collide with the incrementing
          * task below, as the first component is 0, not 1 */
-        new_conn(ev, lp_ctx, connected_socket, 
+        new_conn(ev, lp_ctx, connected_socket,
                  cluster_id(0, socket_get_fd(connected_socket)), private_data);
 }
@@ -80 +80 @@
 */
 static void single_new_task(struct tevent_context *ev, 
-                            struct loadparm_context *lp_ctx, 
+                            struct loadparm_context *lp_ctx,
                             const char *service_name,
                             void (*new_task)(struct tevent_context *, struct loadparm_context *, struct server_id, void *), 
@@ -98 +98 @@
 
 /* called when a task goes down */
-static void single_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason) 
+static void single_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, const char *reason)
 {
-        DEBUG(2,("single_terminate: reason[%s]\n",reason));
+        DEBUG(3,("single_terminate: reason[%s]\n",reason));
 }
 

vendor/current/source4/smbd/process_standard.c

@@ -24 +24 @@
 #include "includes.h"
 #include "lib/events/events.h"
-#include "../tdb/include/tdb.h"
 #include "smbd/process_model.h"
 #include "system/filesys.h"
 #include "cluster/cluster.h"
 #include "param/param.h"
+#include "ldb_wrap.h"
 
 #ifdef HAVE_SETPROCTITLE
@@ -51 +51 @@
   called when the process model is selected
 */
-static void standard_model_init(struct tevent_context *ev)
+static void standard_model_init(void)
 {
         pipe(child_pipe);
@@ -81 +81 @@
         struct socket_context *sock2;
         pid_t pid;
-        struct tevent_context *ev2;
         struct socket_address *c, *s;
 
@@ -107 +106 @@
 
         /* This is now the child code. We need a completely new event_context to work with */
-        ev2 = s4_event_context_init(NULL);
-
-        /* the service has given us a private pointer that
-           encapsulates the context it needs for this new connection -
-           everything else will be freed */
-        talloc_steal(ev2, private_data);
-        talloc_steal(private_data, sock2);
+
+        if (tevent_re_initialise(ev) != 0) {
+                smb_panic("Failed to re-initialise tevent after fork");
+        }
 
         /* this will free all the listening sockets and all state that
            is not associated with this new connection */
         talloc_free(sock);
-        talloc_free(ev);
 
         /* we don't care if the dup fails, as its only a select()
@@ -125 +120 @@
                         
         /* tdb needs special fork handling */
-        if (tdb_reopen_all(1) == -1) {
-                DEBUG(0,("standard_accept_connection: tdb_reopen_all failed.\n"));
-        }
-
-        tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
+        ldb_wrap_fork_hook();
+
+        tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
                       standard_pipe_handler, NULL);
         close(child_pipe[1]);
@@ -137 +130 @@
 
         /* setup the process title */
-        c = socket_get_peer_addr(sock2, ev2);
-        s = socket_get_my_addr(sock2, ev2);
+        c = socket_get_peer_addr(sock2, ev);
+        s = socket_get_my_addr(sock2, ev);
         if (s && c) {
                 setproctitle("conn c[%s:%u] s[%s:%u] server_id[%d]",
-                             c->addr, c->port, s->addr, s->port, pid);
+                             c->addr, c->port, s->addr, s->port, (int)pid);
         }
         talloc_free(c);
@@ -147 +140 @@
 
         /* setup this new connection.  Cluster ID is PID based for this process modal */
-        new_conn(ev2, lp_ctx, sock2, cluster_id(pid, 0), private_data);
+        new_conn(ev, lp_ctx, sock2, cluster_id(pid, 0), private_data);
 
         /* we can't return to the top level here, as that event context is gone,
            so we now process events in the new event context until there are no
            more to process */      
-        event_loop_wait(ev2);
-
-        talloc_free(ev2);
+        event_loop_wait(ev);
+
+        talloc_free(ev);
         exit(0);
 }
@@ -164 +157 @@
                               struct loadparm_context *lp_ctx,
                               const char *service_name,
-                              void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *), 
+                              void (*new_task)(struct tevent_context *, struct loadparm_context *lp_ctx, struct server_id , void *),
                               void *private_data)
 {
         pid_t pid;
-        struct tevent_context *ev2;
 
         pid = fork();
@@ -179 +171 @@
         pid = getpid();
 
-        /* This is now the child code. We need a completely new event_context to work with */
-        ev2 = s4_event_context_init(NULL);
-
-        /* the service has given us a private pointer that
-           encapsulates the context it needs for this new connection -
-           everything else will be freed */
-        talloc_steal(ev2, private_data);
-
         /* this will free all the listening sockets and all state that
            is not associated with this new connection */
-        talloc_free(ev);
-
-        /* tdb needs special fork handling */
-        if (tdb_reopen_all(1) == -1) {
-                DEBUG(0,("standard_accept_connection: tdb_reopen_all failed.\n"));
-        }
-
-        tevent_add_fd(ev2, ev2, child_pipe[0], TEVENT_FD_READ,
+        if (tevent_re_initialise(ev) != 0) {
+                smb_panic("Failed to re-initialise tevent after fork");
+        }
+
+        /* ldb/tdb need special fork handling */
+        ldb_wrap_fork_hook();
+
+        tevent_add_fd(ev, ev, child_pipe[0], TEVENT_FD_READ,
                       standard_pipe_handler, NULL);
         close(child_pipe[1]);
@@ -203 +187 @@
         set_need_random_reseed();
 
-        setproctitle("task %s server_id[%d]", service_name, pid);
+        setproctitle("task %s server_id[%d]", service_name, (int)pid);
 
         /* setup this new task.  Cluster ID is PID based for this process modal */
-        new_task(ev2, lp_ctx, cluster_id(pid, 0), private_data);
+        new_task(ev, lp_ctx, cluster_id(pid, 0), private_data);
 
         /* we can't return to the top level here, as that event context is gone,
            so we now process events in the new event context until there are no
            more to process */      
-        event_loop_wait(ev2);
-
-        talloc_free(ev2);
+        event_loop_wait(ev);
+
+        talloc_free(ev);
         exit(0);
 }
@@ -219 +203 @@
 
 /* called when a task goes down */
-_NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx, 
+_NORETURN_ static void standard_terminate(struct tevent_context *ev, struct loadparm_context *lp_ctx,
                                           const char *reason) 
 {
         DEBUG(2,("standard_terminate: reason[%s]\n",reason));
+
+        talloc_free(ev);
 
         /* this reload_charcnv() has the effect of freeing the iconv context memory,
            which makes leak checking easier */
         reload_charcnv(lp_ctx);
-
-        talloc_free(ev);
 
         /* terminate this process */

vendor/current/source4/smbd/process_thread.c

@@ -30 +30 @@
 #include "system/wait.h"
 #include "system/filesys.h"
+#include "system/time.h"
 #include "lib/events/events.h"
 #include "lib/util/dlinklist.h"
@@ -63 +64 @@
 */
 static void thread_accept_connection(struct tevent_context *ev, 
-                                     struct loadparm_context *lp_ctx, 
+                                     struct loadparm_context *lp_ctx,
                                      struct socket_context *sock,
                                      void (*new_conn)(struct tevent_context *, 
@@ -133 +134 @@
         struct new_task_state *new_task = talloc_get_type(thread_parm, struct new_task_state);
 
-        new_task->new_task(new_task->ev, new_task->lp_ctx, pthread_self(), 
+        new_task->new_task(new_task->ev, new_task->lp_ctx, pthread_self(),
                            new_task->private_data);
 
@@ -189 +190 @@
 
 /* called when a task goes down */
-static void thread_terminate(struct tevent_context *event_ctx, struct loadparm_context *lp_ctx, const char *reason) 
+static void thread_terminate(struct tevent_context *event_ctx, struct loadparm_context *lp_ctx, const char *reason)
 {
         DEBUG(10,("thread_terminate: reason[%s]\n",reason));
@@ -234 +235 @@
 }
 
-static void mutex_start_timer(struct timeval *tp1)
-{
-        gettimeofday(tp1,NULL);
-}
-
-static double mutex_end_timer(struct timeval tp1)
-{
-        struct timeval tp2;
-        gettimeofday(&tp2,NULL);
+static void mutex_start_timer(struct timespec *tp1)
+{
+        clock_gettime_mono(tp1);
+}
+
+static double mutex_end_timer(struct timespec tp1)
+{
+        struct timespec tp2;
+
+        clock_gettime_mono(&tp2);
         return((tp2.tv_sec - tp1.tv_sec) + 
-               (tp2.tv_usec - tp1.tv_usec)*1.0e-6);
+               (tp2.tv_nsec - tp1.tv_nsec)*1.0e-9);
 }
 
@@ -255 +257 @@
         int rc;
         double t;
-        struct timeval tp1;
+        struct timespec tp1;
         /* Test below is ONLY for debugging */
         if ((rc = pthread_mutex_trylock(mutex))) {
@@ -317 +319 @@
         int rc;
         double t;
-        struct timeval tp1;
+        struct timespec tp1;
         /* Test below is ONLY for debugging */
         if ((rc = pthread_rwlock_tryrdlock(rwlock))) {
@@ -346 +348 @@
         int rc;
         double t;
-        struct timeval tp1;
+        struct timespec tp1;
         /* Test below is ONLY for debugging */
         if ((rc = pthread_rwlock_trywrlock(rwlock))) {
@@ -460 +462 @@
 {
 #ifdef SIGSEGV
-        CatchSignal(SIGSEGV,SIGNAL_CAST thread_sig_fault);
+        CatchSignal(SIGSEGV, thread_sig_fault);
 #endif
 #ifdef SIGBUS
-        CatchSignal(SIGBUS,SIGNAL_CAST thread_sig_fault);
+        CatchSignal(SIGBUS, thread_sig_fault);
 #endif
 #ifdef SIGABRT
-        CatchSignal(SIGABRT,SIGNAL_CAST thread_sig_fault);
+        CatchSignal(SIGABRT, thread_sig_fault);
 #endif
 }
@@ -510 +512 @@
   called when the process model is selected
 */
-static void thread_model_init(struct tevent_context *event_context)
+static void thread_model_init(void)
 {
         struct mutex_ops m_ops;
@@ -519 +521 @@
 
         pthread_key_create(&title_key, NULL);
-        pthread_setspecific(title_key, talloc_strdup(event_context, ""));
+        pthread_setspecific(title_key, NULL);
 
         /* register mutex/rwlock handlers */

vendor/current/source4/smbd/samba.8.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 <refentry id="samba.8">
 

vendor/current/source4/smbd/server.c

@@ -32 +32 @@
 #include "ntptr/ntptr.h"
 #include "auth/gensec/gensec.h"
+#include "libcli/auth/schannel.h"
 #include "smbd/process_model.h"
 #include "param/secrets.h"
@@ -41 +42 @@
 #include "librpc/gen_ndr/ndr_irpc.h"
 #include "cluster/cluster.h"
+#include "dynconfig/dynconfig.h"
 
 /*
@@ -116 +118 @@
 #endif
         DEBUG(0,("Exiting pid %d on SIGTERM\n", (int)getpid()));
-        exit(0);
+        exit(127);
 }
 
@@ -141 +143 @@
 
         /* POSIX demands that signals are inherited. If the invoking process has
-         * these signals masked, we will have problems, as we won't recieve them. */
+         * these signals masked, we will have problems, as we won't receive them. */
         BlockSignals(false, SIGHUP);
         BlockSignals(false, SIGTERM);
@@ -177 +179 @@
 {
         const char *binary_name = (const char *)private_data;
-        DEBUG(0,("%s: maximum runtime exceeded - terminating\n", binary_name));
+        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));
+        }
         exit(0);
 }
 
 /*
-  pre-open the sam ldb to ensure the schema has been loaded. This
-  saves a lot of time in child processes  
+  pre-open the key databases. This saves a lot of time in child
+  processes
  */
-static void prime_samdb_schema(struct tevent_context *event_ctx)
-{
-        TALLOC_CTX *samdb_context;
-        samdb_context = talloc_new(event_ctx);
-        samdb_connect(samdb_context, event_ctx, cmdline_lp_ctx, system_session(samdb_context, cmdline_lp_ctx));
-        talloc_free(samdb_context);
+static void prime_ldb_databases(struct tevent_context *event_ctx)
+{
+        TALLOC_CTX *db_context;
+        db_context = talloc_new(event_ctx);
+
+        samdb_connect(db_context, event_ctx, cmdline_lp_ctx, system_session(cmdline_lp_ctx), 0);
+        privilege_connect(db_context, cmdline_lp_ctx);
+
+        /* we deliberately leave these open, which allows them to be
+         * re-used in ldb_wrap_connect() */
 }
 
@@ -214 +226 @@
 
         msg = messaging_init(talloc_autofree_context(), 
-                             lp_messaging_path(event_ctx, lp_ctx),
-                             cluster_id(0, SAMBA_PARENT_TASKID),
-                             lp_iconv_convenience(lp_ctx),
-                             event_ctx);
+                             lpcfg_messaging_path(event_ctx, lp_ctx),
+                             cluster_id(0, SAMBA_PARENT_TASKID), event_ctx);
         NT_STATUS_HAVE_NO_MEMORY(msg);
 
@@ -229 +239 @@
 
 
+/*
+  show build info
+ */
+static void show_build(void)
+{
+#define CONFIG_OPTION(n) { #n, dyn_ ## n }
+        struct {
+                const char *name;
+                const char *value;
+        } config_options[] = {
+                CONFIG_OPTION(BINDIR),
+                CONFIG_OPTION(SBINDIR),
+                CONFIG_OPTION(CONFIGFILE),
+                CONFIG_OPTION(NCALRPCDIR),
+                CONFIG_OPTION(LOGFILEBASE),
+                CONFIG_OPTION(LMHOSTSFILE),
+                CONFIG_OPTION(DATADIR),
+                CONFIG_OPTION(MODULESDIR),
+                CONFIG_OPTION(LOCKDIR),
+                CONFIG_OPTION(PIDDIR),
+                CONFIG_OPTION(PRIVATE_DIR),
+                CONFIG_OPTION(SWATDIR),
+                CONFIG_OPTION(CODEPAGEDIR),
+                CONFIG_OPTION(SETUPDIR),
+                CONFIG_OPTION(WINBINDD_SOCKET_DIR),
+                CONFIG_OPTION(WINBINDD_PRIVILEGED_SOCKET_DIR),
+                CONFIG_OPTION(NTP_SIGND_SOCKET_DIR),
+                { NULL, NULL}
+        };
+        int i;
+
+        printf("Samba version: %s\n", SAMBA_VERSION_STRING);
+        printf("Build environment:\n");
+#ifdef BUILD_SYSTEM
+        printf("   Build host:  %s\n", BUILD_SYSTEM);
+#endif
+
+        printf("Paths:\n");
+        for (i=0; config_options[i].name; i++) {
+                printf("   %s: %s\n", config_options[i].name, config_options[i].value);
+        }
+
+        exit(0);
+}
 
 /*
@@ -239 +293 @@
         int opt;
         poptContext pc;
-        extern NTSTATUS server_service_wrepl_init(void);
-        extern NTSTATUS server_service_kdc_init(void);
-        extern NTSTATUS server_service_ldap_init(void);
-        extern NTSTATUS server_service_web_init(void);
-        extern NTSTATUS server_service_ldap_init(void);
-        extern NTSTATUS server_service_winbind_init(void);
-        extern NTSTATUS server_service_nbtd_init(void);
-        extern NTSTATUS server_service_auth_init(void);
-        extern NTSTATUS server_service_cldapd_init(void);
-        extern NTSTATUS server_service_smb_init(void);
-        extern NTSTATUS server_service_drepl_init(void);
-        extern NTSTATUS server_service_kcc_init(void);
-        extern NTSTATUS server_service_rpc_init(void);
-        extern NTSTATUS server_service_ntp_signd_init(void);
-        extern NTSTATUS server_service_samba3_smb_init(void);
+#define _MODULE_PROTO(init) extern NTSTATUS init(void);
+        STATIC_service_MODULES_PROTO;
         init_module_fn static_init[] = { STATIC_service_MODULES };
         init_module_fn *shared_init;
@@ -264 +305 @@
                 OPT_DAEMON = 1000,
                 OPT_INTERACTIVE,
-                OPT_PROCESS_MODEL
+                OPT_PROCESS_MODEL,
+                OPT_SHOW_BUILD
         };
         struct poptOption long_options[] = {
@@ -276 +318 @@
                 {"maximum-runtime",0, POPT_ARG_INT, &max_runtime, 0, 
                  "set maximum runtime of the server process, till autotermination", "seconds"},
+                {"show-build", 'b', POPT_ARG_NONE, NULL, OPT_SHOW_BUILD, "show build info", NULL },
                 POPT_COMMON_SAMBA
                 POPT_COMMON_VERSION
@@ -293 +336 @@
                         model = poptGetOptArg(pc);
                         break;
+                case OPT_SHOW_BUILD:
+                        show_build();
+                        break;
                 default:
                         fprintf(stderr, "\nInvalid option %s: %s\n\n",
                                   poptBadOption(pc, 0), poptStrerror(opt));
                         poptPrintUsage(pc, stderr, 0);
-                        exit(1);
+                        return 1;
                 }
         }
@@ -305 +351 @@
                           "Option -i|--interactive is not allowed together with -D|--daemon\n\n");
                 poptPrintUsage(pc, stderr, 0);
-                exit(1);
+                return 1;
         } else if (!opt_interactive) {
                 /* default is --daemon */
@@ -321 +367 @@
 
         DEBUG(0,("%s version %s started.\n", binary_name, SAMBA_VERSION_STRING));
-        DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team 1992-2009\n"));
+        DEBUGADD(0,("Copyright Andrew Tridgell and the Samba Team 1992-2011\n"));
 
         if (sizeof(uint16_t) < 2 || sizeof(uint32_t) < 4 || sizeof(uint64_t) < 8) {
@@ -327 +373 @@
                 DEBUGADD(0,("sizeof(uint16_t) = %u, sizeof(uint32_t) %u, sizeof(uint64_t) = %u\n",
                             (unsigned int)sizeof(uint16_t), (unsigned int)sizeof(uint32_t), (unsigned int)sizeof(uint64_t)));
-                exit(1);
+                return 1;
         }
 
         if (opt_daemon) {
                 DEBUG(3,("Becoming a daemon.\n"));
-                become_daemon(true, false);
+                become_daemon(true, false, false);
         }
 
         cleanup_tmp_files(cmdline_lp_ctx);
 
-        if (!directory_exist(lp_lockdir(cmdline_lp_ctx))) {
-                mkdir(lp_lockdir(cmdline_lp_ctx), 0755);
-        }
-
-        pidfile_create(lp_piddir(cmdline_lp_ctx), binary_name);
+        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
@@ -347 +393 @@
         /* Setup the SECRETS subsystem */
         if (secrets_init(talloc_autofree_context(), cmdline_lp_ctx) == NULL) {
-                exit(1);
+                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);
+                }
         }
 
@@ -393 +446 @@
 
         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));
+                }
                 tevent_add_timer(event_ctx, event_ctx,
                                  timeval_current_ofs(max_runtime, 0),
@@ -399 +460 @@
         }
 
-        prime_samdb_schema(event_ctx);
+        prime_ldb_databases(event_ctx);
 
         status = setup_parent_messaging(event_ctx, cmdline_lp_ctx);
@@ -410 +471 @@
 
         status = server_service_startup(event_ctx, cmdline_lp_ctx, model, 
-                                        lp_server_services(cmdline_lp_ctx));
+                                        lpcfg_server_services(cmdline_lp_ctx));
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(0,("Starting Services failed - %s\n", nt_errstr(status)));

vendor/current/source4/smbd/service.c

@@ -84 +84 @@
         }
 
-        model_ops = process_model_startup(event_ctx, model);
+        model_ops = process_model_startup(model);
         if (!model_ops) {
                 DEBUG(0,("process_model_startup('%s') failed\n", model));

vendor/current/source4/smbd/service_named_pipe.c

@@ -24 +24 @@
 #include "smbd/service.h"
 #include "param/param.h"
+#include "auth/auth.h"
 #include "auth/session.h"
 #include "auth/auth_sam_reply.h"
-#include "lib/stream/packet.h"
+#include "lib/socket/socket.h"
+#include "lib/tsocket/tsocket.h"
+#include "libcli/util/tstream.h"
 #include "librpc/gen_ndr/ndr_named_pipe_auth.h"
 #include "system/passwd.h"
+#include "system/network.h"
 #include "libcli/raw/smb.h"
-#include "auth/credentials/credentials.h"
-#include "auth/credentials/credentials_krb5.h"
+#include "auth/session.h"
+#include "libcli/security/security.h"
+#include "libcli/named_pipe_auth/npa_tstream.h"
 
 struct named_pipe_socket {
@@ -40 +45 @@
 };
 
-struct named_pipe_connection {
-        struct stream_connection *connection;
-        struct packet_context *packet;
-        const struct named_pipe_socket *pipe_sock;
-        NTSTATUS status;
-};
-
-static void named_pipe_handover_connection(void *private_data)
-{
-        struct named_pipe_connection *pipe_conn = talloc_get_type(
-                private_data, struct named_pipe_connection);
-        struct stream_connection *conn = pipe_conn->connection;
-
-        TEVENT_FD_NOT_WRITEABLE(conn->event.fde);
-
-        packet_set_socket(pipe_conn->packet, NULL);
-        packet_set_event_context(pipe_conn->packet, NULL);
-        packet_set_fde(pipe_conn->packet, NULL);
-        TALLOC_FREE(pipe_conn->packet);
-
-        if (!NT_STATUS_IS_OK(pipe_conn->status)) {
-                stream_terminate_connection(conn, nt_errstr(pipe_conn->status));
+static void named_pipe_accept_done(struct tevent_req *subreq);
+
+static void named_pipe_accept(struct stream_connection *conn)
+{
+        struct tstream_context *plain_tstream;
+        int fd;
+        struct tevent_req *subreq;
+        int ret;
+
+        /* Let tstream take over fd operations */
+
+        fd = socket_get_fd(conn->socket);
+        socket_set_flags(conn->socket, SOCKET_FLAG_NOCLOSE);
+        TALLOC_FREE(conn->event.fde);
+        TALLOC_FREE(conn->socket);
+
+        ret = tstream_bsd_existing_socket(conn, fd, &plain_tstream);
+        if (ret != 0) {
+                stream_terminate_connection(conn,
+                                "named_pipe_accept: out of memory");
                 return;
         }
 
-        /*
-         * remove the named_pipe layer together with its packet layer
-         */
-        conn->ops               = pipe_conn->pipe_sock->ops;
-        conn->private_data      = pipe_conn->pipe_sock->private_data;
-        talloc_unlink(conn, pipe_conn);
-
-        /* we're now ready to start receiving events on this stream */
-        TEVENT_FD_READABLE(conn->event.fde);
+        subreq = tstream_npa_accept_existing_send(conn, conn->event.ctx,
+                                                  plain_tstream,
+                                                  FILE_TYPE_MESSAGE_MODE_PIPE,
+                                                  0xff | 0x0400 | 0x0100,
+                                                  4096);
+        if (subreq == NULL) {
+                stream_terminate_connection(conn,
+                        "named_pipe_accept: "
+                        "no memory for tstream_npa_accept_existing_send");
+                return;
+        }
+        tevent_req_set_callback(subreq, named_pipe_accept_done, conn);
+}
+
+static void named_pipe_accept_done(struct tevent_req *subreq)
+{
+        struct stream_connection *conn = tevent_req_callback_data(subreq,
+                                                struct stream_connection);
+        struct named_pipe_socket *pipe_sock =
+                                talloc_get_type(conn->private_data,
+                                                struct named_pipe_socket);
+        struct tsocket_address *client;
+        char *client_name;
+        struct tsocket_address *server;
+        char *server_name;
+        struct auth_session_info_transport *session_info_transport;
+        const char *reason = NULL;
+        TALLOC_CTX *tmp_ctx;
+        int error;
+        int ret;
+
+        tmp_ctx = talloc_new(conn);
+        if (!tmp_ctx) {
+                reason = "Out of memory!\n";
+                goto out;
+        }
+
+        ret = tstream_npa_accept_existing_recv(subreq, &error, tmp_ctx,
+                                               &conn->tstream,
+                                               &client,
+                                               &client_name,
+                                               &server,
+                                               &server_name,
+                                               &session_info_transport);
+        TALLOC_FREE(subreq);
+        if (ret != 0) {
+                reason = talloc_asprintf(conn,
+                                         "tstream_npa_accept_existing_recv()"
+                                         " failed: %s", strerror(error));
+                goto out;
+        }
+
+        DEBUG(10, ("Accepted npa connection from %s. "
+                   "Client: %s (%s). Server: %s (%s)\n",
+                   tsocket_address_string(conn->remote_address, tmp_ctx),
+                   client_name, tsocket_address_string(client, tmp_ctx),
+                   server_name, tsocket_address_string(server, tmp_ctx)));
+
+        conn->session_info = auth_session_info_from_transport(conn, session_info_transport,
+                                                              conn->lp_ctx,
+                                                              &reason);
+        if (!conn->session_info) {
+                goto out;
+        }
 
         /*
@@ -79 +137 @@
          * now that we have setup the transport session_info
          */
+        conn->ops = pipe_sock->ops;
+        conn->private_data = pipe_sock->private_data;
         conn->ops->accept_connection(conn);
 
-        DEBUG(10,("named_pipe_handover_connection[%s]: succeeded\n",
-              conn->ops->name));
-}
-
-static NTSTATUS named_pipe_recv_auth_request(void *private_data,
-                                             DATA_BLOB req_blob)
-{
-        struct named_pipe_connection *pipe_conn = talloc_get_type(
-                private_data, struct named_pipe_connection);
-        struct stream_connection *conn = pipe_conn->connection;
-        enum ndr_err_code ndr_err;
-        struct named_pipe_auth_req req;
-        union netr_Validation val;
-        struct auth_serversupplied_info *server_info;
-        struct named_pipe_auth_rep rep;
-        DATA_BLOB rep_blob;
-        NTSTATUS status;
-
-        /*
-         * make sure nothing happens on the socket untill the
-         * real implemenation takes over
-         */
-        packet_recv_disable(pipe_conn->packet);
-
-        /*
-         * TODO: check it's a root (uid == 0) pipe
-         */
-
-        ZERO_STRUCT(rep);
-        rep.level = 0;
-        rep.status = NT_STATUS_INTERNAL_ERROR;
-
-        DEBUG(10,("named_pipe_auth: req_blob.length[%u]\n",
-                  (unsigned int)req_blob.length));
-        dump_data(11, req_blob.data, req_blob.length);
-
-        /* parse the passed credentials */
-        ndr_err = ndr_pull_struct_blob_all(
-                        &req_blob,
-                        pipe_conn,
-                        lp_iconv_convenience(conn->lp_ctx),
-                        &req,
-                        (ndr_pull_flags_fn_t)ndr_pull_named_pipe_auth_req);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                rep.status = ndr_map_error2ntstatus(ndr_err);
-                DEBUG(2, ("Could not unmarshall named_pipe_auth_req: %s\n",
-                          nt_errstr(rep.status)));
-                goto reply;
-        }
-
-        if (DEBUGLVL(10)) {
-                NDR_PRINT_DEBUG(named_pipe_auth_req, &req);
-        }
-
-        if (strcmp(NAMED_PIPE_AUTH_MAGIC, req.magic) != 0) {
-                DEBUG(2, ("named_pipe_auth_req: invalid magic '%s' != %s\n",
-                          req.magic, NAMED_PIPE_AUTH_MAGIC));
-                rep.status = NT_STATUS_INVALID_PARAMETER;
-                goto reply;
-        }
-
-        switch (req.level) {
-        case 0:
-                /*
-                 * anon connection, we don't create a session info
-                 * and leave it NULL
-                 */
-                rep.level = 0;
-                rep.status = NT_STATUS_OK;
-                break;
-        case 1:
-                val.sam3 = &req.info.info1;
-
-                rep.level = 1;
-                rep.status = make_server_info_netlogon_validation(pipe_conn,
-                                                                  "TODO",
-                                                                  3, &val,
-                                                                  &server_info);
-                if (!NT_STATUS_IS_OK(rep.status)) {
-                        DEBUG(2, ("make_server_info_netlogon_validation returned "
-                                  "%s\n", nt_errstr(rep.status)));
-                        goto reply;
-                }
-
-                /* setup the session_info on the connection */
-                rep.status = auth_generate_session_info(conn,
-                                                        conn->event.ctx,
-                                                        conn->lp_ctx,
-                                                        server_info,
-                                                        &conn->session_info);
-                if (!NT_STATUS_IS_OK(rep.status)) {
-                        DEBUG(2, ("auth_generate_session_info failed: %s\n",
-                                  nt_errstr(rep.status)));
-                        goto reply;
-                }
-
-                break;
-        case 2:
-                rep.level = 2;
-                rep.info.info2.file_type = FILE_TYPE_MESSAGE_MODE_PIPE;
-                rep.info.info2.device_state = 0xff | 0x0400 | 0x0100;
-                rep.info.info2.allocation_size = 4096;
-
-                if (!req.info.info2.sam_info3) {
-                        /*
-                         * anon connection, we don't create a session info
-                         * and leave it NULL
-                         */
-                        rep.status = NT_STATUS_OK;
-                        break;
-                }
-
-                val.sam3 = req.info.info2.sam_info3;
-
-                rep.status = make_server_info_netlogon_validation(pipe_conn,
-                                                val.sam3->base.account_name.string,
-                                                3, &val, &server_info);
-                if (!NT_STATUS_IS_OK(rep.status)) {
-                        DEBUG(2, ("make_server_info_netlogon_validation returned "
-                                  "%s\n", nt_errstr(rep.status)));
-                        goto reply;
-                }
-
-                /* setup the session_info on the connection */
-                rep.status = auth_generate_session_info(conn,
-                                                        conn->event.ctx,
-                                                        conn->lp_ctx,
-                                                        server_info,
-                                                        &conn->session_info);
-                if (!NT_STATUS_IS_OK(rep.status)) {
-                        DEBUG(2, ("auth_generate_session_info failed: %s\n",
-                                  nt_errstr(rep.status)));
-                        goto reply;
-                }
-
-                conn->session_info->session_key = data_blob_const(req.info.info2.session_key,
-                                                        req.info.info2.session_key_length);
-                talloc_steal(conn->session_info, req.info.info2.session_key);
-
-                break;
-        case 3:
-                rep.level = 3;
-                rep.info.info3.file_type = FILE_TYPE_MESSAGE_MODE_PIPE;
-                rep.info.info3.device_state = 0xff | 0x0400 | 0x0100;
-                rep.info.info3.allocation_size = 4096;
-
-                if (!req.info.info3.sam_info3) {
-                        /*
-                         * anon connection, we don't create a session info
-                         * and leave it NULL
-                         */
-                        rep.status = NT_STATUS_OK;
-                        break;
-                }
-
-                val.sam3 = req.info.info3.sam_info3;
-
-                rep.status = make_server_info_netlogon_validation(pipe_conn,
-                                                val.sam3->base.account_name.string,
-                                                3, &val, &server_info);
-                if (!NT_STATUS_IS_OK(rep.status)) {
-                        DEBUG(2, ("make_server_info_netlogon_validation returned "
-                                  "%s\n", nt_errstr(rep.status)));
-                        goto reply;
-                }
-
-                /* setup the session_info on the connection */
-                rep.status = auth_generate_session_info(conn,
-                                                        conn->event.ctx,
-                                                        conn->lp_ctx,
-                                                        server_info,
-                                                        &conn->session_info);
-                if (!NT_STATUS_IS_OK(rep.status)) {
-                        DEBUG(2, ("auth_generate_session_info failed: %s\n",
-                                  nt_errstr(rep.status)));
-                        goto reply;
-                }
-
-                if (req.info.info3.gssapi_delegated_creds_length) {
-                        OM_uint32 minor_status;
-                        gss_buffer_desc cred_token;
-                        gss_cred_id_t cred_handle;
-                        int ret;
-
-                        DEBUG(10, ("named_pipe_auth: delegated credentials supplied by client\n"));
-
-                        cred_token.value = req.info.info3.gssapi_delegated_creds;
-                        cred_token.length = req.info.info3.gssapi_delegated_creds_length;
-
-                        ret = gss_import_cred(&minor_status,
-                                               &cred_token,
-                                               &cred_handle);
-                        if (ret != GSS_S_COMPLETE) {
-                                rep.status = NT_STATUS_INTERNAL_ERROR;
-                                goto reply;
-                        }
-
-                        conn->session_info->credentials = cli_credentials_init(conn->session_info);
-                        if (!conn->session_info->credentials) {
-                                rep.status = NT_STATUS_NO_MEMORY;
-                                goto reply;
-                        }
-
-                        cli_credentials_set_conf(conn->session_info->credentials,
-                                                 conn->lp_ctx);
-                        /* Just so we don't segfault trying to get at a username */
-                        cli_credentials_set_anonymous(conn->session_info->credentials);
-
-                        ret = cli_credentials_set_client_gss_creds(conn->session_info->credentials,
-                                                                   conn->event.ctx,
-                                                                   conn->lp_ctx,
-                                                                   cred_handle,
-                                                                   CRED_SPECIFIED);
-                        if (ret) {
-                                rep.status = NT_STATUS_INTERNAL_ERROR;
-                                goto reply;
-                        }
-
-                        /* This credential handle isn't useful for password authentication, so ensure nobody tries to do that */
-                        cli_credentials_set_kerberos_state(conn->session_info->credentials,
-                                                           CRED_MUST_USE_KERBEROS);
-                }
-
-                conn->session_info->session_key = data_blob_const(req.info.info3.session_key,
-                                                        req.info.info3.session_key_length);
-                talloc_steal(conn->session_info, req.info.info3.session_key);
-
-                break;
-        default:
-                DEBUG(2, ("named_pipe_auth_req: unknown level %u\n",
-                          req.level));
-                rep.level = 0;
-                rep.status = NT_STATUS_INVALID_LEVEL;
-                goto reply;
-        }
-
-reply:
-        /* create the output */
-        ndr_err = ndr_push_struct_blob(&rep_blob, pipe_conn,
-                        lp_iconv_convenience(conn->lp_ctx),
-                        &rep,
-                        (ndr_push_flags_fn_t)ndr_push_named_pipe_auth_rep);
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
-                status = ndr_map_error2ntstatus(ndr_err);
-                DEBUG(2, ("Could not marshall named_pipe_auth_rep: %s\n",
-                          nt_errstr(status)));
-                return status;
-        }
-
-        DEBUG(10,("named_pipe_auth reply[%u]\n", (unsigned)rep_blob.length));
-        dump_data(11, rep_blob.data, rep_blob.length);
-        if (DEBUGLVL(10)) {
-                NDR_PRINT_DEBUG(named_pipe_auth_rep, &rep);
-        }
-
-        pipe_conn->status = rep.status;
-        status = packet_send_callback(pipe_conn->packet, rep_blob,
-                                      named_pipe_handover_connection,
-                                      pipe_conn);
-        if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(0, ("packet_send_callback returned %s\n",
-                          nt_errstr(status)));
-                return status;
-        }
-
-        return NT_STATUS_OK;
+        DEBUG(10, ("named pipe connection [%s] established\n",
+                   conn->ops->name));
+
+        talloc_free(tmp_ctx);
+        return;
+
+out:
+        talloc_free(tmp_ctx);
+        if (!reason) {
+                reason = "Internal error";
+        }
+        stream_terminate_connection(conn, reason);
 }
 
@@ -354 +160 @@
 static void named_pipe_recv(struct stream_connection *conn, uint16_t flags)
 {
-        struct named_pipe_connection *pipe_conn = talloc_get_type(
-                conn->private_data, struct named_pipe_connection);
-
-        DEBUG(10,("named_pipe_recv\n"));
-
-        packet_recv(pipe_conn->packet);
+        stream_terminate_connection(conn, "named_pipe_recv: called");
 }
 
@@ -367 +168 @@
 static void named_pipe_send(struct stream_connection *conn, uint16_t flags)
 {
-        struct named_pipe_connection *pipe_conn = talloc_get_type(
-                conn->private_data, struct named_pipe_connection);
-
-        packet_queue_run(pipe_conn->packet);
-}
-
-/*
-  handle socket recv errors
-*/
-static void named_pipe_recv_error(void *private_data, NTSTATUS status)
-{
-        struct named_pipe_connection *pipe_conn = talloc_get_type(
-                private_data, struct named_pipe_connection);
-
-        stream_terminate_connection(pipe_conn->connection, nt_errstr(status));
-}
-
-static NTSTATUS named_pipe_full_request(void *private_data, DATA_BLOB blob, size_t *size)
-{
-        if (blob.length < 8) {
-                return STATUS_MORE_ENTRIES;
-        }
-
-        if (memcmp(NAMED_PIPE_AUTH_MAGIC, &blob.data[4], 4) != 0) {
-                DEBUG(0,("named_pipe_full_request: wrong protocol\n"));
-                *size = blob.length;
-                /* the error will be handled in named_pipe_recv_auth_request */
-                return NT_STATUS_OK;
-        }
-
-        *size = 4 + RIVAL(blob.data, 0);
-        if (*size > blob.length) {
-                return STATUS_MORE_ENTRIES;
-        }
-
-        return NT_STATUS_OK;
-}
-
-static void named_pipe_accept(struct stream_connection *conn)
-{
-        struct named_pipe_socket *pipe_sock = talloc_get_type(
-                conn->private_data, struct named_pipe_socket);
-        struct named_pipe_connection *pipe_conn;
-
-        DEBUG(5,("named_pipe_accept\n"));
-
-        pipe_conn = talloc_zero(conn, struct named_pipe_connection);
-        if (!pipe_conn) {
-                stream_terminate_connection(conn, "out of memory");
-                return;
-        }
-
-        pipe_conn->packet = packet_init(pipe_conn);
-        if (!pipe_conn->packet) {
-                stream_terminate_connection(conn, "out of memory");
-                return;
-        }
-        packet_set_private(pipe_conn->packet, pipe_conn);
-        packet_set_socket(pipe_conn->packet, conn->socket);
-        packet_set_callback(pipe_conn->packet, named_pipe_recv_auth_request);
-        packet_set_full_request(pipe_conn->packet, named_pipe_full_request);
-        packet_set_error_handler(pipe_conn->packet, named_pipe_recv_error);
-        packet_set_event_context(pipe_conn->packet, conn->event.ctx);
-        packet_set_fde(pipe_conn->packet, conn->event.fde);
-        packet_set_serialise(pipe_conn->packet);
-        packet_set_initial_read(pipe_conn->packet, 8);
-
-        pipe_conn->pipe_sock = pipe_sock;
-
-        pipe_conn->connection = conn;
-        conn->private_data = pipe_conn;
+        stream_terminate_connection(conn, "named_pipe_send: called");
 }
 
@@ -447 +178 @@
 };
 
-NTSTATUS stream_setup_named_pipe(struct tevent_context *event_context,
-                                 struct loadparm_context *lp_ctx,
-                                 const struct model_ops *model_ops,
-                                 const struct stream_server_ops *stream_ops,
-                                 const char *pipe_name,
-                                 void *private_data)
+NTSTATUS tstream_setup_named_pipe(TALLOC_CTX *mem_ctx,
+                                  struct tevent_context *event_context,
+                                  struct loadparm_context *lp_ctx,
+                                  const struct model_ops *model_ops,
+                                  const struct stream_server_ops *stream_ops,
+                                  const char *pipe_name,
+                                  void *private_data)
 {
         char *dirname;
@@ -458 +190 @@
         NTSTATUS status = NT_STATUS_NO_MEMORY;;
 
-        pipe_sock = talloc(event_context, struct named_pipe_socket);
+        pipe_sock = talloc(mem_ctx, struct named_pipe_socket);
         if (pipe_sock == NULL) {
                 goto fail;
@@ -469 +201 @@
         }
 
-        dirname = talloc_asprintf(pipe_sock, "%s/np", lp_ncalrpc_dir(lp_ctx));
+        if (!directory_create_or_exist(lpcfg_ncalrpc_dir(lp_ctx), geteuid(), 0755)) {
+                status = map_nt_error_from_unix(errno);
+                DEBUG(0,(__location__ ": Failed to create ncalrpc pipe directory '%s' - %s\n",
+                         lpcfg_ncalrpc_dir(lp_ctx), nt_errstr(status)));
+                goto fail;
+        }
+
+        dirname = talloc_asprintf(pipe_sock, "%s/np", lpcfg_ncalrpc_dir(lp_ctx));
         if (dirname == NULL) {
                 goto fail;
@@ -493 +232 @@
         talloc_free(dirname);
 
-        pipe_sock->ops          = stream_ops;
-        pipe_sock->private_data = talloc_reference(pipe_sock, private_data);
-
-        status = stream_setup_socket(event_context,
+        pipe_sock->ops = stream_ops;
+        pipe_sock->private_data = private_data;
+
+        status = stream_setup_socket(pipe_sock,
+                                     event_context,
                                      lp_ctx,
                                      model_ops,

vendor/current/source4/smbd/service_stream.c

@@ -27 +27 @@
 #include "cluster/cluster.h"
 #include "param/param.h"
+#include "../lib/tsocket/tsocket.h"
 
 /* the range of ports to try for dcerpc over tcp endpoints */
@@ -98 +99 @@
 }
 
-static void stream_io_handler_fde(struct tevent_context *ev, struct tevent_fd *fde, 
+void stream_io_handler_fde(struct tevent_context *ev, struct tevent_fd *fde,
                                   uint16_t flags, void *private_data)
 {
@@ -121 +122 @@
                                      struct loadparm_context *lp_ctx,
                                      const struct model_ops *model_ops,
-                                     struct socket_context *sock,
                                      const struct stream_server_ops *stream_ops,
                                      struct messaging_context *msg_ctx,
@@ -132 +132 @@
         NT_STATUS_HAVE_NO_MEMORY(srv_conn);
 
-        talloc_steal(srv_conn, sock);
-
         srv_conn->private_data  = private_data;
         srv_conn->model_ops     = model_ops;
-        srv_conn->socket        = sock;
+        srv_conn->socket        = NULL;
         srv_conn->server_id     = cluster_id(0, 0);
         srv_conn->ops           = stream_ops;
@@ -142 +140 @@
         srv_conn->event.ctx     = ev;
         srv_conn->lp_ctx        = lp_ctx;
-        srv_conn->event.fde     = tevent_add_fd(ev, srv_conn, socket_get_fd(sock),
-                                                TEVENT_FD_READ,
-                                                stream_io_handler_fde, srv_conn);
-        if (!srv_conn->event.fde) {
-                talloc_free(srv_conn);
-                return NT_STATUS_NO_MEMORY;
-        }
+        srv_conn->event.fde     = NULL;
 
         *_srv_conn = srv_conn;
@@ -165 +157 @@
         struct stream_socket *stream_socket = talloc_get_type(private_data, struct stream_socket);
         struct stream_connection *srv_conn;
-        struct socket_address *c, *s;
 
         srv_conn = talloc_zero(ev, struct stream_connection);
@@ -183 +174 @@
         srv_conn->lp_ctx        = lp_ctx;
 
-        if (!socket_check_access(sock, "smbd", lp_hostsallow(NULL, lp_default_service(lp_ctx)), lp_hostsdeny(NULL, lp_default_service(lp_ctx)))) {
+        if (!socket_check_access(sock, "smbd", lpcfg_hostsallow(NULL, lpcfg_default_service(lp_ctx)), lpcfg_hostsdeny(NULL, lpcfg_default_service(lp_ctx)))) {
                 stream_terminate_connection(srv_conn, "denied by access rules");
                 return;
@@ -197 +188 @@
         /* setup to receive internal messages on this connection */
         srv_conn->msg_ctx = messaging_init(srv_conn, 
-                                           lp_messaging_path(srv_conn, lp_ctx),
-                                           srv_conn->server_id, 
-                                           lp_iconv_convenience(lp_ctx),
-                                           ev);
+                                           lpcfg_messaging_path(srv_conn, lp_ctx),
+                                           srv_conn->server_id, ev);
         if (!srv_conn->msg_ctx) {
                 stream_terminate_connection(srv_conn, "messaging_init() failed");
@@ -206 +195 @@
         }
 
-        c = socket_get_peer_addr(sock, ev);
-        s = socket_get_my_addr(sock, ev);
-        if (s && c) {
+        srv_conn->remote_address = socket_get_remote_addr(srv_conn->socket, srv_conn);
+        if (!srv_conn->remote_address) {
+                stream_terminate_connection(srv_conn, "socket_get_remote_addr() failed");
+                return;
+        }
+
+        srv_conn->local_address = socket_get_local_addr(srv_conn->socket, srv_conn);
+        if (!srv_conn->local_address) {
+                stream_terminate_connection(srv_conn, "socket_get_local_addr() failed");
+                return;
+        }
+
+        {
+                TALLOC_CTX *tmp_ctx;
                 const char *title;
-                title = talloc_asprintf(s, "conn[%s] c[%s:%u] s[%s:%u] server_id[%s]",
+
+                tmp_ctx = talloc_new(srv_conn);
+
+                title = talloc_asprintf(tmp_ctx, "conn[%s] c[%s] s[%s] server_id[%s]",
                                         stream_socket->ops->name, 
-                                        c->addr, c->port, s->addr, s->port,
-                                        cluster_id_string(s, server_id));
+                                        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));
                 if (title) {
                         stream_connection_set_title(srv_conn, title);
                 }
-        }
-        talloc_free(c);
-        talloc_free(s);
+                talloc_free(tmp_ctx);
+        }
 
         /* we're now ready to start receiving events on this stream */
@@ -240 +243 @@
            connection.  When done, it calls stream_new_connection()
            with the newly created socket */
-        stream_socket->model_ops->accept_connection(ev, stream_socket->lp_ctx, 
+        stream_socket->model_ops->accept_connection(ev, stream_socket->lp_ctx,
                                                     stream_socket->sock, 
                                                     stream_new_connection, stream_socket);
@@ -253 +256 @@
          to the socket implementation - JRV20070903
  */
-NTSTATUS stream_setup_socket(struct tevent_context *event_context,
+NTSTATUS stream_setup_socket(TALLOC_CTX *mem_ctx,
+                             struct tevent_context *event_context,
                              struct loadparm_context *lp_ctx,
                              const struct model_ops *model_ops,
@@ -269 +273 @@
         int i;
 
-        stream_socket = talloc_zero(event_context, struct stream_socket);
+        stream_socket = talloc_zero(mem_ctx, struct stream_socket);
         NT_STATUS_HAVE_NO_MEMORY(stream_socket);
 

vendor/current/source4/smbd/service_stream.h

@@ -24 +24 @@
 #define __SERVICE_STREAM_H__
 
-#include "librpc/gen_ndr/server_id.h"
+#include "librpc/gen_ndr/server_id4.h"
 
 /* modules can use the following to determine if the interface has changed
@@ -51 +51 @@
         struct loadparm_context *lp_ctx;
 
+        struct tstream_context *tstream;
+        struct tsocket_address *local_address;
+        struct tsocket_address *remote_address;
+
         /*
          * this transport layer session info, normally NULL
@@ -71 +75 @@
 };
 
+void stream_terminate_connection(struct stream_connection *srv_conn, const char *reason);
+
 #endif /* __SERVICE_STREAM_H__ */

vendor/current/source4/smbd/service_task.c

@@ -24 +24 @@
 #include "lib/messaging/irpc.h"
 #include "param/param.h"
-#include "librpc/gen_ndr/ndr_irpc.h"
+#include "librpc/gen_ndr/ndr_irpc_c.h"
 
 /*
@@ -36 +36 @@
 
         if (fatal) {
+                struct dcerpc_binding_handle *irpc_handle;
                 struct samba_terminate r;
-                struct server_id *sid;
 
-                sid = irpc_servers_byname(task->msg_ctx, task, "samba");
-
-                r.in.reason = reason;
-                IRPC_CALL(task->msg_ctx, sid[0],
-                          irpc, SAMBA_TERMINATE,
-                          &r, NULL);
+                irpc_handle = irpc_binding_handle_by_name(task, task->msg_ctx,
+                                                          "samba", &ndr_table_irpc);
+                if (irpc_handle != NULL) {
+                        r.in.reason = reason;
+                        dcerpc_samba_terminate_r(irpc_handle, task, &r);
+                }
         }
 
@@ -80 +80 @@
 
         task->msg_ctx = messaging_init(task, 
-                                       lp_messaging_path(task, task->lp_ctx),
+                                       lpcfg_messaging_path(task, task->lp_ctx),
                                        task->server_id, 
-                                       lp_iconv_convenience(task->lp_ctx),
                                        task->event_ctx);
         if (!task->msg_ctx) {

vendor/current/source4/smbd/service_task.h

@@ -23 +23 @@
 #define __SERVICE_TASK_H__ 
 
-#include "librpc/gen_ndr/server_id.h"
+#include "librpc/gen_ndr/server_id4.h"
 
 struct task_server {