Changeset 740 for vendor/current/source3/smbd/process.c

Timestamp:

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

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

File:

• vendor/current/source3/smbd/process.c (modified) (78 diffs)

vendor/current/source3/smbd/process.c ¶

@@ -4 +4 @@
    Copyright (C) Andrew Tridgell 1992-1998
    Copyright (C) Volker Lendecke 2005-2007
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
@@ -20 +20 @@
 
 #include "includes.h"
+#include "../lib/tsocket/tsocket.h"
+#include "system/filesys.h"
+#include "smbd/smbd.h"
 #include "smbd/globals.h"
-#include "../librpc/gen_ndr/srv_dfs.h"
-#include "../librpc/gen_ndr/srv_dssetup.h"
-#include "../librpc/gen_ndr/srv_echo.h"
-#include "../librpc/gen_ndr/srv_eventlog.h"
-#include "../librpc/gen_ndr/srv_initshutdown.h"
-#include "../librpc/gen_ndr/srv_lsa.h"
-#include "../librpc/gen_ndr/srv_netlogon.h"
-#include "../librpc/gen_ndr/srv_ntsvcs.h"
-#include "../librpc/gen_ndr/srv_samr.h"
-#include "../librpc/gen_ndr/srv_spoolss.h"
-#include "../librpc/gen_ndr/srv_srvsvc.h"
-#include "../librpc/gen_ndr/srv_svcctl.h"
-#include "../librpc/gen_ndr/srv_winreg.h"
-#include "../librpc/gen_ndr/srv_wkssvc.h"
+#include "librpc/gen_ndr/netlogon.h"
+#include "../lib/async_req/async_sock.h"
+#include "ctdbd_conn.h"
+#include "../lib/util/select.h"
+#include "printing/pcap.h"
+#include "system/select.h"
+#include "passdb.h"
+#include "auth.h"
+#include "messages.h"
+#include "smbprofile.h"
+#include "rpc_server/spoolss/srv_spoolss_nt.h"
+#include "libsmb/libsmb.h"
 
 extern bool global_machine_password_needs_changing;
@@ -40 +41 @@
 static void construct_reply_common(struct smb_request *req, const char *inbuf,
                                    char *outbuf);
+static struct pending_message_list *get_deferred_open_message_smb(uint64_t mid);
+
+static bool smbd_lock_socket_internal(struct smbd_server_connection *sconn)
+{
+        bool ok;
+
+        if (sconn->smb1.echo_handler.socket_lock_fd == -1) {
+                return true;
+        }
+
+        sconn->smb1.echo_handler.ref_count++;
+
+        if (sconn->smb1.echo_handler.ref_count > 1) {
+                return true;
+        }
+
+        DEBUG(10,("pid[%d] wait for socket lock\n", (int)sys_getpid()));
+
+        do {
+                ok = fcntl_lock(
+                        sconn->smb1.echo_handler.socket_lock_fd,
+                        SMB_F_SETLKW, 0, 0, F_WRLCK);
+        } while (!ok && (errno == EINTR));
+
+        if (!ok) {
+                DEBUG(1, ("fcntl_lock failed: %s\n", strerror(errno)));
+                return false;
+        }
+
+        DEBUG(10,("pid[%d] got for socket lock\n", (int)sys_getpid()));
+
+        return true;
+}
+
+void smbd_lock_socket(struct smbd_server_connection *sconn)
+{
+        if (!smbd_lock_socket_internal(sconn)) {
+                exit_server_cleanly("failed to lock socket");
+        }
+}
+
+static bool smbd_unlock_socket_internal(struct smbd_server_connection *sconn)
+{
+        bool ok;
+
+        if (sconn->smb1.echo_handler.socket_lock_fd == -1) {
+                return true;
+        }
+
+        sconn->smb1.echo_handler.ref_count--;
+
+        if (sconn->smb1.echo_handler.ref_count > 0) {
+                return true;
+        }
+
+        do {
+                ok = fcntl_lock(
+                        sconn->smb1.echo_handler.socket_lock_fd,
+                        SMB_F_SETLKW, 0, 0, F_UNLCK);
+        } while (!ok && (errno == EINTR));
+
+        if (!ok) {
+                DEBUG(1, ("fcntl_lock failed: %s\n", strerror(errno)));
+                return false;
+        }
+
+        DEBUG(10,("pid[%d] unlocked socket\n", (int)sys_getpid()));
+
+        return true;
+}
+
+void smbd_unlock_socket(struct smbd_server_connection *sconn)
+{
+        if (!smbd_unlock_socket_internal(sconn)) {
+                exit_server_cleanly("failed to unlock socket");
+        }
+}
 
 /* Accessor function for smb_read_error for smbd functions. */
@@ -47 +125 @@
 ****************************************************************************/
 
-bool srv_send_smb(int fd, char *buffer,
+bool srv_send_smb(struct smbd_server_connection *sconn, char *buffer,
                   bool do_signing, uint32_t seqnum,
                   bool do_encrypt,
@@ -57 +135 @@
         char *buf_out = buffer;
 
+        smbd_lock_socket(sconn);
+
         if (do_signing) {
                 /* Sign the outgoing packet if required. */
-                srv_calculate_sign_mac(smbd_server_conn, buf_out, seqnum);
+                srv_calculate_sign_mac(sconn, buf_out, seqnum);
         }
 
@@ -74 +154 @@
         len = smb_len(buf_out) + 4;
 
-        ret = write_data(fd,buf_out+nwritten,len - nwritten);
+        ret = write_data(sconn->sock, buf_out+nwritten, len - nwritten);
         if (ret <= 0) {
-                DEBUG(0,("Error writing %d bytes to client. %d. (%s)\n",
-                         (int)len,(int)ret, strerror(errno) ));
+
+                char addr[INET6_ADDRSTRLEN];
+                /*
+                 * Try and give an error message saying what
+                 * client failed.
+                 */
+                DEBUG(1,("pid[%d] Error writing %d bytes to client %s. %d. (%s)\n",
+                         (int)sys_getpid(), (int)len,
+                         get_peer_addr(sconn->sock, addr, sizeof(addr)),
+                         (int)ret, strerror(errno) ));
+
                 srv_free_enc_buffer(buf_out);
                 goto out;
@@ -86 +175 @@
 out:
         SMB_PERFCOUNT_END(pcd);
+
+        smbd_unlock_socket(sconn);
         return true;
 }
@@ -139 +230 @@
                                       unsigned int timeout, ssize_t len)
 {
+        NTSTATUS status;
+
         if (len <= 0) {
                 return NT_STATUS_OK;
         }
 
-        return read_fd_with_timeout(fd, buffer, len, len, timeout, NULL);
+        status = read_fd_with_timeout(fd, buffer, len, len, timeout, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                char addr[INET6_ADDRSTRLEN];
+                DEBUG(0, ("read_fd_with_timeout failed for client %s read "
+                          "error = %s.\n",
+                          get_peer_addr(fd, addr, sizeof(addr)),
+                          nt_errstr(status)));
+        }
+        return status;
 }
 
@@ -164 +265 @@
 static NTSTATUS receive_smb_raw_talloc_partial_read(TALLOC_CTX *mem_ctx,
                                                     const char lenbuf[4],
-                                                    int fd, char **buffer,
+                                                    struct smbd_server_connection *sconn,
+                                                    int sock,
+                                                    char **buffer,
                                                     unsigned int timeout,
                                                     size_t *p_unread,
@@ -178 +281 @@
 
         status = read_fd_with_timeout(
-                fd, writeX_header + 4,
+                sock, writeX_header + 4,
                 STANDARD_WRITE_AND_X_HEADER_SIZE,
                 STANDARD_WRITE_AND_X_HEADER_SIZE,
@@ -184 +287 @@
 
         if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("read_fd_with_timeout failed for client %s read "
+                          "error = %s.\n", sconn->client_id.addr,
+                          nt_errstr(status)));
                 return status;
         }
@@ -192 +298 @@
          */
 
-        if (is_valid_writeX_buffer((uint8_t *)writeX_header)) {
+        if (is_valid_writeX_buffer(sconn, (uint8_t *)writeX_header)) {
                 /*
                  * If the data offset is beyond what
@@ -202 +308 @@
                 if (doff > STANDARD_WRITE_AND_X_HEADER_SIZE) {
                         size_t drain = doff - STANDARD_WRITE_AND_X_HEADER_SIZE;
-                        if (drain_socket(smbd_server_fd(), drain) != drain) {
+                        if (drain_socket(sock, drain) != drain) {
                                 smb_panic("receive_smb_raw_talloc_partial_read:"
                                         " failed to drain pending bytes");
@@ -257 +363 @@
         if(toread > 0) {
                 status = read_packet_remainder(
-                        fd, (*buffer) + 4 + STANDARD_WRITE_AND_X_HEADER_SIZE,
+                        sock,
+                        (*buffer) + 4 + STANDARD_WRITE_AND_X_HEADER_SIZE,
                         timeout, toread);
 
@@ -271 +378 @@
 }
 
-static NTSTATUS receive_smb_raw_talloc(TALLOC_CTX *mem_ctx, int fd,
+static NTSTATUS receive_smb_raw_talloc(TALLOC_CTX *mem_ctx,
+                                       struct smbd_server_connection *sconn,
+                                       int sock,
                                        char **buffer, unsigned int timeout,
                                        size_t *p_unread, size_t *plen)
@@ -282 +391 @@
         *p_unread = 0;
 
-        status = read_smb_length_return_keepalive(fd, lenbuf, timeout, &len);
+        status = read_smb_length_return_keepalive(sock, lenbuf, timeout,
+                                                  &len);
         if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(10, ("receive_smb_raw: %s\n", nt_errstr(status)));
                 return status;
         }
@@ -291 +400 @@
             (smb_len_large(lenbuf) > /* Could be a UNIX large writeX. */
                 (min_recv_size + STANDARD_WRITE_AND_X_HEADER_SIZE)) &&
-            !srv_is_signing_active(smbd_server_conn)) {
+            !srv_is_signing_active(sconn) &&
+            sconn->smb1.echo_handler.trusted_fde == NULL) {
 
                 return receive_smb_raw_talloc_partial_read(
-                        mem_ctx, lenbuf, fd, buffer, timeout, p_unread, plen);
+                        mem_ctx, lenbuf, sconn, sock, buffer, timeout,
+                        p_unread, plen);
         }
 
@@ -315 +426 @@
         memcpy(*buffer, lenbuf, sizeof(lenbuf));
 
-        status = read_packet_remainder(fd, (*buffer)+4, timeout, len);
+        status = read_packet_remainder(sock, (*buffer)+4, timeout, len);
         if (!NT_STATUS_IS_OK(status)) {
                 return status;
@@ -324 +435 @@
 }
 
-static NTSTATUS receive_smb_talloc(TALLOC_CTX *mem_ctx, int fd,
+static NTSTATUS receive_smb_talloc(TALLOC_CTX *mem_ctx,
+                                   struct smbd_server_connection *sconn,
+                                   int sock,
                                    char **buffer, unsigned int timeout,
                                    size_t *p_unread, bool *p_encrypted,
                                    size_t *p_len,
-                                   uint32_t *seqnum)
+                                   uint32_t *seqnum,
+                                   bool trusted_channel)
 {
         size_t len = 0;
@@ -335 +449 @@
         *p_encrypted = false;
 
-        status = receive_smb_raw_talloc(mem_ctx, fd, buffer, timeout,
+        status = receive_smb_raw_talloc(mem_ctx, sconn, sock, buffer, timeout,
                                         p_unread, &len);
         if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("read_smb_length_return_keepalive failed for "
+                          "client %s read error = %s.\n",
+                          sconn->client_id.addr, nt_errstr(status)));
                 return status;
         }
@@ -353 +470 @@
 
         /* Check the incoming SMB signature. */
-        if (!srv_check_sign_mac(smbd_server_conn, *buffer, seqnum)) {
+        if (!srv_check_sign_mac(sconn, *buffer, seqnum, trusted_channel)) {
                 DEBUG(0, ("receive_smb: SMB Signature verification failed on "
                           "incoming packet!\n"));
@@ -367 +484 @@
  */
 
-void init_smb_request(struct smb_request *req,
-                        const uint8 *inbuf,
-                        size_t unread_bytes,
-                        bool encrypted)
-{
-        struct smbd_server_connection *sconn = smbd_server_conn;
+static bool init_smb_request(struct smb_request *req,
+                             struct smbd_server_connection *sconn,
+                             const uint8 *inbuf,
+                             size_t unread_bytes, bool encrypted,
+                             uint32_t seqnum)
+{
         size_t req_size = smb_len(inbuf) + 4;
         /* Ensure we have at least smb_size bytes. */
@@ -378 +495 @@
                 DEBUG(0,("init_smb_request: invalid request size %u\n",
                         (unsigned int)req_size ));
-                exit_server_cleanly("Invalid SMB request");
+                return false;
         }
         req->cmd    = CVAL(inbuf, smb_com);
         req->flags2 = SVAL(inbuf, smb_flg2);
         req->smbpid = SVAL(inbuf, smb_pid);
-        req->mid    = SVAL(inbuf, smb_mid);
-        req->seqnum = 0;
+        req->mid    = (uint64_t)SVAL(inbuf, smb_mid);
+        req->seqnum = seqnum;
         req->vuid   = SVAL(inbuf, smb_uid);
         req->tid    = SVAL(inbuf, smb_tid);
@@ -393 +510 @@
         req->unread_bytes = unread_bytes;
         req->encrypted = encrypted;
+        req->sconn = sconn;
         req->conn = conn_find(sconn,req->tid);
         req->chain_fsp = NULL;
         req->chain_outbuf = NULL;
         req->done = false;
+        req->smb2req = NULL;
         smb_init_perfcount_data(&req->pcd);
 
@@ -404 +523 @@
                         (unsigned int)req->wct,
                         (unsigned int)req_size));
-                exit_server_cleanly("Invalid SMB request");
+                return false;
         }
         /* Ensure bcc is correct. */
@@ -413 +532 @@
                         (unsigned int)req->wct,
                         (unsigned int)req_size));
-                exit_server_cleanly("Invalid SMB request");
+                return false;
         }
 
         req->outbuf = NULL;
+        return true;
 }
 
@@ -432 +552 @@
                                            struct pending_message_list);
         TALLOC_CTX *mem_ctx = talloc_tos();
-        uint16_t mid = SVAL(msg->buf.data,smb_mid);
+        uint64_t mid = (uint64_t)SVAL(msg->buf.data,smb_mid);
         uint8_t *inbuf;
 
@@ -444 +564 @@
         /* We leave this message on the queue so the open code can
            know this is a retry. */
-        DEBUG(5,("smbd_deferred_open_timer: trigger mid %u.\n",
-                (unsigned int)mid ));
+        DEBUG(5,("smbd_deferred_open_timer: trigger mid %llu.\n",
+                (unsigned long long)mid ));
 
         /* Mark the message as processed so this is not
@@ -456 +576 @@
 
         /* If it's still there and was processed, remove it. */
-        msg = get_open_deferred_message(mid);
+        msg = get_deferred_open_message_smb(mid);
         if (msg && msg->processed) {
-                remove_deferred_open_smb_message(mid);
+                remove_deferred_open_message_smb(mid);
         }
 }
@@ -528 +648 @@
 ****************************************************************************/
 
-void remove_deferred_open_smb_message(uint16 mid)
+void remove_deferred_open_message_smb(uint64_t mid)
 {
         struct pending_message_list *pml;
 
+        if (smbd_server_conn->using_smb2) {
+                remove_deferred_open_message_smb2(smbd_server_conn, mid);
+                return;
+        }
+
         for (pml = deferred_open_queue; pml; pml = pml->next) {
-                if (mid == SVAL(pml->buf.data,smb_mid)) {
-                        DEBUG(10,("remove_deferred_open_smb_message: "
-                                  "deleting mid %u len %u\n",
-                                  (unsigned int)mid,
+                if (mid == (uint64_t)SVAL(pml->buf.data,smb_mid)) {
+                        DEBUG(10,("remove_deferred_open_message_smb: "
+                                  "deleting mid %llu len %u\n",
+                                  (unsigned long long)mid,
                                   (unsigned int)pml->buf.length ));
                         DLIST_REMOVE(deferred_open_queue, pml);
@@ -550 +675 @@
 ****************************************************************************/
 
-void schedule_deferred_open_smb_message(uint16 mid)
+void schedule_deferred_open_message_smb(uint64_t mid)
 {
         struct pending_message_list *pml;
         int i = 0;
 
+        if (smbd_server_conn->using_smb2) {
+                schedule_deferred_open_message_smb2(smbd_server_conn, mid);
+                return;
+        }
+
         for (pml = deferred_open_queue; pml; pml = pml->next) {
-                uint16 msg_mid = SVAL(pml->buf.data,smb_mid);
-
-                DEBUG(10,("schedule_deferred_open_smb_message: [%d] msg_mid = %u\n", i++,
-                        (unsigned int)msg_mid ));
+                uint64_t msg_mid = (uint64_t)SVAL(pml->buf.data,smb_mid);
+
+                DEBUG(10,("schedule_deferred_open_message_smb: [%d] "
+                        "msg_mid = %llu\n",
+                        i++,
+                        (unsigned long long)msg_mid ));
 
                 if (mid == msg_mid) {
@@ -567 +699 @@
                                 /* A processed message should not be
                                  * rescheduled. */
-                                DEBUG(0,("schedule_deferred_open_smb_message: LOGIC ERROR "
-                                        "message mid %u was already processed\n",
-                                        msg_mid ));
+                                DEBUG(0,("schedule_deferred_open_message_smb: LOGIC ERROR "
+                                        "message mid %llu was already processed\n",
+                                        (unsigned long long)msg_mid ));
                                 continue;
                         }
 
-                        DEBUG(10,("schedule_deferred_open_smb_message: scheduling mid %u\n",
-                                mid ));
+                        DEBUG(10,("schedule_deferred_open_message_smb: "
+                                "scheduling mid %llu\n",
+                                (unsigned long long)mid ));
 
                         te = event_add_timed(smbd_event_context(),
@@ -582 +715 @@
                                              pml);
                         if (!te) {
-                                DEBUG(10,("schedule_deferred_open_smb_message: "
-                                          "event_add_timed() failed, skipping mid %u\n",
-                                          mid ));
+                                DEBUG(10,("schedule_deferred_open_message_smb: "
+                                        "event_add_timed() failed, "
+                                        "skipping mid %llu\n",
+                                        (unsigned long long)msg_mid ));
                         }
 
@@ -594 +728 @@
         }
 
-        DEBUG(10,("schedule_deferred_open_smb_message: failed to find message mid %u\n",
-                mid ));
+        DEBUG(10,("schedule_deferred_open_message_smb: failed to "
+                "find message mid %llu\n",
+                (unsigned long long)mid ));
 }
 
@@ -602 +737 @@
 ****************************************************************************/
 
-bool open_was_deferred(uint16 mid)
+bool open_was_deferred(uint64_t mid)
 {
         struct pending_message_list *pml;
 
+        if (smbd_server_conn->using_smb2) {
+                return open_was_deferred_smb2(smbd_server_conn, mid);
+        }
+
         for (pml = deferred_open_queue; pml; pml = pml->next) {
-                if (SVAL(pml->buf.data,smb_mid) == mid && !pml->processed) {
+                if (((uint64_t)SVAL(pml->buf.data,smb_mid)) == mid && !pml->processed) {
                         return True;
                 }
@@ -618 +757 @@
 ****************************************************************************/
 
-struct pending_message_list *get_open_deferred_message(uint16 mid)
+static struct pending_message_list *get_deferred_open_message_smb(uint64_t mid)
 {
         struct pending_message_list *pml;
 
         for (pml = deferred_open_queue; pml; pml = pml->next) {
-                if (SVAL(pml->buf.data,smb_mid) == mid) {
+                if (((uint64_t)SVAL(pml->buf.data,smb_mid)) == mid) {
                         return pml;
                 }
         }
         return NULL;
+}
+
+/****************************************************************************
+ Get the state data queued by this mid.
+****************************************************************************/
+
+bool get_deferred_open_message_state(struct smb_request *smbreq,
+                                struct timeval *p_request_time,
+                                void **pp_state)
+{
+        struct pending_message_list *pml;
+
+        if (smbd_server_conn->using_smb2) {
+                return get_deferred_open_message_state_smb2(smbreq->smb2req,
+                                        p_request_time,
+                                        pp_state);
+        }
+
+        pml = get_deferred_open_message_smb(smbreq->mid);
+        if (!pml) {
+                return false;
+        }
+        if (p_request_time) {
+                *p_request_time = pml->request_time;
+        }
+        if (pp_state) {
+                *pp_state = (void *)pml->private_data.data;
+        }
+        return true;
 }
 
@@ -635 +803 @@
 ****************************************************************************/
 
-bool push_deferred_smb_message(struct smb_request *req,
+bool push_deferred_open_message_smb(struct smb_request *req,
                                struct timeval request_time,
                                struct timeval timeout,
+                               struct file_id id,
                                char *private_data, size_t priv_len)
 {
         struct timeval end_time;
 
+        if (req->smb2req) {
+                return push_deferred_open_message_smb2(req->smb2req,
+                                                request_time,
+                                                timeout,
+                                                id,
+                                                private_data,
+                                                priv_len);
+        }
+
         if (req->unread_bytes) {
-                DEBUG(0,("push_deferred_smb_message: logic error ! "
+                DEBUG(0,("push_deferred_open_message_smb: logic error ! "
                         "unread_bytes = %u\n",
                         (unsigned int)req->unread_bytes ));
-                smb_panic("push_deferred_smb_message: "
+                smb_panic("push_deferred_open_message_smb: "
                         "logic error unread_bytes != 0" );
         }
@@ -652 +830 @@
         end_time = timeval_sum(&request_time, &timeout);
 
-        DEBUG(10,("push_deferred_open_smb_message: pushing message len %u mid %u "
-                  "timeout time [%u.%06u]\n",
-                  (unsigned int) smb_len(req->inbuf)+4, (unsigned int)req->mid,
-                  (unsigned int)end_time.tv_sec,
-                  (unsigned int)end_time.tv_usec));
+        DEBUG(10,("push_deferred_open_message_smb: pushing message "
+                "len %u mid %llu timeout time [%u.%06u]\n",
+                (unsigned int) smb_len(req->inbuf)+4,
+                (unsigned long long)req->mid,
+                (unsigned int)end_time.tv_sec,
+                (unsigned int)end_time.tv_usec));
 
         return push_queued_message(req, request_time, end_time,
@@ -773 +952 @@
                                   void *private_data)
 {
+        struct messaging_context *msg_ctx = talloc_get_type_abort(
+                private_data, struct messaging_context);
         change_to_root_user();
         DEBUG(1,("Reloading services after SIGHUP\n"));
-        reload_services(False);
-}
-
-void smbd_setup_sig_hup_handler(void)
+        reload_services(msg_ctx, smbd_server_conn->sock, False);
+        if (am_parent) {
+                pcap_cache_reload(ev, msg_ctx, &reload_pcap_change_notify);
+        }
+}
+
+void smbd_setup_sig_hup_handler(struct tevent_context *ev,
+                                struct messaging_context *msg_ctx)
 {
         struct tevent_signal *se;
 
-        se = tevent_add_signal(smbd_event_context(),
-                               smbd_event_context(),
-                               SIGHUP, 0,
-                               smbd_sig_hup_handler,
-                               NULL);
+        se = tevent_add_signal(ev, ev, SIGHUP, 0, smbd_sig_hup_handler,
+                               msg_ctx);
         if (!se) {
                 exit_server("failed to setup SIGHUP handler");
@@ -794 +976 @@
 static NTSTATUS smbd_server_connection_loop_once(struct smbd_server_connection *conn)
 {
-        fd_set r_fds, w_fds;
-        int selrtn;
-        struct timeval to;
-        int maxfd = 0;
-
-        to.tv_sec = SMBD_SELECT_TIMEOUT;
-        to.tv_usec = 0;
-
-        /*
-         * Setup the select fd sets.
-         */
-
-        FD_ZERO(&r_fds);
-        FD_ZERO(&w_fds);
+        int timeout;
+        int num_pfds = 0;
+        int ret;
+        bool retry;
+
+        timeout = SMBD_SELECT_TIMEOUT * 1000;
 
         /*
@@ -814 +988 @@
          */
 
-        {
-                struct timeval now;
-                GetTimeOfDay(&now);
-
-                event_add_to_select_args(smbd_event_context(), &now,
-                                         &r_fds, &w_fds, &to, &maxfd);
-        }
+        event_add_to_poll_args(smbd_event_context(), conn,
+                               &conn->pfds, &num_pfds, &timeout);
 
         /* Process a signal and timed events now... */
-        if (run_events(smbd_event_context(), 0, NULL, NULL)) {
+        if (run_events_poll(smbd_event_context(), 0, NULL, 0)) {
                 return NT_STATUS_RETRY;
         }
@@ -831 +1000 @@
                 START_PROFILE(smbd_idle);
 
-                selrtn = sys_select(maxfd+1,&r_fds,&w_fds,NULL,&to);
+                ret = sys_poll(conn->pfds, num_pfds, timeout);
                 sav = errno;
 
@@ -838 +1007 @@
         }
 
-        if (selrtn == -1 && errno != EINTR) {
+        if (ret == -1) {
+                if (errno == EINTR) {
+                        return NT_STATUS_RETRY;
+                }
                 return map_nt_error_from_unix(errno);
         }
 
-        if (run_events(smbd_event_context(), selrtn, &r_fds, &w_fds)) {
+        retry = run_events_poll(smbd_event_context(), ret, conn->pfds,
+                                num_pfds);
+        if (retry) {
                 return NT_STATUS_RETRY;
         }
 
-        /* Check if error */
-        if (selrtn == -1) {
-                /* something is wrong. Maybe the socket is dead? */
-                return map_nt_error_from_unix(errno);
-        }
-
         /* Did we timeout ? */
-        if (selrtn == 0) {
+        if (ret == 0) {
                 return NT_STATUS_RETRY;
         }
@@ -866 +1034 @@
  */
 
-NTSTATUS allow_new_trans(struct trans_state *list, int mid)
+NTSTATUS allow_new_trans(struct trans_state *list, uint64_t mid)
 {
         int count = 0;
@@ -1268 +1436 @@
         uint16 session_tag;
         connection_struct *conn = NULL;
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
 
         errno = 0;
@@ -1320 +1488 @@
                         if (vuser) {
                                 set_current_user_info(
-                                        vuser->server_info->sanitized_username,
-                                        vuser->server_info->unix_name,
-                                        pdb_get_domain(vuser->server_info
-                                                       ->sam_account));
+                                        vuser->session_info->sanitized_username,
+                                        vuser->session_info->unix_name,
+                                        vuser->session_info->info3->base.domain.string);
                         }
                 }
@@ -1347 +1514 @@
                 if (!change_to_user(conn,session_tag)) {
                         DEBUG(0, ("Error: Could not change to user. Removing "
-                            "deferred open, mid=%d.\n", req->mid));
+                                "deferred open, mid=%llu.\n",
+                                (unsigned long long)req->mid));
                         reply_force_doserror(req, ERRSRV, ERRbaduid);
                         return conn;
@@ -1396 +1564 @@
         if ((flags & AS_GUEST)
             && (!change_to_guest() ||
-                !check_access(smbd_server_fd(), lp_hostsallow(-1),
-                              lp_hostsdeny(-1)))) {
+                !allow_access(lp_hostsdeny(-1), lp_hostsallow(-1),
+                              sconn->client_id.name,
+                              sconn->client_id.addr))) {
                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
                 return conn;
@@ -1410 +1579 @@
 ****************************************************************************/
 
-static void construct_reply(char *inbuf, int size, size_t unread_bytes,
+static void construct_reply(struct smbd_server_connection *sconn,
+                            char *inbuf, int size, size_t unread_bytes,
                             uint32_t seqnum, bool encrypted,
                             struct smb_perfcount_data *deferred_pcd)
@@ -1421 +1591 @@
         }
 
-        init_smb_request(req, (uint8 *)inbuf, unread_bytes, encrypted);
+        if (!init_smb_request(req, sconn, (uint8 *)inbuf, unread_bytes,
+                              encrypted, seqnum)) {
+                exit_server_cleanly("Invalid SMB request");
+        }
+
         req->inbuf  = (uint8_t *)talloc_move(req, &inbuf);
-        req->seqnum = seqnum;
 
         /* we popped this message off the queue - keep original perf data */
@@ -1438 +1611 @@
         if (req->unread_bytes) {
                 /* writeX failed. drain socket. */
-                if (drain_socket(smbd_server_fd(), req->unread_bytes) !=
+                if (drain_socket(req->sconn->sock, req->unread_bytes) !=
                                 req->unread_bytes) {
                         smb_panic("failed to drain pending bytes");
@@ -1458 +1631 @@
         }
 
-        if (!srv_send_smb(smbd_server_fd(),
+        if (!srv_send_smb(req->sconn,
                         (char *)req->outbuf,
                         true, req->seqnum+1,
@@ -1474 +1647 @@
  Process an smb from the client
 ****************************************************************************/
-static void process_smb(struct smbd_server_connection *conn,
+static void process_smb(struct smbd_server_connection *sconn,
                         uint8_t *inbuf, size_t nread, size_t unread_bytes,
                         uint32_t seqnum, bool encrypted,
@@ -1485 +1658 @@
         DEBUG( 6, ( "got message type 0x%x of len 0x%x\n", msg_type,
                     smb_len(inbuf) ) );
-        DEBUG( 3, ( "Transaction %d of length %d (%u toread)\n", trans_num,
-                                (int)nread,
-                                (unsigned int)unread_bytes ));
+        DEBUG(3, ("Transaction %d of length %d (%u toread)\n",
+                  sconn->trans_num, (int)nread, (unsigned int)unread_bytes));
 
         if (msg_type != 0) {
@@ -1493 +1665 @@
                  * NetBIOS session request, keepalive, etc.
                  */
-                reply_special((char *)inbuf, nread);
+                reply_special(sconn, (char *)inbuf, nread);
                 goto done;
         }
 
-        if (smbd_server_conn->allow_smb2) {
+        if (sconn->using_smb2) {
+                /* At this point we're not really using smb2,
+                 * we make the decision here.. */
                 if (smbd_is_smb2_header(inbuf, nread)) {
-                        smbd_smb2_first_negprot(smbd_server_conn, inbuf, nread);
+                        smbd_smb2_first_negprot(sconn, inbuf, nread);
                         return;
-                }
-                smbd_server_conn->allow_smb2 = false;
+                } else if (nread >= smb_size && valid_smb_header(inbuf)
+                                && CVAL(inbuf, smb_com) != 0x72) {
+                        /* This is a non-negprot SMB1 packet.
+                           Disable SMB2 from now on. */
+                        sconn->using_smb2 = false;
+                }
         }
 
         show_msg((char *)inbuf);
 
-        construct_reply((char *)inbuf,nread,unread_bytes,seqnum,encrypted,deferred_pcd);
-        trans_num++;
+        construct_reply(sconn, (char *)inbuf, nread, unread_bytes, seqnum,
+                        encrypted, deferred_pcd);
+        sconn->trans_num++;
 
 done:
-        conn->smb1.num_requests++;
+        sconn->num_requests++;
 
         /* The timeout_processing function isn't run nearly
@@ -1520 +1699 @@
            tradeoff of performance vs log file size overrun. */
 
-        if ((conn->smb1.num_requests % 50) == 0 &&
+        if ((sconn->num_requests % 50) == 0 &&
             need_to_check_log_size()) {
                 change_to_root_user();
@@ -1559 +1738 @@
 {
         srv_set_message(outbuf,0,0,false);
-        
+
         SCVAL(outbuf, smb_com, req->cmd);
         SIVAL(outbuf,smb_rcls,0);
@@ -1891 +2070 @@
                            talloc_get_size(req->chain_outbuf) - 4);
 
-                if (!srv_send_smb(smbd_server_fd(), (char *)req->chain_outbuf,
+                if (!srv_send_smb(req->sconn, (char *)req->chain_outbuf,
                                   true, req->seqnum+1,
                                   IS_CONN_ENCRYPTED(req->conn)
@@ -2031 +2210 @@
         show_msg((char *)(req->chain_outbuf));
 
-        if (!srv_send_smb(smbd_server_fd(), (char *)req->chain_outbuf,
+        if (!srv_send_smb(req->sconn, (char *)req->chain_outbuf,
                           true, req->seqnum+1,
                           IS_CONN_ENCRYPTED(req->conn)||req->encrypted,
                           &req->pcd)) {
-                exit_server_cleanly("construct_reply: srv_send_smb failed.");
+                exit_server_cleanly("chain_reply: srv_send_smb failed.");
         }
         TALLOC_FREE(req->chain_outbuf);
@@ -2045 +2224 @@
 ****************************************************************************/
 
-void check_reload(time_t t)
-{
-        time_t printcap_cache_time = (time_t)lp_printcap_cache_time();
-
-        if(last_smb_conf_reload_time == 0) {
+static void check_reload(struct smbd_server_connection *sconn, time_t t)
+{
+
+        if (last_smb_conf_reload_time == 0) {
                 last_smb_conf_reload_time = t;
-                /* Our printing subsystem might not be ready at smbd start up.
-                   Then no printer is available till the first printers check
-                   is performed.  A lower initial interval circumvents this. */
-                if ( printcap_cache_time > 60 )
-                        last_printer_reload_time = t - printcap_cache_time + 60;
-                else
-                        last_printer_reload_time = t;
-        }
-
-        if (mypid != getpid()) { /* First time or fork happened meanwhile */
-                /* randomize over 60 second the printcap reload to avoid all
-                 * process hitting cupsd at the same time */
-                int time_range = 60;
-
-                last_printer_reload_time += random() % time_range;
-                mypid = getpid();
         }
 
         if (t >= last_smb_conf_reload_time+SMBD_RELOAD_CHECK) {
-                reload_services(True);
+                reload_services(sconn->msg_ctx, sconn->sock, True);
                 last_smb_conf_reload_time = t;
         }
-
-        /* 'printcap cache time = 0' disable the feature */
-        
-        if ( printcap_cache_time != 0 )
-        { 
-                /* see if it's time to reload or if the clock has been set back */
-                
-                if ( (t >= last_printer_reload_time+printcap_cache_time) 
-                        || (t-last_printer_reload_time  < 0) ) 
-                {
-                        DEBUG( 3,( "Printcap cache time expired.\n"));
-                        pcap_cache_reload(&reload_printers);
-                        last_printer_reload_time = t;
-                }
-        }
+}
+
+static bool fd_is_readable(int fd)
+{
+        int ret, revents;
+
+        ret = poll_one_fd(fd, POLLIN|POLLHUP, 0, &revents);
+
+        return ((ret > 0) && ((revents & (POLLIN|POLLHUP|POLLERR)) != 0));
+
 }
 
@@ -2095 +2252 @@
 }
 
-static void smbd_server_connection_read_handler(struct smbd_server_connection *conn)
+static void smbd_server_connection_read_handler(
+        struct smbd_server_connection *conn, int fd)
 {
         uint8_t *inbuf = NULL;
@@ -2105 +2263 @@
         uint32_t seqnum;
 
-        /* TODO: make this completely nonblocking */
-
-        status = receive_smb_talloc(mem_ctx, smbd_server_fd(),
-                                    (char **)(void *)&inbuf,
-                                    0, /* timeout */
-                                    &unread_bytes,
-                                    &encrypted,
-                                    &inbuf_len, &seqnum);
+        bool from_client = (conn->sock == fd);
+
+        if (from_client) {
+                smbd_lock_socket(conn);
+
+                if (lp_async_smb_echo_handler() && !fd_is_readable(fd)) {
+                        DEBUG(10,("the echo listener was faster\n"));
+                        smbd_unlock_socket(conn);
+                        return;
+                }
+
+                /* TODO: make this completely nonblocking */
+                status = receive_smb_talloc(mem_ctx, conn, fd,
+                                            (char **)(void *)&inbuf,
+                                            0, /* timeout */
+                                            &unread_bytes,
+                                            &encrypted,
+                                            &inbuf_len, &seqnum,
+                                            false /* trusted channel */);
+                smbd_unlock_socket(conn);
+        } else {
+                /* TODO: make this completely nonblocking */
+                status = receive_smb_talloc(mem_ctx, conn, fd,
+                                            (char **)(void *)&inbuf,
+                                            0, /* timeout */
+                                            &unread_bytes,
+                                            &encrypted,
+                                            &inbuf_len, &seqnum,
+                                            true /* trusted channel */);
+        }
+
         if (NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) {
                 goto process;
@@ -2138 +2319 @@
         if (flags & EVENT_FD_WRITE) {
                 smbd_server_connection_write_handler(conn);
-        } else if (flags & EVENT_FD_READ) {
-                smbd_server_connection_read_handler(conn);
-        }
-}
-
+                return;
+        }
+        if (flags & EVENT_FD_READ) {
+                smbd_server_connection_read_handler(conn, conn->sock);
+                return;
+        }
+}
+
+static void smbd_server_echo_handler(struct event_context *ev,
+                                     struct fd_event *fde,
+                                     uint16_t flags,
+                                     void *private_data)
+{
+        struct smbd_server_connection *conn = talloc_get_type(private_data,
+                                              struct smbd_server_connection);
+
+        if (flags & EVENT_FD_WRITE) {
+                smbd_server_connection_write_handler(conn);
+                return;
+        }
+        if (flags & EVENT_FD_READ) {
+                smbd_server_connection_read_handler(
+                        conn, conn->smb1.echo_handler.trusted_fd);
+                return;
+        }
+}
 
 /****************************************************************************
@@ -2149 +2351 @@
 static void release_ip(const char *ip, void *priv)
 {
-        char addr[INET6_ADDRSTRLEN];
-        char *p = addr;
-
-        client_socket_addr(get_client_fd(),addr,sizeof(addr));
+        const char *addr = (const char *)priv;
+        const char *p = addr;
 
         if (strncmp("::ffff:", addr, 7) == 0) {
                 p = addr + 7;
         }
+
+        DEBUG(10, ("Got release IP message for %s, "
+                   "our address is %s\n", ip, p));
 
         if ((strcmp(p, ip) == 0) || ((p != addr) && strcmp(addr, ip) == 0)) {
@@ -2175 +2378 @@
                            uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)
 {
-        release_ip((char *)data->data, NULL);
+        struct smbd_server_connection *sconn = talloc_get_type_abort(
+                private_data, struct smbd_server_connection);
+
+        release_ip((char *)data->data, sconn->client_id.addr);
 }
 
 #ifdef CLUSTER_SUPPORT
-static int client_get_tcp_info(struct sockaddr_storage *server,
+static int client_get_tcp_info(int sock, struct sockaddr_storage *server,
                                struct sockaddr_storage *client)
 {
         socklen_t length;
-        if (server_fd == -1) {
+        length = sizeof(*server);
+        if (getsockname(sock, (struct sockaddr *)server, &length) != 0) {
                 return -1;
         }
-        length = sizeof(*server);
-        if (getsockname(server_fd, (struct sockaddr *)server, &length) != 0) {
-                return -1;
-        }
         length = sizeof(*client);
-        if (getpeername(server_fd, (struct sockaddr *)client, &length) != 0) {
+        if (getpeername(sock, (struct sockaddr *)client, &length) != 0) {
                 return -1;
         }
@@ -2203 +2406 @@
 static bool keepalive_fn(const struct timeval *now, void *private_data)
 {
-        if (!send_keepalive(smbd_server_fd())) {
-                DEBUG( 2, ( "Keepalive failed - exiting.\n" ) );
+        struct smbd_server_connection *sconn = smbd_server_conn;
+        bool ret;
+
+        if (sconn->using_smb2) {
+                /* Don't do keepalives on an SMB2 connection. */
+                return false;
+        }
+
+        smbd_lock_socket(smbd_server_conn);
+        ret = send_keepalive(sconn->sock);
+        smbd_unlock_socket(smbd_server_conn);
+
+        if (!ret) {
+                char addr[INET6_ADDRSTRLEN];
+                /*
+                 * Try and give an error message saying what
+                 * client failed.
+                 */
+                DEBUG(0, ("send_keepalive failed for client %s. "
+                          "Error %s - exiting\n",
+                          get_peer_addr(sconn->sock, addr, sizeof(addr)),
+                          strerror(errno)));
                 return False;
         }
@@ -2215 +2438 @@
 static bool deadtime_fn(const struct timeval *now, void *private_data)
 {
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn =
+                (struct smbd_server_connection *)private_data;
+
         if ((conn_num_open(sconn) == 0)
             || (conn_idle_all(sconn, now->tv_sec))) {
                 DEBUG( 2, ( "Closing idle connection\n" ) );
-                messaging_send(smbd_messaging_context(), procid_self(),
+                messaging_send(sconn->msg_ctx,
+                               messaging_server_id(sconn->msg_ctx),
                                MSG_SHUTDOWN, &data_blob_null);
                 return False;
@@ -2233 +2459 @@
 static bool housekeeping_fn(const struct timeval *now, void *private_data)
 {
+        struct smbd_server_connection *sconn = talloc_get_type_abort(
+                private_data, struct smbd_server_connection);
+
+        DEBUG(5, ("housekeeping\n"));
+
         change_to_root_user();
 
         /* update printer queue caches if necessary */
-        update_monitored_printq_cache();
+        update_monitored_printq_cache(sconn->msg_ctx);
 
         /* check if we need to reload services */
-        check_reload(time(NULL));
+        check_reload(sconn, time_mono(NULL));
 
         /* Change machine password if neccessary. */
@@ -2252 +2483 @@
 }
 
+static int create_unlink_tmp(const char *dir)
+{
+        char *fname;
+        int fd;
+
+        fname = talloc_asprintf(talloc_tos(), "%s/listenerlock_XXXXXX", dir);
+        if (fname == NULL) {
+                errno = ENOMEM;
+                return -1;
+        }
+        fd = mkstemp(fname);
+        if (fd == -1) {
+                TALLOC_FREE(fname);
+                return -1;
+        }
+        if (unlink(fname) == -1) {
+                int sys_errno = errno;
+                close(fd);
+                TALLOC_FREE(fname);
+                errno = sys_errno;
+                return -1;
+        }
+        TALLOC_FREE(fname);
+        return fd;
+}
+
+struct smbd_echo_state {
+        struct tevent_context *ev;
+        struct iovec *pending;
+        struct smbd_server_connection *sconn;
+        int parent_pipe;
+
+        struct tevent_fd *parent_fde;
+
+        struct tevent_fd *read_fde;
+        struct tevent_req *write_req;
+};
+
+static void smbd_echo_writer_done(struct tevent_req *req);
+
+static void smbd_echo_activate_writer(struct smbd_echo_state *state)
+{
+        int num_pending;
+
+        if (state->write_req != NULL) {
+                return;
+        }
+
+        num_pending = talloc_array_length(state->pending);
+        if (num_pending == 0) {
+                return;
+        }
+
+        state->write_req = writev_send(state, state->ev, NULL,
+                                       state->parent_pipe, false,
+                                       state->pending, num_pending);
+        if (state->write_req == NULL) {
+                DEBUG(1, ("writev_send failed\n"));
+                exit(1);
+        }
+
+        talloc_steal(state->write_req, state->pending);
+        state->pending = NULL;
+
+        tevent_req_set_callback(state->write_req, smbd_echo_writer_done,
+                                state);
+}
+
+static void smbd_echo_writer_done(struct tevent_req *req)
+{
+        struct smbd_echo_state *state = tevent_req_callback_data(
+                req, struct smbd_echo_state);
+        ssize_t written;
+        int err;
+
+        written = writev_recv(req, &err);
+        TALLOC_FREE(req);
+        state->write_req = NULL;
+        if (written == -1) {
+                DEBUG(1, ("writev to parent failed: %s\n", strerror(err)));
+                exit(1);
+        }
+        DEBUG(10,("echo_handler[%d]: forwarded pdu to main\n", (int)sys_getpid()));
+        smbd_echo_activate_writer(state);
+}
+
+static bool smbd_echo_reply(uint8_t *inbuf, size_t inbuf_len,
+                            uint32_t seqnum)
+{
+        struct smb_request req;
+        uint16_t num_replies;
+        size_t out_len;
+        char *outbuf;
+        bool ok;
+
+        if ((inbuf_len == 4) && (CVAL(inbuf, 0) == SMBkeepalive)) {
+                DEBUG(10, ("Got netbios keepalive\n"));
+                /*
+                 * Just swallow it
+                 */
+                return true;
+        }
+
+        if (inbuf_len < smb_size) {
+                DEBUG(10, ("Got short packet: %d bytes\n", (int)inbuf_len));
+                return false;
+        }
+        if (!valid_smb_header(inbuf)) {
+                DEBUG(10, ("Got invalid SMB header\n"));
+                return false;
+        }
+
+        if (!init_smb_request(&req, smbd_server_conn, inbuf, 0, false,
+                              seqnum)) {
+                return false;
+        }
+        req.inbuf = inbuf;
+
+        DEBUG(10, ("smbecho handler got cmd %d (%s)\n", (int)req.cmd,
+                   smb_messages[req.cmd].name
+                   ? smb_messages[req.cmd].name : "unknown"));
+
+        if (req.cmd != SMBecho) {
+                return false;
+        }
+        if (req.wct < 1) {
+                return false;
+        }
+
+        num_replies = SVAL(req.vwv+0, 0);
+        if (num_replies != 1) {
+                /* Not a Windows "Hey, you're still there?" request */
+                return false;
+        }
+
+        if (!create_outbuf(talloc_tos(), &req, (char *)req.inbuf, &outbuf,
+                           1, req.buflen)) {
+                DEBUG(10, ("create_outbuf failed\n"));
+                return false;
+        }
+        req.outbuf = (uint8_t *)outbuf;
+
+        SSVAL(req.outbuf, smb_vwv0, num_replies);
+
+        if (req.buflen > 0) {
+                memcpy(smb_buf(req.outbuf), req.buf, req.buflen);
+        }
+
+        out_len = smb_len(req.outbuf) + 4;
+
+        ok = srv_send_smb(req.sconn,
+                          (char *)outbuf,
+                          true, seqnum+1,
+                          false, &req.pcd);
+        TALLOC_FREE(outbuf);
+        if (!ok) {
+                exit(1);
+        }
+
+        return true;
+}
+
+static void smbd_echo_exit(struct tevent_context *ev,
+                           struct tevent_fd *fde, uint16_t flags,
+                           void *private_data)
+{
+        DEBUG(2, ("smbd_echo_exit: lost connection to parent\n"));
+        exit(0);
+}
+
+static void smbd_echo_reader(struct tevent_context *ev,
+                             struct tevent_fd *fde, uint16_t flags,
+                             void *private_data)
+{
+        struct smbd_echo_state *state = talloc_get_type_abort(
+                private_data, struct smbd_echo_state);
+        struct smbd_server_connection *sconn = state->sconn;
+        size_t unread, num_pending;
+        NTSTATUS status;
+        struct iovec *tmp;
+        size_t iov_len;
+        uint32_t seqnum = 0;
+        bool reply;
+        bool ok;
+        bool encrypted = false;
+
+        smb_msleep(1000);
+
+        ok = smbd_lock_socket_internal(sconn);
+        if (!ok) {
+                DEBUG(0, ("%s: failed to lock socket\n",
+                        __location__));
+                exit(1);
+        }
+
+        if (!fd_is_readable(sconn->sock)) {
+                DEBUG(10,("echo_handler[%d] the parent smbd was faster\n",
+                          (int)sys_getpid()));
+                ok = smbd_unlock_socket_internal(sconn);
+                if (!ok) {
+                        DEBUG(1, ("%s: failed to unlock socket in\n",
+                                __location__));
+                        exit(1);
+                }
+                return;
+        }
+
+        num_pending = talloc_array_length(state->pending);
+        tmp = talloc_realloc(state, state->pending, struct iovec,
+                             num_pending+1);
+        if (tmp == NULL) {
+                DEBUG(1, ("talloc_realloc failed\n"));
+                exit(1);
+        }
+        state->pending = tmp;
+
+        DEBUG(10,("echo_handler[%d]: reading pdu\n", (int)sys_getpid()));
+
+        status = receive_smb_talloc(state->pending, sconn, sconn->sock,
+                                    (char **)(void *)&state->pending[num_pending].iov_base,
+                                    0 /* timeout */,
+                                    &unread,
+                                    &encrypted,
+                                    &iov_len,
+                                    &seqnum,
+                                    false /* trusted_channel*/);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(1, ("echo_handler[%d]: receive_smb_raw_talloc failed: %s\n",
+                          (int)sys_getpid(), nt_errstr(status)));
+                exit(1);
+        }
+        state->pending[num_pending].iov_len = iov_len;
+
+        ok = smbd_unlock_socket_internal(sconn);
+        if (!ok) {
+                DEBUG(1, ("%s: failed to unlock socket in\n",
+                        __location__));
+                exit(1);
+        }
+
+        reply = smbd_echo_reply((uint8_t *)state->pending[num_pending].iov_base,
+                                state->pending[num_pending].iov_len,
+                                seqnum);
+        if (reply) {
+                DEBUG(10,("echo_handler[%d]: replied to client\n", (int)sys_getpid()));
+                /* no check, shrinking by some bytes does not fail */
+                state->pending = talloc_realloc(state, state->pending,
+                                                struct iovec,
+                                                num_pending);
+                return;
+        }
+
+        if (state->pending[num_pending].iov_len >= smb_size) {
+                /*
+                 * place the seqnum in the packet so that the main process
+                 * can reply with signing
+                 */
+                SIVAL((uint8_t *)state->pending[num_pending].iov_base,
+                      smb_ss_field, seqnum);
+                SIVAL((uint8_t *)state->pending[num_pending].iov_base,
+                      smb_ss_field+4, NT_STATUS_V(NT_STATUS_OK));
+        }
+
+        DEBUG(10,("echo_handler[%d]: forward to main\n", (int)sys_getpid()));
+        smbd_echo_activate_writer(state);
+}
+
+static void smbd_echo_loop(struct smbd_server_connection *sconn,
+                           int parent_pipe)
+{
+        struct smbd_echo_state *state;
+
+        state = talloc_zero(sconn, struct smbd_echo_state);
+        if (state == NULL) {
+                DEBUG(1, ("talloc failed\n"));
+                return;
+        }
+        state->sconn = sconn;
+        state->parent_pipe = parent_pipe;
+        state->ev = s3_tevent_context_init(state);
+        if (state->ev == NULL) {
+                DEBUG(1, ("tevent_context_init failed\n"));
+                TALLOC_FREE(state);
+                return;
+        }
+        state->parent_fde = tevent_add_fd(state->ev, state, parent_pipe,
+                                        TEVENT_FD_READ, smbd_echo_exit,
+                                        state);
+        if (state->parent_fde == NULL) {
+                DEBUG(1, ("tevent_add_fd failed\n"));
+                TALLOC_FREE(state);
+                return;
+        }
+        state->read_fde = tevent_add_fd(state->ev, state, sconn->sock,
+                                        TEVENT_FD_READ, smbd_echo_reader,
+                                        state);
+        if (state->read_fde == NULL) {
+                DEBUG(1, ("tevent_add_fd failed\n"));
+                TALLOC_FREE(state);
+                return;
+        }
+
+        while (true) {
+                if (tevent_loop_once(state->ev) == -1) {
+                        DEBUG(1, ("tevent_loop_once failed: %s\n",
+                                  strerror(errno)));
+                        break;
+                }
+        }
+        TALLOC_FREE(state);
+}
+
+/*
+ * Handle SMBecho requests in a forked child process
+ */
+static bool fork_echo_handler(struct smbd_server_connection *sconn)
+{
+        int listener_pipe[2];
+        int res;
+        pid_t child;
+
+        res = pipe(listener_pipe);
+        if (res == -1) {
+                DEBUG(1, ("pipe() failed: %s\n", strerror(errno)));
+                return false;
+        }
+        sconn->smb1.echo_handler.socket_lock_fd = create_unlink_tmp(lp_lockdir());
+        if (sconn->smb1.echo_handler.socket_lock_fd == -1) {
+                DEBUG(1, ("Could not create lock fd: %s\n", strerror(errno)));
+                goto fail;
+        }
+
+        child = sys_fork();
+        if (child == 0) {
+                NTSTATUS status;
+
+                close(listener_pipe[0]);
+                set_blocking(listener_pipe[1], false);
+
+                status = reinit_after_fork(sconn->msg_ctx,
+                                           smbd_event_context(),
+                                           procid_self(), false);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(1, ("reinit_after_fork failed: %s\n",
+                                  nt_errstr(status)));
+                        exit(1);
+                }
+                smbd_echo_loop(sconn, listener_pipe[1]);
+                exit(0);
+        }
+        close(listener_pipe[1]);
+        listener_pipe[1] = -1;
+        sconn->smb1.echo_handler.trusted_fd = listener_pipe[0];
+
+        DEBUG(10,("fork_echo_handler: main[%d] echo_child[%d]\n", (int)sys_getpid(), child));
+
+        /*
+         * Without smb signing this is the same as the normal smbd
+         * listener. This needs to change once signing comes in.
+         */
+        sconn->smb1.echo_handler.trusted_fde = event_add_fd(smbd_event_context(),
+                                        sconn,
+                                        sconn->smb1.echo_handler.trusted_fd,
+                                        EVENT_FD_READ,
+                                        smbd_server_echo_handler,
+                                        sconn);
+        if (sconn->smb1.echo_handler.trusted_fde == NULL) {
+                DEBUG(1, ("event_add_fd failed\n"));
+                goto fail;
+        }
+
+        return true;
+
+fail:
+        if (listener_pipe[0] != -1) {
+                close(listener_pipe[0]);
+        }
+        if (listener_pipe[1] != -1) {
+                close(listener_pipe[1]);
+        }
+        sconn->smb1.echo_handler.trusted_fd = -1;
+        if (sconn->smb1.echo_handler.socket_lock_fd != -1) {
+                close(sconn->smb1.echo_handler.socket_lock_fd);
+        }
+        sconn->smb1.echo_handler.trusted_fd = -1;
+        sconn->smb1.echo_handler.socket_lock_fd = -1;
+        return false;
+}
+
+#if CLUSTER_SUPPORT
+
+static NTSTATUS smbd_register_ips(struct smbd_server_connection *sconn,
+                                  struct sockaddr_storage *srv,
+                                  struct sockaddr_storage *clnt)
+{
+        struct ctdbd_connection *cconn;
+        char tmp_addr[INET6_ADDRSTRLEN];
+        char *addr;
+
+        cconn = messaging_ctdbd_connection();
+        if (cconn == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        client_socket_addr(sconn->sock, tmp_addr, sizeof(tmp_addr));
+        addr = talloc_strdup(cconn, tmp_addr);
+        if (addr == NULL) {
+                return NT_STATUS_NO_MEMORY;
+        }
+        return ctdbd_register_ips(cconn, srv, clnt, release_ip, addr);
+}
+
+#endif
+
 /****************************************************************************
  Process commands from the client
 ****************************************************************************/
 
-void smbd_process(void)
+void smbd_process(struct smbd_server_connection *sconn)
 {
         TALLOC_CTX *frame = talloc_stackframe();
-        char remaddr[INET6_ADDRSTRLEN];
+        struct sockaddr_storage ss;
+        struct sockaddr *sa = NULL;
+        socklen_t sa_socklen;
+        struct tsocket_address *local_address = NULL;
+        struct tsocket_address *remote_address = NULL;
+        const char *remaddr = NULL;
+        int ret;
 
         if (lp_maxprotocol() == PROTOCOL_SMB2 &&
-            lp_security() != SEC_SHARE) {
-                smbd_server_conn->allow_smb2 = true;
+            !lp_async_smb_echo_handler()) {
+                /*
+                 * We're not making the decision here,
+                 * we're just allowing the client
+                 * to decide between SMB1 and SMB2
+                 * with the first negprot
+                 * packet.
+                 */
+                sconn->using_smb2 = true;
         }
 
         /* Ensure child is set to blocking mode */
-        set_blocking(smbd_server_fd(),True);
-
-        set_socket_options(smbd_server_fd(),"SO_KEEPALIVE");
-        set_socket_options(smbd_server_fd(), lp_socket_options());
+        set_blocking(sconn->sock,True);
+
+        set_socket_options(sconn->sock, "SO_KEEPALIVE");
+        set_socket_options(sconn->sock, lp_socket_options());
+
+        sa = (struct sockaddr *)(void *)&ss;
+        sa_socklen = sizeof(ss);
+        ret = getpeername(sconn->sock, sa, &sa_socklen);
+        if (ret != 0) {
+                int level = (errno == ENOTCONN)?2:0;
+                DEBUG(level,("getpeername() failed - %s\n", strerror(errno)));
+                exit_server_cleanly("getpeername() failed.\n");
+        }
+        ret = tsocket_address_bsd_from_sockaddr(sconn,
+                                                sa, sa_socklen,
+                                                &remote_address);
+        if (ret != 0) {
+                DEBUG(0,("%s: tsocket_address_bsd_from_sockaddr remote failed - %s\n",
+                        __location__, strerror(errno)));
+                exit_server_cleanly("tsocket_address_bsd_from_sockaddr remote failed.\n");
+        }
+
+        sa = (struct sockaddr *)(void *)&ss;
+        sa_socklen = sizeof(ss);
+        ret = getsockname(sconn->sock, sa, &sa_socklen);
+        if (ret != 0) {
+                int level = (errno == ENOTCONN)?2:0;
+                DEBUG(level,("getsockname() failed - %s\n", strerror(errno)));
+                exit_server_cleanly("getsockname() failed.\n");
+        }
+        ret = tsocket_address_bsd_from_sockaddr(sconn,
+                                                sa, sa_socklen,
+                                                &local_address);
+        if (ret != 0) {
+                DEBUG(0,("%s: tsocket_address_bsd_from_sockaddr remote failed - %s\n",
+                        __location__, strerror(errno)));
+                exit_server_cleanly("tsocket_address_bsd_from_sockaddr remote failed.\n");
+        }
+
+        sconn->local_address = local_address;
+        sconn->remote_address = remote_address;
+
+        if (tsocket_address_is_inet(remote_address, "ip")) {
+                remaddr = tsocket_address_inet_addr_string(
+                                sconn->remote_address,
+                                talloc_tos());
+                if (remaddr == NULL) {
+
+                }
+        } else {
+                remaddr = "0.0.0.0";
+        }
 
         /* this is needed so that we get decent entries
            in smbstatus for port 445 connects */
-        set_remote_machine_name(get_peer_addr(smbd_server_fd(),
-                                              remaddr,
-                                              sizeof(remaddr)),
-                                              false);
-        reload_services(true);
+        set_remote_machine_name(remaddr, false);
+        reload_services(sconn->msg_ctx, sconn->sock, true);
 
         /*
@@ -2287 +2990 @@
          */
 
-        if (!check_access(smbd_server_fd(), lp_hostsallow(-1),
-                          lp_hostsdeny(-1))) {
-                char addr[INET6_ADDRSTRLEN];
-
+        if (!allow_access(lp_hostsdeny(-1), lp_hostsallow(-1),
+                          sconn->client_id.name,
+                          sconn->client_id.addr)) {
                 /*
                  * send a negative session response "not listening on calling
@@ -2296 +2998 @@
                  */
                 unsigned char buf[5] = {0x83, 0, 0, 1, 0x81};
-                DEBUG( 1, ("Connection denied from %s\n",
-                           client_addr(get_client_fd(),addr,sizeof(addr)) ) );
-                (void)srv_send_smb(smbd_server_fd(),(char *)buf, false,
+                DEBUG( 1, ("Connection denied from %s to %s\n",
+                           tsocket_address_string(remote_address, talloc_tos()),
+                           tsocket_address_string(local_address, talloc_tos())));
+                (void)srv_send_smb(sconn,(char *)buf, false,
                                    0, false, NULL);
                 exit_server_cleanly("connection denied");
         }
 
-        static_init_rpc;
+        DEBUG(10, ("Connection allowed from %s to %s\n",
+                   tsocket_address_string(remote_address, talloc_tos()),
+                   tsocket_address_string(local_address, talloc_tos())));
 
         init_modules();
@@ -2325 +3030 @@
         }
 
-        if (!srv_init_signing(smbd_server_conn)) {
+        if (!srv_init_signing(sconn)) {
                 exit_server("Failed to init smb_signing");
         }
 
+        if (lp_async_smb_echo_handler() && !fork_echo_handler(sconn)) {
+                exit_server("Failed to fork echo handler");
+        }
+
         /* Setup oplocks */
-        if (!init_oplocks(smbd_messaging_context()))
+        if (!init_oplocks(sconn->msg_ctx))
                 exit_server("Failed to init oplocks");
 
-        /* Setup aio signal handler. */
-        initialize_async_io_handler();
-
         /* register our message handlers */
-        messaging_register(smbd_messaging_context(), NULL,
+        messaging_register(sconn->msg_ctx, NULL,
                            MSG_SMB_FORCE_TDIS, msg_force_tdis);
-        messaging_register(smbd_messaging_context(), NULL,
+        messaging_register(sconn->msg_ctx, sconn,
                            MSG_SMB_RELEASE_IP, msg_release_ip);
-        messaging_register(smbd_messaging_context(), NULL,
+        messaging_register(sconn->msg_ctx, NULL,
                            MSG_SMB_CLOSE_FILE, msg_close_file);
 
@@ -2348 +3054 @@
          * MSGs to all child processes
          */
-        messaging_deregister(smbd_messaging_context(),
+        messaging_deregister(sconn->msg_ctx,
                              MSG_DEBUG, NULL);
-        messaging_register(smbd_messaging_context(), NULL,
+        messaging_register(sconn->msg_ctx, NULL,
                            MSG_DEBUG, debug_message);
 
@@ -2364 +3070 @@
         if (!(event_add_idle(smbd_event_context(), NULL,
                              timeval_set(IDLE_CLOSED_TIMEOUT, 0),
-                             "deadtime", deadtime_fn, NULL))) {
+                             "deadtime", deadtime_fn, sconn))) {
                 DEBUG(0, ("Could not add deadtime event\n"));
                 exit(1);
@@ -2371 +3077 @@
         if (!(event_add_idle(smbd_event_context(), NULL,
                              timeval_set(SMBD_HOUSEKEEPING_INTERVAL, 0),
-                             "housekeeping", housekeeping_fn, NULL))) {
+                             "housekeeping", housekeeping_fn, sconn))) {
                 DEBUG(0, ("Could not add housekeeping event\n"));
                 exit(1);
@@ -2388 +3094 @@
                 struct sockaddr_storage srv, clnt;
 
-                if (client_get_tcp_info(&srv, &clnt) == 0) {
-
+                if (client_get_tcp_info(sconn->sock, &srv, &clnt) == 0) {
                         NTSTATUS status;
-
-                        status = ctdbd_register_ips(
-                                messaging_ctdbd_connection(),
-                                &srv, &clnt, release_ip, NULL);
-
+                        status = smbd_register_ips(sconn, &srv, &clnt);
                         if (!NT_STATUS_IS_OK(status)) {
                                 DEBUG(0, ("ctdbd_register_ips failed: %s\n",
@@ -2410 +3111 @@
 #endif
 
-        smbd_server_conn->nbt.got_session = false;
-
-        smbd_server_conn->smb1.negprot.max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
-
-        smbd_server_conn->smb1.sessions.done_sesssetup = false;
-        smbd_server_conn->smb1.sessions.max_send = BUFFER_SIZE;
-        smbd_server_conn->smb1.sessions.last_session_tag = UID_FIELD_INVALID;
+        sconn->nbt.got_session = false;
+
+        sconn->smb1.negprot.max_recv = MIN(lp_maxxmit(),BUFFER_SIZE);
+
+        sconn->smb1.sessions.done_sesssetup = false;
+        sconn->smb1.sessions.max_send = BUFFER_SIZE;
+        sconn->smb1.sessions.last_session_tag = UID_FIELD_INVALID;
         /* users from session setup */
-        smbd_server_conn->smb1.sessions.session_userlist = NULL;
+        sconn->smb1.sessions.session_userlist = NULL;
         /* workgroup from session setup. */
-        smbd_server_conn->smb1.sessions.session_workgroup = NULL;
+        sconn->smb1.sessions.session_workgroup = NULL;
         /* this holds info on user ids that are already validated for this VC */
-        smbd_server_conn->smb1.sessions.validated_users = NULL;
-        smbd_server_conn->smb1.sessions.next_vuid = VUID_OFFSET;
-        smbd_server_conn->smb1.sessions.num_validated_vuids = 0;
-#ifdef HAVE_NETGROUP
-        smbd_server_conn->smb1.sessions.my_yp_domain = NULL;
-#endif
-
-        conn_init(smbd_server_conn);
-        if (!init_dptrs(smbd_server_conn)) {
+        sconn->smb1.sessions.validated_users = NULL;
+        sconn->smb1.sessions.next_vuid = VUID_OFFSET;
+        sconn->smb1.sessions.num_validated_vuids = 0;
+
+        conn_init(sconn);
+        if (!init_dptrs(sconn)) {
                 exit_server("init_dptrs() failed");
         }
 
-        smbd_server_conn->smb1.fde = event_add_fd(smbd_event_context(),
-                                                  smbd_server_conn,
-                                                  smbd_server_fd(),
+        sconn->smb1.fde = event_add_fd(smbd_event_context(),
+                                                  sconn,
+                                                  sconn->sock,
                                                   EVENT_FD_READ,
                                                   smbd_server_connection_handler,
-                                                  smbd_server_conn);
-        if (!smbd_server_conn->smb1.fde) {
+                                                  sconn);
+        if (!sconn->smb1.fde) {
                 exit_server("failed to create smbd_server_connection fde");
         }
@@ -2453 +3151 @@
                 errno = 0;
 
-                status = smbd_server_connection_loop_once(smbd_server_conn);
+                status = smbd_server_connection_loop_once(sconn);
                 if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY) &&
                     !NT_STATUS_IS_OK(status)) {