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

Timestamp:

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

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

File:

• vendor/current/source3/smbd/reply.c (modified) (161 diffs)

vendor/current/source3/smbd/reply.c

@@ -26 +26 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "printing.h"
+#include "smbd/smbd.h"
 #include "smbd/globals.h"
+#include "fake_file.h"
+#include "rpc_client/rpc_client.h"
+#include "../librpc/gen_ndr/ndr_spoolss_c.h"
+#include "rpc_client/cli_spoolss.h"
+#include "rpc_client/init_spoolss.h"
+#include "rpc_server/rpc_ncacn_np.h"
+#include "libcli/security/security.h"
+#include "libsmb/nmblib.h"
+#include "auth.h"
+#include "smbprofile.h"
 
 /****************************************************************************
@@ -323 +336 @@
                     files_struct *fsp)
 {
-        if (!(fsp) || !(conn)) {
+        if ((fsp == NULL) || (conn == NULL)) {
                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
                 return False;
         }
-        if (((conn) != (fsp)->conn) || req->vuid != (fsp)->vuid) {
+        if ((conn != fsp->conn) || (req->vuid != fsp->vuid)) {
                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
                 return False;
@@ -344 +357 @@
                 return False;
         }
-        if ((fsp)->is_directory) {
+        if (fsp->is_directory) {
                 reply_nterror(req, NT_STATUS_INVALID_DEVICE_REQUEST);
                 return False;
         }
-        if ((fsp)->fh->fd == -1) {
+        if (fsp->fh->fd == -1) {
                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
                 return False;
         }
-        (fsp)->num_smb_operations++;
+        fsp->num_smb_operations++;
         return True;
 }
@@ -387 +400 @@
 }
 
-/****************************************************************************
- Check if we have a correct fsp. Replacement for the FSP_BELONGS_CONN macro
-****************************************************************************/
-
-bool fsp_belongs_conn(connection_struct *conn, struct smb_request *req,
-                      files_struct *fsp)
-{
-        if ((fsp) && (conn) && ((conn)==(fsp)->conn)
-            && (req->vuid == (fsp)->vuid)) {
-                return True;
-        }
-
-        reply_nterror(req, NT_STATUS_INVALID_HANDLE);
-        return False;
-}
-
-static bool netbios_session_retarget(const char *name, int name_type)
+static bool netbios_session_retarget(struct smbd_server_connection *sconn,
+                                     const char *name, int name_type)
 {
         char *trim_name;
@@ -417 +415 @@
         uint8_t outbuf[10];
 
-        if (get_socket_port(smbd_server_fd()) != 139) {
+        if (get_socket_port(sconn->sock) != 139) {
                 return false;
         }
@@ -459 +457 @@
         if (p != NULL) {
                 *p++ = '\0';
-                sscanf(p, "%x", &retarget_type);
+                if (sscanf(p, "%x", &retarget_type) != 1) {
+                        goto fail;
+                }
         }
 
@@ -480 +480 @@
         *(uint16_t *)(outbuf+8) = htons(retarget_port);
 
-        if (!srv_send_smb(smbd_server_fd(), (char *)outbuf, false, 0, false,
+        if (!srv_send_smb(sconn, (char *)outbuf, false, 0, false,
                           NULL)) {
                 exit_server_cleanly("netbios_session_regarget: srv_send_smb "
@@ -493 +493 @@
 
 /****************************************************************************
- Reply to a (netbios-level) special message.
+ Reply to a (netbios-level) special message. 
 ****************************************************************************/
 
-void reply_special(char *inbuf, size_t inbuf_size)
+void reply_special(struct smbd_server_connection *sconn, char *inbuf, size_t inbuf_size)
 {
         int msg_type = CVAL(inbuf,0);
         int msg_flags = CVAL(inbuf,1);
-        struct smbd_server_connection *sconn = smbd_server_conn;
         /*
          * We only really use 4 bytes of the outbuf, but for the smb_setlen
@@ -533 +532 @@
                 if (name_len1 <= 0 || name_len1 > inbuf_size - 4) {
                         DEBUG(0,("Invalid name length in session request\n"));
-                        return;
+                        break;
                 }
                 name_len2 = name_len((unsigned char *)(inbuf+4+name_len1),inbuf_size - 4 - name_len1);
                 if (name_len2 <= 0 || name_len2 > inbuf_size - 4 - name_len1) {
                         DEBUG(0,("Invalid name length in session request\n"));
-                        return;
+                        break;
                 }
 
@@ -548 +547 @@
                 if (name_type1 == -1 || name_type2 == -1) {
                         DEBUG(0,("Invalid name type in session request\n"));
-                        return;
+                        break;
                 }
 
@@ -554 +553 @@
                          name1, name_type1, name2, name_type2));
 
-                if (netbios_session_retarget(name1, name_type1)) {
+                if (netbios_session_retarget(sconn, name1, name_type1)) {
                         exit_server_cleanly("retargeted client");
+                }
+
+                /*
+                 * Windows NT/2k uses "*SMBSERVER" and XP uses
+                 * "*SMBSERV" arrggg!!!
+                 */
+                if (strequal(name1, "*SMBSERVER     ")
+                    || strequal(name1, "*SMBSERV       "))  {
+                        fstrcpy(name1, sconn->client_id.addr);
                 }
 
@@ -579 +587 @@
                 }
 
-                reload_services(True);
+                reload_services(sconn->msg_ctx, sconn->sock, True);
                 reopen_logs();
 
@@ -606 +614 @@
                     msg_type, msg_flags));
 
-        srv_send_smb(smbd_server_fd(), outbuf, false, 0, false, NULL);
+        srv_send_smb(sconn, outbuf, false, 0, false, NULL);
         return;
 }
@@ -627 +635 @@
         DATA_BLOB password_blob;
         TALLOC_CTX *ctx = talloc_tos();
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
 
         START_PROFILE(SMBtcon);
@@ -703 +711 @@
         const char *p, *q;
         uint16 tcon_flags;
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
 
         START_PROFILE(SMBtconX);
@@ -828 +836 @@
                                 perm2 = FILE_ALL_ACCESS;
                         } else {
-                                perm1 = CAN_WRITE(conn) ?
-                                                SHARE_ALL_ACCESS :
-                                                SHARE_READ_ONLY;
+                                perm1 = conn->share_access;
                         }
 
@@ -944 +950 @@
                                 return;
                         }
-                        SSVAL(p,0,fsp->rap_print_jobid);             /* Job number */
+                        /* Job number */
+                        if (fsp->print_file) {
+                                SSVAL(p, 0, fsp->print_file->rap_jobid);
+                        } else {
+                                SSVAL(p, 0, 0);
+                        }
                         srvstr_push((char *)req->outbuf, req->flags2, p+2,
                                     global_myname(), 15,
@@ -1096 +1107 @@
                 under WfWg - weird! */
         if (*fname == '\0') {
-                mode = aHIDDEN | aDIR;
+                mode = FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY;
                 if (!CAN_WRITE(conn)) {
-                        mode |= aRONLY;
+                        mode |= FILE_ATTRIBUTE_READONLY;
                 }
                 size = 0;
@@ -1137 +1148 @@
                         ZERO_STRUCT(write_time_ts);
                         fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
-                        get_file_infos(fileid, NULL, &write_time_ts);
+                        get_file_infos(fileid, 0, NULL, &write_time_ts);
                         if (!null_timespec(write_time_ts)) {
                                 update_stat_ex_mtime(&smb_fname->st, write_time_ts);
@@ -1144 +1155 @@
 
                 mtime = convert_timespec_to_time_t(smb_fname->st.st_ex_mtime);
-                if (mode & aDIR) {
+                if (mode & FILE_ATTRIBUTE_DIRECTORY) {
                         size = 0;
                 }
@@ -1245 +1256 @@
         if (mode != FILE_ATTRIBUTE_NORMAL) {
                 if (VALID_STAT_OF_DIR(smb_fname->st))
-                        mode |= aDIR;
+                        mode |= FILE_ATTRIBUTE_DIRECTORY;
                 else
-                        mode &= ~aDIR;
+                        mode &= ~FILE_ATTRIBUTE_DIRECTORY;
 
                 if (file_set_dosmode(conn, smb_fname, mode, NULL,
@@ -1382 +1393 @@
         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
         struct dptr_struct *dirptr = NULL;
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
 
         START_PROFILE(SMBsearch);
@@ -1416 +1427 @@
         p += 2;
 
-        /* dirtype &= ~aDIR; */
+        /* dirtype &= ~FILE_ATTRIBUTE_DIRECTORY; */
 
         if (status_len == 0) {
@@ -1456 +1467 @@
 
                 nt_status = dptr_create(conn,
+                                        NULL, /* fsp */
                                         directory,
                                         True,
@@ -1507 +1519 @@
         dptr_init_search_op(dirptr);
 
-        if ((dirtype&0x1F) == aVOLID) {
+        if ((dirtype&0x1F) == FILE_ATTRIBUTE_VOLUME) {
                 char buf[DIR_STRUCT_SIZE];
                 memcpy(buf,status,21);
                 if (!make_dir_struct(ctx,buf,"???????????",volume_label(SNUM(conn)),
-                                0,aVOLID,0,!allow_long_path_components)) {
+                                0,FILE_ATTRIBUTE_VOLUME,0,!allow_long_path_components)) {
                         reply_nterror(req, NT_STATUS_NO_MEMORY);
                         goto out;
@@ -1649 +1661 @@
         bool path_contains_wcard = False;
         TALLOC_CTX *ctx = talloc_tos();
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
 
         START_PROFILE(SMBfclose);
@@ -1714 +1726 @@
         uint32 create_disposition;
         uint32 create_options = 0;
+        uint32_t private_flags = 0;
         NTSTATUS status;
         bool ask_sharemode = lp_parm_bool(SNUM(conn), "smbd", "search ask sharemode", true);
@@ -1757 +1770 @@
                                          OPENX_FILE_EXISTS_OPEN, &access_mask,
                                          &share_mode, &create_disposition,
-                                         &create_options)) {
+                                         &create_options, &private_flags)) {
                 reply_force_doserror(req, ERRDOS, ERRbadaccess);
                 goto out;
@@ -1774 +1787 @@
                 oplock_request,                         /* oplock_request */
                 0,                                      /* allocation_size */
+                private_flags,
                 NULL,                                   /* sd */
                 NULL,                                   /* ea_list */
@@ -1797 +1811 @@
 
                 ZERO_STRUCT(write_time_ts);
-                get_file_infos(fsp->file_id, NULL, &write_time_ts);
+                get_file_infos(fsp->file_id, 0, NULL, &write_time_ts);
                 if (!null_timespec(write_time_ts)) {
                         update_stat_ex_mtime(&smb_fname->st, write_time_ts);
@@ -1805 +1819 @@
         mtime = convert_timespec_to_time_t(smb_fname->st.st_ex_mtime);
 
-        if (fattr & aDIR) {
+        if (fattr & FILE_ATTRIBUTE_DIRECTORY) {
                 DEBUG(3,("attempt to open a directory %s\n",
                          fsp_str_dbg(fsp)));
@@ -1873 +1887 @@
         uint32 create_disposition;
         uint32 create_options = 0;
+        uint32_t private_flags = 0;
         TALLOC_CTX *ctx = talloc_tos();
 
@@ -1930 +1945 @@
                                          &access_mask, &share_mode,
                                          &create_disposition,
-                                         &create_options)) {
+                                         &create_options,
+                                         &private_flags)) {
                 reply_force_doserror(req, ERRDOS, ERRbadaccess);
                 goto out;
@@ -1947 +1963 @@
                 oplock_request,                         /* oplock_request */
                 0,                                      /* allocation_size */
+                private_flags,
                 NULL,                                   /* sd */
                 NULL,                                   /* ea_list */
@@ -1976 +1993 @@
                         goto out;
                 }
-                smb_fname->st.st_ex_size =
-                    SMB_VFS_GET_ALLOC_SIZE(conn, fsp, &smb_fname->st);
-        }
-
-        fattr = dos_mode(conn, smb_fname);
-        mtime = convert_timespec_to_time_t(smb_fname->st.st_ex_mtime);
-        if (fattr & aDIR) {
+                status = vfs_stat_fsp(fsp);
+                if (!NT_STATUS_IS_OK(status)) {
+                        close_file(req, fsp, ERROR_CLOSE);
+                        reply_nterror(req, status);
+                        goto out;
+                }
+        }
+
+        fattr = dos_mode(conn, fsp->fsp_name);
+        mtime = convert_timespec_to_time_t(fsp->fsp_name->st.st_ex_mtime);
+        if (fattr & FILE_ATTRIBUTE_DIRECTORY) {
                 close_file(req, fsp, ERROR_CLOSE);
                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
@@ -2029 +2050 @@
                 srv_put_dos_date3((char *)req->outbuf,smb_vwv4,mtime);
         }
-        SIVAL(req->outbuf,smb_vwv6,(uint32)smb_fname->st.st_ex_size);
+        SIVAL(req->outbuf,smb_vwv6,(uint32)fsp->fsp_name->st.st_ex_size);
         SSVAL(req->outbuf,smb_vwv8,GET_OPENX_MODE(deny_mode));
         SSVAL(req->outbuf,smb_vwv11,smb_action);
 
         if (open_flags & EXTENDED_RESPONSE_REQUIRED) {
-                SIVAL(req->outbuf, smb_vwv15, STD_RIGHT_ALL_ACCESS);
+                SIVAL(req->outbuf, smb_vwv15, SEC_STD_ALL);
         }
 
@@ -2050 +2071 @@
 void reply_ulogoffX(struct smb_request *req)
 {
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
         user_struct *vuser;
 
@@ -2065 +2086 @@
                 open by this user */
         if ((vuser != NULL) && (lp_security() != SEC_SHARE)) {
-                file_close_user(req->vuid);
+                file_close_user(sconn, req->vuid);
         }
 
@@ -2138 +2159 @@
         }
 
-        if (fattr & aVOLID) {
+        if (fattr & FILE_ATTRIBUTE_VOLUME) {
                 DEBUG(0,("Attempt to create file (%s) with volid set - "
                          "please report this\n",
@@ -2164 +2185 @@
                 oplock_request,                         /* oplock_request */
                 0,                                      /* allocation_size */
+                0,                                      /* private_flags */
                 NULL,                                   /* sd */
                 NULL,                                   /* ea_list */
@@ -2292 +2314 @@
                 oplock_request,                         /* oplock_request */
                 0,                                      /* allocation_size */
+                0,                                      /* private_flags */
                 NULL,                                   /* sd */
                 NULL,                                   /* ea_list */
@@ -2357 +2380 @@
                         uint16 dirtype)
 {
-        uint32 fmode;
-
         if (!CAN_WRITE(conn)) {
                 return NT_STATUS_MEDIA_WRITE_PROTECTED;
         }
 
-        fmode = dos_mode(conn, fsp->fsp_name);
-        if ((fmode & ~dirtype) & (aHIDDEN | aSYSTEM)) {
-                return NT_STATUS_NO_SUCH_FILE;
+        if ((dirtype & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) !=
+                        (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) {
+                /* Only bother to read the DOS attribute if we might deny the
+                   rename on the grounds of attribute missmatch. */
+                uint32_t fmode = dos_mode(conn, fsp->fsp_name);
+                if ((fmode & ~dirtype) & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM)) {
+                        return NT_STATUS_NO_SUCH_FILE;
+                }
         }
 
@@ -2425 +2451 @@
 
         if (dirtype & FILE_ATTRIBUTE_NORMAL) {
-                dirtype = aDIR|aARCH|aRONLY;
-        }
-
-        dirtype &= (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM);
+                dirtype = FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY;
+        }
+
+        dirtype &= (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
         if (!dirtype) {
                 return NT_STATUS_NO_SUCH_FILE;
@@ -2434 +2460 @@
 
         if (!dir_check_ftype(conn, fattr, dirtype)) {
-                if (fattr & aDIR) {
+                if (fattr & FILE_ATTRIBUTE_DIRECTORY) {
                         return NT_STATUS_FILE_IS_A_DIRECTORY;
                 }
@@ -2465 +2491 @@
 
         /* Can't delete a directory. */
-        if (fattr & aDIR) {
+        if (fattr & FILE_ATTRIBUTE_DIRECTORY) {
                 return NT_STATUS_FILE_IS_A_DIRECTORY;
         }
@@ -2471 +2497 @@
 
 #if 0 /* JRATEST */
-        else if (dirtype & aDIR) /* Asked for a directory and it isn't. */
+        else if (dirtype & FILE_ATTRIBUTE_DIRECTORY) /* Asked for a directory and it isn't. */
                 return NT_STATUS_OBJECT_NAME_INVALID;
 #endif /* JRATEST */
@@ -2492 +2518 @@
                  0,                     /* oplock_request */
                  0,                     /* allocation_size */
+                 0,                     /* private_flags */
                  NULL,                  /* sd */
                  NULL,                  /* ea_list */
@@ -2514 +2541 @@
 
         /* The set is across all open files on this dev/inode pair. */
-        if (!set_delete_on_close(fsp, True, &conn->server_info->utok)) {
+        if (!set_delete_on_close(fsp, True, &conn->session_info->utok)) {
                 close_file(req, fsp, NORMAL_CLOSE);
                 return NT_STATUS_ACCESS_DENIED;
@@ -2571 +2598 @@
                  */
                 TALLOC_FREE(smb_fname->base_name);
-                smb_fname->base_name = talloc_asprintf(smb_fname,
-                                                       "%s/%s",
-                                                       fname_dir,
-                                                       fname_mask);
+                if (ISDOT(fname_dir)) {
+                        /* Ensure we use canonical names on open. */
+                        smb_fname->base_name = talloc_asprintf(smb_fname,
+                                                        "%s",
+                                                        fname_mask);
+                } else {
+                        smb_fname->base_name = talloc_asprintf(smb_fname,
+                                                        "%s/%s",
+                                                        fname_dir,
+                                                        fname_mask);
+                }
                 if (!smb_fname->base_name) {
                         status = NT_STATUS_NO_MEMORY;
@@ -2600 +2634 @@
                 char *talloced = NULL;
 
-                if ((dirtype & SAMBA_ATTRIBUTES_MASK) == aDIR) {
+                if ((dirtype & SAMBA_ATTRIBUTES_MASK) == FILE_ATTRIBUTE_DIRECTORY) {
                         status = NT_STATUS_OBJECT_NAME_INVALID;
                         goto out;
@@ -2659 +2693 @@
 
                         TALLOC_FREE(smb_fname->base_name);
-                        smb_fname->base_name =
-                            talloc_asprintf(smb_fname, "%s/%s",
-                                            fname_dir, dname);
+                        if (ISDOT(fname_dir)) {
+                                /* Ensure we use canonical names on open. */
+                                smb_fname->base_name =
+                                        talloc_asprintf(smb_fname, "%s",
+                                                dname);
+                        } else {
+                                smb_fname->base_name =
+                                        talloc_asprintf(smb_fname, "%s/%s",
+                                                fname_dir, dname);
+                        }
 
                         if (!smb_fname->base_name) {
@@ -2792 +2833 @@
 ****************************************************************************/
 
-static ssize_t fake_sendfile(files_struct *fsp, SMB_OFF_T startpos,
-                             size_t nread)
+ssize_t fake_sendfile(files_struct *fsp, SMB_OFF_T startpos, size_t nread)
 {
         size_t bufsize;
@@ -2829 +2869 @@
                 }
 
-                if (write_data(smbd_server_fd(),buf,cur_read) != cur_read) {
+                if (write_data(fsp->conn->sconn->sock, buf, cur_read)
+                    != cur_read) {
+                        char addr[INET6_ADDRSTRLEN];
+                        /*
+                         * Try and give an error message saying what
+                         * client failed.
+                         */
+                        DEBUG(0, ("write_data failed for client %s. "
+                                  "Error %s\n",
+                                  get_peer_addr(fsp->conn->sconn->sock, addr,
+                                                sizeof(addr)),
+                                  strerror(errno)));
                         SAFE_FREE(buf);
                         return -1;
@@ -2841 +2892 @@
 }
 
-#if defined(WITH_SENDFILE)
 /****************************************************************************
  Deal with the case of sendfile reading less bytes from the file than
@@ -2847 +2897 @@
 ****************************************************************************/
 
-static void sendfile_short_send(files_struct *fsp,
+void sendfile_short_send(files_struct *fsp,
                                 ssize_t nread,
                                 size_t headersize,
@@ -2890 +2940 @@
 
                         to_write = MIN(SHORT_SEND_BUFSIZE, smb_maxcnt - nread);
-                        if (write_data(smbd_server_fd(), buf, to_write) != to_write) {
+                        if (write_data(fsp->conn->sconn->sock, buf, to_write)
+                            != to_write) {
+                                char addr[INET6_ADDRSTRLEN];
+                                /*
+                                 * Try and give an error message saying what
+                                 * client failed.
+                                 */
+                                DEBUG(0, ("write_data failed for client %s. "
+                                          "Error %s\n",
+                                          get_peer_addr(
+                                                  fsp->conn->sconn->sock, addr,
+                                                  sizeof(addr)),
+                                          strerror(errno)));
                                 exit_server_cleanly("sendfile_short_send: "
-                                        "write_data failed");
+                                                    "write_data failed");
                         }
                         nread += to_write;
@@ -2899 +2961 @@
         }
 }
-#endif /* defined WITH_SENDFILE */
 
 /****************************************************************************
@@ -2905 +2966 @@
 ****************************************************************************/
 
-static void reply_readbraw_error(void)
+static void reply_readbraw_error(struct smbd_server_connection *sconn)
 {
         char header[4];
+
         SIVAL(header,0,0);
-        if (write_data(smbd_server_fd(),header,4) != 4) {
+
+        smbd_lock_socket(sconn);
+        if (write_data(sconn->sock,header,4) != 4) {
+                char addr[INET6_ADDRSTRLEN];
+                /*
+                 * Try and give an error message saying what
+                 * client failed.
+                 */
+                DEBUG(0, ("write_data failed for client %s. "
+                          "Error %s\n",
+                          get_peer_addr(sconn->sock, addr, sizeof(addr)),
+                          strerror(errno)));
+
                 fail_readraw();
         }
+        smbd_unlock_socket(sconn);
 }
 
@@ -2925 +3000 @@
                                ssize_t mincount)
 {
+        struct smbd_server_connection *sconn = req->sconn;
         char *outbuf = NULL;
         ssize_t ret=0;
 
-#if defined(WITH_SENDFILE)
         /*
          * We can only use sendfile on a non-chained packet 
@@ -2938 +3013 @@
         if ( !req_is_in_chain(req) && (nread > 0) && (fsp->base_fsp == NULL) &&
             (fsp->wcp == NULL) &&
-            lp_use_sendfile(SNUM(conn), smbd_server_conn->smb1.signing_state) ) {
+            lp_use_sendfile(SNUM(conn), req->sconn->smb1.signing_state) ) {
                 ssize_t sendfile_read = -1;
                 char header[4];
@@ -2946 +3021 @@
                 header_blob = data_blob_const(header, 4);
 
-                if ((sendfile_read = SMB_VFS_SENDFILE(smbd_server_fd(), fsp,
-                                &header_blob, startpos, nread)) == -1) {
+                sendfile_read = SMB_VFS_SENDFILE(sconn->sock, fsp,
+                                                 &header_blob, startpos,
+                                                 nread);
+                if (sendfile_read == -1) {
                         /* Returning ENOSYS means no data at all was sent.
                          * Do this as a normal read. */
@@ -3001 +3078 @@
 
 normal_readbraw:
-#endif
 
         outbuf = TALLOC_ARRAY(NULL, char, nread+4);
@@ -3007 +3083 @@
                 DEBUG(0,("send_file_readbraw: TALLOC_ARRAY failed for size %u.\n",
                         (unsigned)(nread+4)));
-                reply_readbraw_error();
+                reply_readbraw_error(sconn);
                 return;
         }
@@ -3023 +3099 @@
 
         _smb_setlen(outbuf,ret);
-        if (write_data(smbd_server_fd(),outbuf,4+ret) != 4+ret)
+        if (write_data(sconn->sock, outbuf, 4+ret) != 4+ret) {
+                char addr[INET6_ADDRSTRLEN];
+                /*
+                 * Try and give an error message saying what
+                 * client failed.
+                 */
+                DEBUG(0, ("write_data failed for client %s. "
+                          "Error %s\n",
+                          get_peer_addr(fsp->conn->sconn->sock, addr,
+                                        sizeof(addr)),
+                          strerror(errno)));
+
                 fail_readraw();
+        }
 
         TALLOC_FREE(outbuf);
@@ -3036 +3124 @@
 {
         connection_struct *conn = req->conn;
+        struct smbd_server_connection *sconn = req->sconn;
         ssize_t maxcount,mincount;
         size_t nread = 0;
@@ -3045 +3134 @@
         START_PROFILE(SMBreadbraw);
 
-        if (srv_is_signing_active(smbd_server_conn) ||
+        if (srv_is_signing_active(sconn) ||
             is_encrypted_packet(req->inbuf)) {
                 exit_server_cleanly("reply_readbraw: SMB signing/sealing is active - "
@@ -3052 +3141 @@
 
         if (req->wct < 8) {
-                reply_readbraw_error();
+                reply_readbraw_error(sconn);
+                END_PROFILE(SMBreadbraw);
+                return;
+        }
+
+        if (sconn->smb1.echo_handler.trusted_fde) {
+                DEBUG(2,("SMBreadbraw rejected with NOT_SUPPORTED because of "
+                         "'async smb echo handler = yes'\n"));
+                reply_readbraw_error(sconn);
                 END_PROFILE(SMBreadbraw);
                 return;
@@ -3080 +3177 @@
                         "- cache prime?\n",
                         (int)SVAL(req->vwv+0, 0)));
-                reply_readbraw_error();
+                reply_readbraw_error(sconn);
                 END_PROFILE(SMBreadbraw);
                 return;
@@ -3091 +3188 @@
                 DEBUG(3,("reply_readbraw: fnum %d not readable.\n",
                                 (int)SVAL(req->vwv+0, 0)));
-                reply_readbraw_error();
+                reply_readbraw_error(sconn);
                 END_PROFILE(SMBreadbraw);
                 return;
@@ -3118 +3215 @@
                                 "64 bit offsets.\n",
                         (unsigned int)IVAL(req->vwv+8, 0) ));
-                        reply_readbraw_error();
+                        reply_readbraw_error(sconn);
                         END_PROFILE(SMBreadbraw);
                         return;
@@ -3129 +3226 @@
                                 "readraw offset (%.0f) !\n",
                                 (double)startpos ));
-                        reply_readbraw_error();
+                        reply_readbraw_error(sconn);
                         END_PROFILE(SMBreadbraw);
                         return;
@@ -3141 +3238 @@
         maxcount = MIN(65535,maxcount);
 
-        init_strict_lock_struct(fsp, (uint32)req->smbpid,
+        init_strict_lock_struct(fsp, (uint64_t)req->smbpid,
             (uint64_t)startpos, (uint64_t)maxcount, READ_LOCK,
             &lock);
 
         if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
-                reply_readbraw_error();
+                reply_readbraw_error(sconn);
                 END_PROFILE(SMBreadbraw);
                 return;
@@ -3201 +3298 @@
         struct byte_range_lock *br_lck = NULL;
         char *p = NULL;
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
 
         START_PROFILE(SMBlockread);
@@ -3241 +3338 @@
          */
 
-        br_lck = do_lock(smbd_messaging_context(),
+        br_lck = do_lock(req->sconn->msg_ctx,
                         fsp,
-                        req->smbpid,
+                        (uint64_t)req->smbpid,
                         (uint64_t)numtoread,
                         (uint64_t)startpos,
@@ -3311 +3408 @@
         files_struct *fsp;
         struct lock_struct lock;
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
 
         START_PROFILE(SMBread);
@@ -3354 +3451 @@
         data = smb_buf(req->outbuf) + 3;
 
-        init_strict_lock_struct(fsp, (uint32)req->smbpid,
+        init_strict_lock_struct(fsp, (uint64_t)req->smbpid,
             (uint64_t)startpos, (uint64_t)numtoread, READ_LOCK,
             &lock);
@@ -3436 +3533 @@
         }
 
-        init_strict_lock_struct(fsp, (uint32)req->smbpid,
+        init_strict_lock_struct(fsp, (uint64_t)req->smbpid,
             (uint64_t)startpos, (uint64_t)smb_maxcnt, READ_LOCK,
             &lock);
@@ -3455 +3552 @@
         }
 
-#if defined(WITH_SENDFILE)
         /*
          * We can only use sendfile on a non-chained packet
@@ -3465 +3561 @@
             !is_encrypted_packet(req->inbuf) && (fsp->base_fsp == NULL) &&
             (fsp->wcp == NULL) &&
-            lp_use_sendfile(SNUM(conn), smbd_server_conn->smb1.signing_state) ) {
+            lp_use_sendfile(SNUM(conn), req->sconn->smb1.signing_state) ) {
                 uint8 headerbuf[smb_size + 12 * 2];
                 DATA_BLOB header;
@@ -3480 +3576 @@
                 setup_readX_header(req, (char *)headerbuf, smb_maxcnt);
 
-                if ((nread = SMB_VFS_SENDFILE(smbd_server_fd(), fsp, &header, startpos, smb_maxcnt)) == -1) {
+                nread = SMB_VFS_SENDFILE(req->sconn->sock, fsp, &header,
+                                         startpos, smb_maxcnt);
+                if (nread == -1) {
                         /* Returning ENOSYS means no data at all was sent.
                            Do this as a normal read. */
@@ -3546 +3644 @@
 normal_read:
 
-#endif
-
         if ((smb_maxcnt & 0xFF0000) > 0x10000) {
                 uint8 headerbuf[smb_size + 2*12];
@@ -3555 +3651 @@
 
                 /* Send out the header. */
-                if (write_data(smbd_server_fd(), (char *)headerbuf,
+                if (write_data(req->sconn->sock, (char *)headerbuf,
                                sizeof(headerbuf)) != sizeof(headerbuf)) {
+
+                        char addr[INET6_ADDRSTRLEN];
+                        /*
+                         * Try and give an error message saying what
+                         * client failed.
+                         */
+                        DEBUG(0, ("write_data failed for client %s. "
+                                  "Error %s\n",
+                                  get_peer_addr(req->sconn->sock, addr,
+                                                sizeof(addr)),
+                                  strerror(errno)));
+
                         DEBUG(0,("send_file_readX: write_data failed for file "
                                  "%s (%s). Terminating\n", fsp_str_dbg(fsp),
@@ -3655 +3763 @@
                         }
                         /* We currently don't do this on signed or sealed data. */
-                        if (srv_is_signing_active(smbd_server_conn) ||
+                        if (srv_is_signing_active(req->sconn) ||
                             is_encrypted_packet(req->inbuf)) {
                                 reply_nterror(req, NT_STATUS_NOT_SUPPORTED);
@@ -3698 +3806 @@
         }
 
-        if (!big_readX &&
-            schedule_aio_read_and_X(conn, req, fsp, startpos, smb_maxcnt)) {
-                goto out;
-        }
-
+        if (!big_readX) {
+                NTSTATUS status = schedule_aio_read_and_X(conn,
+                                        req,
+                                        fsp,
+                                        startpos,
+                                        smb_maxcnt);
+                if (NT_STATUS_IS_OK(status)) {
+                        /* Read scheduled - we're done. */
+                        goto out;
+                }
+                if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) {
+                        /* Real error - report to client. */
+                        END_PROFILE(SMBreadX);
+                        reply_nterror(req, status);
+                        return;
+                }
+                /* NT_STATUS_RETRY - fall back to sync read. */
+        }
+
+        smbd_lock_socket(req->sconn);
         send_file_readX(conn, req, fsp, startpos, smb_maxcnt);
+        smbd_unlock_socket(req->sconn);
 
  out:
@@ -3722 +3846 @@
         memcpy(req->outbuf, old_outbuf, smb_size);
         TALLOC_FREE(old_outbuf);
+}
+
+/****************************************************************************
+ Read 4 bytes of a smb packet and return the smb length of the packet.
+ Store the result in the buffer. This version of the function will
+ never return a session keepalive (length of zero).
+ Timeout is in milliseconds.
+****************************************************************************/
+
+static NTSTATUS read_smb_length(int fd, char *inbuf, unsigned int timeout,
+                                size_t *len)
+{
+        uint8_t msgtype = SMBkeepalive;
+
+        while (msgtype == SMBkeepalive) {
+                NTSTATUS status;
+
+                status = read_smb_length_return_keepalive(fd, inbuf, timeout,
+                                                          len);
+                if (!NT_STATUS_IS_OK(status)) {
+                        char addr[INET6_ADDRSTRLEN];
+                        /* Try and give an error message
+                         * saying what client failed. */
+                        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;
+                }
+
+                msgtype = CVAL(inbuf, 0);
+        }
+
+        DEBUG(10,("read_smb_length: got smb length of %lu\n",
+                  (unsigned long)len));
+
+        return NT_STATUS_OK;
 }
 
@@ -3752 +3913 @@
         SCVAL(req->inbuf,smb_com,SMBwritec);
 
-        if (srv_is_signing_active(smbd_server_conn)) {
+        if (srv_is_signing_active(req->sconn)) {
                 END_PROFILE(SMBwritebraw);
                 exit_server_cleanly("reply_writebraw: SMB signing is active - "
@@ -3760 +3921 @@
         if (req->wct < 12) {
                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                error_to_writebrawerr(req);
+                END_PROFILE(SMBwritebraw);
+                return;
+        }
+
+        if (req->sconn->smb1.echo_handler.trusted_fde) {
+                DEBUG(2,("SMBwritebraw rejected with NOT_SUPPORTED because of "
+                         "'async smb echo handler = yes'\n"));
+                reply_nterror(req, NT_STATUS_NOT_SUPPORTED);
                 error_to_writebrawerr(req);
                 END_PROFILE(SMBwritebraw);
@@ -3802 +3972 @@
         }
 
-        init_strict_lock_struct(fsp, (uint32)req->smbpid,
-            (uint64_t)startpos, (uint64_t)tcount, WRITE_LOCK,
-            &lock);
-
-        if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
-                reply_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
-                error_to_writebrawerr(req);
-                END_PROFILE(SMBwritebraw);
-                return;
+        if (!fsp->print_file) {
+                init_strict_lock_struct(fsp, (uint64_t)req->smbpid,
+                    (uint64_t)startpos, (uint64_t)tcount, WRITE_LOCK,
+                    &lock);
+
+                if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
+                        reply_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
+                        error_to_writebrawerr(req);
+                        END_PROFILE(SMBwritebraw);
+                        return;
+                }
         }
 
@@ -3846 +4018 @@
         SSVALS(buf,smb_vwv0,0xFFFF);
         show_msg(buf);
-        if (!srv_send_smb(smbd_server_fd(),
+        if (!srv_send_smb(req->sconn,
                           buf,
                           false, 0, /* no signing */
@@ -3856 +4028 @@
 
         /* Now read the raw data into the buffer and write it */
-        status = read_smb_length(smbd_server_fd(), buf, SMB_SECONDARY_WAIT,
+        status = read_smb_length(req->sconn->sock, buf, SMB_SECONDARY_WAIT,
                                  &numtowrite);
         if (!NT_STATUS_IS_OK(status)) {
@@ -3880 +4052 @@
                 }
 
-                status = read_data(smbd_server_fd(), buf+4, numtowrite);
+                status = read_data(req->sconn->sock, buf+4, numtowrite);
 
                 if (!NT_STATUS_IS_OK(status)) {
-                        DEBUG(0,("reply_writebraw: Oversize secondary write "
-                                 "raw read failed (%s). Terminating\n",
-                                 nt_errstr(status)));
+                        char addr[INET6_ADDRSTRLEN];
+                        /* Try and give an error message
+                         * saying what client failed. */
+                        DEBUG(0, ("reply_writebraw: Oversize secondary write "
+                                  "raw read failed (%s) for client %s. "
+                                  "Terminating\n", nt_errstr(status),
+                                  get_peer_addr(req->sconn->sock, addr,
+                                                sizeof(addr))));
                         exit_server_cleanly("secondary writebraw failed");
                 }
@@ -3924 +4101 @@
                 (int)total_written));
 
-        SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
+        if (!fsp->print_file) {
+                SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
+        }
 
         /* We won't return a status if write through is not selected - this
@@ -3938 +4117 @@
                  * JRA.
                  */
-                if (!send_keepalive(smbd_server_fd())) {
+                if (!send_keepalive(req->sconn->sock)) {
                         exit_server_cleanly("reply_writebraw: send of "
                                 "keepalive failed");
@@ -3948 +4127 @@
 
 strict_unlock:
-        SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
+        if (!fsp->print_file) {
+                SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
+        }
 
         END_PROFILE(SMBwritebraw);
@@ -3998 +4179 @@
         data = (const char *)req->buf + 3;
 
-        if (numtowrite) {
-                init_strict_lock_struct(fsp, (uint32)req->smbpid,
+        if (!fsp->print_file && numtowrite > 0) {
+                init_strict_lock_struct(fsp, (uint64_t)req->smbpid,
                     (uint64_t)startpos, (uint64_t)numtowrite, WRITE_LOCK,
                     &lock);
@@ -4038 +4219 @@
         }
 
-        if (numtowrite) {
-                status = do_unlock(smbd_messaging_context(),
+        if (numtowrite && !fsp->print_file) {
+                status = do_unlock(req->sconn->msg_ctx,
                                 fsp,
-                                req->smbpid,
+                                (uint64_t)req->smbpid,
                                 (uint64_t)numtowrite, 
                                 (uint64_t)startpos,
@@ -4060 +4241 @@
 
 strict_unlock:
-        if (numtowrite) {
+        if (numtowrite && !fsp->print_file) {
                 SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
         }
@@ -4119 +4300 @@
         data = (const char *)req->buf + 3;
 
-        init_strict_lock_struct(fsp, (uint32)req->smbpid,
-            (uint64_t)startpos, (uint64_t)numtowrite, WRITE_LOCK,
-            &lock);
-
-        if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
-                reply_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
-                END_PROFILE(SMBwrite);
-                return;
+        if (!fsp->print_file) {
+                init_strict_lock_struct(fsp, (uint64_t)req->smbpid,
+                        (uint64_t)startpos, (uint64_t)numtowrite, WRITE_LOCK,
+                        &lock);
+
+                if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
+                        reply_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
+                        END_PROFILE(SMBwrite);
+                        return;
+                }
         }
 
@@ -4184 +4367 @@
 
 strict_unlock:
-        SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
+        if (!fsp->print_file) {
+                SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
+        }
 
         END_PROFILE(SMBwrite);
@@ -4198 +4383 @@
                                                 1 /* pad byte */)
 
-bool is_valid_writeX_buffer(const uint8_t *inbuf)
+bool is_valid_writeX_buffer(struct smbd_server_connection *sconn,
+                            const uint8_t *inbuf)
 {
         size_t numtowrite;
@@ -4204 +4390 @@
         unsigned int doff = 0;
         size_t len = smb_len_large(inbuf);
-        struct smbd_server_connection *sconn = smbd_server_conn;
 
         if (is_encrypted_packet(inbuf)) {
@@ -4293 +4478 @@
         char *data;
         NTSTATUS status;
+        int saved_errno = 0;
 
         START_PROFILE(SMBwriteX);
@@ -4387 +4573 @@
         }
 
-        init_strict_lock_struct(fsp, (uint32)req->smbpid,
-            (uint64_t)startpos, (uint64_t)numtowrite, WRITE_LOCK,
-            &lock);
-
-        if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
-                reply_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
-                END_PROFILE(SMBwriteX);
-                return;
-        }
-
         /* X/Open SMB protocol says that, unlike SMBwrite
         if the length is zero then NO truncation is
@@ -4405 +4581 @@
                 nwritten = 0;
         } else {
-
-                if ((req->unread_bytes == 0) &&
-                    schedule_aio_write_and_X(conn, req, fsp, data, startpos,
-                                             numtowrite)) {
-                        goto strict_unlock;
+                if (req->unread_bytes == 0) {
+                        status = schedule_aio_write_and_X(conn,
+                                                req,
+                                                fsp,
+                                                data,
+                                                startpos,
+                                                numtowrite);
+
+                        if (NT_STATUS_IS_OK(status)) {
+                                /* write scheduled - we're done. */
+                                goto out;
+                        }
+                        if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) {
+                                /* Real error - report to client. */
+                                reply_nterror(req, status);
+                                goto out;
+                        }
+                        /* NT_STATUS_RETRY - fall through to sync write. */
+                }
+
+                init_strict_lock_struct(fsp, (uint64_t)req->smbpid,
+                    (uint64_t)startpos, (uint64_t)numtowrite, WRITE_LOCK,
+                    &lock);
+
+                if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) {
+                        reply_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT);
+                        goto out;
                 }
 
                 nwritten = write_file(req,fsp,data,startpos,numtowrite);
+                saved_errno = errno;
+
+                SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
         }
 
         if(nwritten < 0) {
-                reply_nterror(req, map_nt_error_from_unix(errno));
-                goto strict_unlock;
+                reply_nterror(req, map_nt_error_from_unix(saved_errno));
+                goto out;
         }
 
         if((nwritten == 0) && (numtowrite != 0)) {
                 reply_nterror(req, NT_STATUS_DISK_FULL);
-                goto strict_unlock;
+                goto out;
         }
 
@@ -4442 +4643 @@
                          fsp_str_dbg(fsp), nt_errstr(status)));
                 reply_nterror(req, status);
-                goto strict_unlock;
-        }
-
-        SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
+                goto out;
+        }
 
         END_PROFILE(SMBwriteX);
@@ -4451 +4650 @@
         return;
 
-strict_unlock:
-        SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
-
+out:
         END_PROFILE(SMBwriteX);
         return;
@@ -4598 +4795 @@
         START_PROFILE(SMBexit);
 
-        file_close_pid(req->smbpid, req->vuid);
+        file_close_pid(req->sconn, req->smbpid, req->vuid);
 
         reply_outbuf(req, 0, 0);
@@ -4631 +4828 @@
          */
 
-        if(!fsp || (fsp->conn != conn) || (fsp->vuid != req->vuid)) {
+        if (!check_fsp_open(conn, req, fsp)) {
                 reply_nterror(req, NT_STATUS_INVALID_HANDLE);
                 END_PROFILE(SMBclose);
@@ -4721 +4918 @@
         data = (const char *)req->buf + 1;
 
-        if (numtowrite) {
-                init_strict_lock_struct(fsp, (uint32)req->smbpid,
+        if (!fsp->print_file) {
+                init_strict_lock_struct(fsp, (uint64_t)req->smbpid,
                     (uint64_t)startpos, (uint64_t)numtowrite, WRITE_LOCK,
                     &lock);
@@ -4767 +4964 @@
 
 strict_unlock:
-        if (numtowrite) {
+        if (numtowrite && !fsp->print_file) {
                 SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock);
         }
@@ -4811 +5008 @@
                  fsp->fh->fd, fsp->fnum, (double)offset, (double)count));
 
-        br_lck = do_lock(smbd_messaging_context(),
+        br_lck = do_lock(req->sconn->msg_ctx,
                         fsp,
-                        req->smbpid,
+                        (uint64_t)req->smbpid,
                         count,
                         offset,
@@ -4866 +5063 @@
         offset = (uint64_t)IVAL(req->vwv+3, 0);
 
-        status = do_unlock(smbd_messaging_context(),
+        status = do_unlock(req->sconn->msg_ctx,
                         fsp,
-                        req->smbpid,
+                        (uint64_t)req->smbpid,
                         count,
                         offset,
@@ -4968 +5165 @@
 
                 show_msg((char *)req->outbuf);
-                if (!srv_send_smb(smbd_server_fd(),
+                if (!srv_send_smb(req->sconn,
                                 (char *)req->outbuf,
                                 true, req->seqnum+1,
@@ -5016 +5213 @@
 
         /* Open for exclusive use, write only. */
-        status = print_fsp_open(req, conn, NULL, req->vuid, fsp);
+        status = print_spool_open(fsp, NULL, req->vuid);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -5124 +5321 @@
 
         {
-                print_queue_struct *queue = NULL;
-                print_status_struct status;
-                int count = print_queue_status(SNUM(conn), &queue, &status);
-                int num_to_get = ABS(max_count);
-                int first = (max_count>0?start_index:start_index+max_count+1);
-                int i;
-
-                if (first >= count)
-                        num_to_get = 0;
-                else
-                        num_to_get = MIN(num_to_get,count-first);
-
-
-                for (i=first;i<first+num_to_get;i++) {
+                TALLOC_CTX *mem_ctx = talloc_tos();
+                NTSTATUS status;
+                WERROR werr;
+                const char *sharename = lp_servicename(SNUM(conn));
+                struct rpc_pipe_client *cli = NULL;
+                struct dcerpc_binding_handle *b = NULL;
+                struct policy_handle handle;
+                struct spoolss_DevmodeContainer devmode_ctr;
+                union spoolss_JobInfo *info;
+                uint32_t count;
+                uint32_t num_to_get;
+                uint32_t first;
+                uint32_t i;
+
+                ZERO_STRUCT(handle);
+
+                status = rpc_pipe_open_interface(conn,
+                                                 &ndr_table_spoolss.syntax_id,
+                                                 conn->session_info,
+                                                 &conn->sconn->client_id,
+                                                 conn->sconn->msg_ctx,
+                                                 &cli);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("reply_printqueue: "
+                                  "could not connect to spoolss: %s\n",
+                                  nt_errstr(status)));
+                        reply_nterror(req, status);
+                        goto out;
+                }
+                b = cli->binding_handle;
+
+                ZERO_STRUCT(devmode_ctr);
+
+                status = dcerpc_spoolss_OpenPrinter(b, mem_ctx,
+                                                sharename,
+                                                NULL, devmode_ctr,
+                                                SEC_FLAG_MAXIMUM_ALLOWED,
+                                                &handle,
+                                                &werr);
+                if (!NT_STATUS_IS_OK(status)) {
+                        reply_nterror(req, status);
+                        goto out;
+                }
+                if (!W_ERROR_IS_OK(werr)) {
+                        reply_nterror(req, werror_to_ntstatus(werr));
+                        goto out;
+                }
+
+                werr = rpccli_spoolss_enumjobs(cli, mem_ctx,
+                                               &handle,
+                                               0, /* firstjob */
+                                               0xff, /* numjobs */
+                                               2, /* level */
+                                               0, /* offered */
+                                               &count,
+                                               &info);
+                if (!W_ERROR_IS_OK(werr)) {
+                        reply_nterror(req, werror_to_ntstatus(werr));
+                        goto out;
+                }
+
+                if (max_count > 0) {
+                        first = start_index;
+                } else {
+                        first = start_index + max_count + 1;
+                }
+
+                if (first >= count) {
+                        num_to_get = first;
+                } else {
+                        num_to_get = first + MIN(ABS(max_count), count - first);
+                }
+
+                for (i = first; i < num_to_get; i++) {
                         char blob[28];
                         char *p = blob;
-
-                        srv_put_dos_date2(p,0,queue[i].time);
-                        SCVAL(p,4,(queue[i].status==LPQ_PRINTING?2:3));
-                        SSVAL(p,5, queue[i].job);
-                        SIVAL(p,7,queue[i].size);
-                        SCVAL(p,11,0);
+                        time_t qtime = spoolss_Time_to_time_t(&info[i].info2.submitted);
+                        int qstatus;
+                        uint16_t qrapjobid = pjobid_to_rap(sharename,
+                                                        info[i].info2.job_id);
+
+                        if (info[i].info2.status == JOB_STATUS_PRINTING) {
+                                qstatus = 2;
+                        } else {
+                                qstatus = 3;
+                        }
+
+                        srv_put_dos_date2(p, 0, qtime);
+                        SCVAL(p, 4, qstatus);
+                        SSVAL(p, 5, qrapjobid);
+                        SIVAL(p, 7, info[i].info2.size);
+                        SCVAL(p, 11, 0);
                         srvstr_push(blob, req->flags2, p+12,
-                                    queue[i].fs_user, 16, STR_ASCII);
+                                    info[i].info2.notify_name, 16, STR_ASCII);
 
                         if (message_push_blob(
@@ -5154 +5421 @@
                                             blob, sizeof(blob))) == -1) {
                                 reply_nterror(req, NT_STATUS_NO_MEMORY);
-                                END_PROFILE(SMBsplretq);
-                                return;
+                                goto out;
                         }
                 }
@@ -5167 +5433 @@
                 }
 
-                SAFE_FREE(queue);
-
-                DEBUG(3,("%d entries returned in queue\n",count));
+
+                DEBUG(3, ("%u entries returned in queue\n",
+                          (unsigned)count));
+
+out:
+                if (b && is_valid_policy_hnd(&handle)) {
+                        dcerpc_spoolss_ClosePrinter(b, mem_ctx, &handle, &werr);
+                }
+
         }
 
@@ -5202 +5474 @@
         }
 
-        if (!CAN_PRINT(conn)) {
+        if (!fsp->print_file) {
                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
                 END_PROFILE(SMBsplwr);
@@ -5224 +5496 @@
         data = (const char *)req->buf + 3;
 
-        if (write_file(req,fsp,data,-1,numtowrite) != numtowrite) {
+        if (write_file(req,fsp,data,(SMB_OFF_T)-1,numtowrite) != numtowrite) {
                 reply_nterror(req, map_nt_error_from_unix(errno));
                 END_PROFILE(SMBsplwr);
@@ -5316 +5588 @@
         files_struct *fsp = NULL;
         int info = 0;
-        struct smbd_server_connection *sconn = smbd_server_conn;
+        struct smbd_server_connection *sconn = req->sconn;
 
         START_PROFILE(SMBrmdir);
@@ -5361 +5633 @@
                 0,                                      /* oplock_request */
                 0,                                      /* allocation_size */
+                0,                                      /* private_flags */
                 NULL,                                   /* sd */
                 NULL,                                   /* ea_list */
@@ -5382 +5655 @@
         }
 
-        if (!set_delete_on_close(fsp, true, &conn->server_info->utok)) {
+        if (!set_delete_on_close(fsp, true, &conn->session_info->utok)) {
                 close_file(req, fsp, ERROR_CLOSE);
                 reply_nterror(req, NT_STATUS_ACCESS_DENIED);
@@ -5538 +5811 @@
 static void rename_open_files(connection_struct *conn,
                               struct share_mode_lock *lck,
+                              uint32_t orig_name_hash,
                               const struct smb_filename *smb_fname_dst)
 {
@@ -5543 +5817 @@
         bool did_rename = False;
         NTSTATUS status;
-
-        for(fsp = file_find_di_first(lck->id); fsp;
+        uint32_t new_name_hash;
+
+        for(fsp = file_find_di_first(conn->sconn, lck->id); fsp;
             fsp = file_find_di_next(fsp)) {
                 /* fsp_name is a relative path under the fsp. To change this for other
@@ -5553 +5828 @@
                         continue;
                 }
+                if (fsp->name_hash != orig_name_hash) {
+                        continue;
+                }
                 DEBUG(10, ("rename_open_files: renaming file fnum %d "
                            "(file_id %s) from %s -> %s\n", fsp->fnum,
@@ -5561 +5839 @@
                 if (NT_STATUS_IS_OK(status)) {
                         did_rename = True;
+                        new_name_hash = fsp->name_hash;
                 }
         }
@@ -5571 +5850 @@
 
         /* Send messages to all smbd's (not ourself) that the name has changed. */
-        rename_share_filename(smbd_messaging_context(), lck, conn->connectpath,
+        rename_share_filename(conn->sconn->msg_ctx, lck, conn->connectpath,
+                              orig_name_hash, new_name_hash,
                               smb_fname_dst);
 
@@ -5681 +5961 @@
         if (!NT_STATUS_IS_OK(status)) {
                 goto out;
-        }
-
-        /* Ensure the dst smb_fname contains a '/' */
-        if(strrchr_m(smb_fname_dst->base_name,'/') == 0) {
-                char * tmp;
-                tmp = talloc_asprintf(smb_fname_dst, "./%s",
-                                      smb_fname_dst->base_name);
-                if (!tmp) {
-                        status = NT_STATUS_NO_MEMORY;
-                        goto out;
-                }
-                TALLOC_FREE(smb_fname_dst->base_name);
-                smb_fname_dst->base_name = tmp;
         }
 
@@ -5711 +5978 @@
 
                 /*
-                 * Get the last component of the destination name.  Note that
-                 * we guarantee that destination name contains a '/' character
-                 * above.
+                 * Get the last component of the destination name.
                  */
                 last_slash = strrchr_m(smb_fname_dst->base_name, '/');
-                fname_dst_lcomp_base_mod = talloc_strdup(ctx, last_slash + 1);
+                if (last_slash) {
+                        fname_dst_lcomp_base_mod = talloc_strdup(ctx, last_slash + 1);
+                } else {
+                        fname_dst_lcomp_base_mod = talloc_strdup(ctx, smb_fname_dst->base_name);
+                }
                 if (!fname_dst_lcomp_base_mod) {
                         status = NT_STATUS_NO_MEMORY;
@@ -5742 +6011 @@
                          * original.
                          */
-                        *last_slash = '\0'; /* Truncate at the '/' */
-                        tmp = talloc_asprintf(smb_fname_dst,
+                        if (last_slash) {
+                                *last_slash = '\0'; /* Truncate at the '/' */
+                                tmp = talloc_asprintf(smb_fname_dst,
                                         "%s/%s",
                                         smb_fname_dst->base_name,
                                         smb_fname_orig_lcomp->base_name);
+                        } else {
+                                tmp = talloc_asprintf(smb_fname_dst,
+                                        "%s",
+                                        smb_fname_orig_lcomp->base_name);
+                        }
                         if (tmp == NULL) {
                                 status = NT_STATUS_NO_MEMORY;
@@ -5819 +6094 @@
                 struct file_id fileid = vfs_file_id_from_sbuf(conn,
                     &smb_fname_dst->st);
-                files_struct *dst_fsp = file_find_di_first(fileid);
+                files_struct *dst_fsp = file_find_di_first(conn->sconn,
+                                                           fileid);
                 /* The file can be open when renaming a stream */
                 if (dst_fsp && !new_is_stream) {
@@ -5885 +6161 @@
                               smb_fname_dst);
 
-                rename_open_files(conn, lck, smb_fname_dst);
+                rename_open_files(conn, lck, fsp->name_hash, smb_fname_dst);
 
                 /*
@@ -6000 +6276 @@
                  */
                 TALLOC_FREE(smb_fname_src->base_name);
-                smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
-                                                           "%s/%s",
-                                                           fname_src_dir,
-                                                           fname_src_mask);
+                if (ISDOT(fname_src_dir)) {
+                        /* Ensure we use canonical names on open. */
+                        smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
+                                                        "%s",
+                                                        fname_src_mask);
+                } else {
+                        smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
+                                                        "%s/%s",
+                                                        fname_src_dir,
+                                                        fname_src_mask);
+                }
                 if (!smb_fname_src->base_name) {
                         status = NT_STATUS_NO_MEMORY;
                         goto out;
-                }
-
-                /* Ensure dst fname contains a '/' also */
-                if(strrchr_m(smb_fname_dst->base_name, '/') == 0) {
-                        char *tmp;
-                        tmp = talloc_asprintf(smb_fname_dst, "./%s",
-                                              smb_fname_dst->base_name);
-                        if (!tmp) {
-                                status = NT_STATUS_NO_MEMORY;
-                                goto out;
-                        }
-                        TALLOC_FREE(smb_fname_dst->base_name);
-                        smb_fname_dst->base_name = tmp;
                 }
 
@@ -6074 +6344 @@
                         0,                              /* oplock_request */
                         0,                              /* allocation_size */
+                        0,                              /* private_flags */
                         NULL,                           /* sd */
                         NULL,                           /* ea_list */
@@ -6136 +6407 @@
                 /* Quick check for "." and ".." */
                 if (ISDOT(dname) || ISDOTDOT(dname)) {
-                        if (attrs & aDIR) {
+                        if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
                                 sysdir_entry = True;
                         } else {
@@ -6161 +6432 @@
 
                 TALLOC_FREE(smb_fname_src->base_name);
-                smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
-                                                           "%s/%s",
-                                                           fname_src_dir,
-                                                           dname);
+                if (ISDOT(fname_src_dir)) {
+                        /* Ensure we use canonical names on open. */
+                        smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
+                                                        "%s",
+                                                        dname);
+                } else {
+                        smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
+                                                        "%s/%s",
+                                                        fname_src_dir,
+                                                        dname);
+                }
                 if (!smb_fname_src->base_name) {
                         status = NT_STATUS_NO_MEMORY;
@@ -6212 +6490 @@
                         0,                              /* oplock_request */
                         0,                              /* allocation_size */
+                        0,                              /* private_flags */
                         NULL,                           /* sd */
                         NULL,                           /* ea_list */
@@ -6283 +6562 @@
         struct smb_filename *smb_fname_src = NULL;
         struct smb_filename *smb_fname_dst = NULL;
+        bool stream_rename = false;
 
         START_PROFILE(SMBmv);
@@ -6307 +6587 @@
                 goto out;
         }
+
+        if (!lp_posix_pathnames()) {
+                /* The newname must begin with a ':' if the
+                   name contains a ':'. */
+                if (strchr_m(name, ':')) {
+                        if (newname[0] != ':') {
+                                reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
+                                goto out;
+                        }
+                        stream_rename = true;
+                }
+        }
 
         status = filename_convert(ctx,
@@ -6344 +6636 @@
         }
 
+        if (stream_rename) {
+                /* smb_fname_dst->base_name must be the same as
+                   smb_fname_src->base_name. */
+                TALLOC_FREE(smb_fname_dst->base_name);
+                smb_fname_dst->base_name = talloc_strdup(smb_fname_dst,
+                                                smb_fname_src->base_name);
+                if (!smb_fname_dst->base_name) {
+                        reply_nterror(req, NT_STATUS_NO_MEMORY);
+                        goto out;
+                }
+        }
+
         DEBUG(3,("reply_mv : %s -> %s\n", smb_fname_str_dbg(smb_fname_src),
                  smb_fname_str_dbg(smb_fname_dst)));
@@ -6432 +6736 @@
                                                  NULL, NULL,
                                                  &new_create_disposition,
+                                                 NULL,
                                                  NULL)) {
                         status = NT_STATUS_INVALID_PARAMETER;
@@ -6451 +6756 @@
                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
                 0,                                      /* allocation_size */
+                0,                                      /* private_flags */
                 NULL,                                   /* sd */
                 NULL,                                   /* ea_list */
@@ -6479 +6785 @@
                 INTERNAL_OPEN_ONLY,                     /* oplock_request */
                 0,                                      /* allocation_size */
+                0,                                      /* private_flags */
                 NULL,                                   /* sd */
                 NULL,                                   /* ea_list */
@@ -6489 +6796 @@
         }
 
-        if ((ofun&3) == 1) {
-                if(SMB_VFS_LSEEK(fsp2,0,SEEK_END) == -1) {
-                        DEBUG(0,("copy_file: error - vfs lseek returned error %s\n", strerror(errno) ));
-                        /*
-                         * Stop the copy from occurring.
-                         */
-                        ret = -1;
-                        smb_fname_src->st.st_ex_size = 0;
+        if (ofun & OPENX_FILE_EXISTS_OPEN) {
+                ret = SMB_VFS_LSEEK(fsp2, 0, SEEK_END);
+                if (ret == -1) {
+                        DEBUG(0, ("error - vfs lseek returned error %s\n",
+                                strerror(errno)));
+                        status = map_nt_error_from_unix(errno);
+                        close_file(NULL, fsp1, ERROR_CLOSE);
+                        close_file(NULL, fsp2, ERROR_CLOSE);
+                        goto out;
                 }
         }
@@ -6503 +6811 @@
         if (smb_fname_src->st.st_ex_size) {
                 ret = vfs_transfer_file(fsp1, fsp2, smb_fname_src->st.st_ex_size);
+        } else {
+                ret = 0;
         }
 
@@ -6680 +6990 @@
                  */
                 TALLOC_FREE(smb_fname_src->base_name);
-                smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
-                                                           "%s/%s",
-                                                           fname_src_dir,
-                                                           fname_src_mask);
+                if (ISDOT(fname_src_dir)) {
+                        /* Ensure we use canonical names on open. */
+                        smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
+                                                        "%s",
+                                                        fname_src_mask);
+                } else {
+                        smb_fname_src->base_name = talloc_asprintf(smb_fname_src,
+                                                        "%s/%s",
+                                                        fname_src_dir,
+                                                        fname_src_mask);
+                }
                 if (!smb_fname_src->base_name) {
                         reply_nterror(req, NT_STATUS_NO_MEMORY);
@@ -6791 +7108 @@
                         /* Get the src smb_fname struct setup. */
                         TALLOC_FREE(smb_fname_src->base_name);
-                        smb_fname_src->base_name =
-                            talloc_asprintf(smb_fname_src, "%s/%s",
-                                            fname_src_dir, dname);
+                        if (ISDOT(fname_src_dir)) {
+                                /* Ensure we use canonical names on open. */
+                                smb_fname_src->base_name =
+                                        talloc_asprintf(smb_fname_src, "%s",
+                                                dname);
+                        } else {
+                                smb_fname_src->base_name =
+                                        talloc_asprintf(smb_fname_src, "%s/%s",
+                                                fname_src_dir, dname);
+                        }
 
                         if (!smb_fname_src->base_name) {
@@ -6876 +7200 @@
 ****************************************************************************/
 
-uint32 get_lock_pid(const uint8_t *data, int data_offset,
+uint64_t get_lock_pid(const uint8_t *data, int data_offset,
                     bool large_file_format)
 {
         if(!large_file_format)
-                return (uint32)SVAL(data,SMB_LPID_OFFSET(data_offset));
+                return (uint64_t)SVAL(data,SMB_LPID_OFFSET(data_offset));
         else
-                return (uint32)SVAL(data,SMB_LARGE_LPID_OFFSET(data_offset));
+                return (uint64_t)SVAL(data,SMB_LARGE_LPID_OFFSET(data_offset));
 }
 
@@ -7033 +7357 @@
                           (double)e->offset,
                           (double)e->count,
-                          (unsigned int)e->smbpid,
+                          (unsigned int)e->smblctx,
                           fsp_str_dbg(fsp)));
 
@@ -7041 +7365 @@
                 }
 
-                status = do_unlock(smbd_messaging_context(),
+                status = do_unlock(req->sconn->msg_ctx,
                                 fsp,
-                                e->smbpid,
+                                e->smblctx,
                                 e->count,
                                 e->offset,
@@ -7068 +7392 @@
                 struct smbd_lock_element *e = &locks[i];
 
-                DEBUG(10,("smbd_do_locking: lock start=%.0f, len=%.0f for pid "
-                          "%u, file %s timeout = %d\n",
+                DEBUG(10,("smbd_do_locking: lock start=%.0f, len=%.0f for smblctx "
+                          "%llu, file %s timeout = %d\n",
                           (double)e->offset,
                           (double)e->count,
-                          (unsigned int)e->smbpid,
+                          (unsigned long long)e->smblctx,
                           fsp_str_dbg(fsp),
                           (int)timeout));
@@ -7109 +7433 @@
                                    return the right error. */
 
-                                blr = blocking_lock_cancel(fsp,
-                                                e->smbpid,
+                                blr = blocking_lock_cancel_smb1(fsp,
+                                                e->smblctx,
                                                 e->offset,
                                                 e->count,
@@ -7124 +7448 @@
                         /* Remove a matching pending lock. */
                         status = do_lock_cancel(fsp,
-                                                e->smbpid,
+                                                e->smblctx,
                                                 e->count,
                                                 e->offset,
@@ -7133 +7457 @@
                         bool defer_lock = false;
                         struct byte_range_lock *br_lck;
-                        uint32_t block_smbpid;
-
-                        br_lck = do_lock(smbd_messaging_context(),
+                        uint64_t block_smblctx;
+
+                        br_lck = do_lock(req->sconn->msg_ctx,
                                         fsp,
-                                        e->smbpid,
+                                        e->smblctx,
                                         e->count,
                                         e->offset, 
@@ -7144 +7468 @@
                                         blocking_lock,
                                         &status,
-                                        &block_smbpid,
+                                        &block_smblctx,
                                         NULL);
 
@@ -7167 +7491 @@
                          * Replacement for do_lock_spin(). JRA. */
 
-                        if (br_lck && lp_blocking_locks(SNUM(conn)) &&
+                        if (!req->sconn->using_smb2 &&
+                            br_lck && lp_blocking_locks(SNUM(conn)) &&
                             lp_lock_spin_time() && !blocking_lock &&
                             NT_STATUS_EQUAL((status),
@@ -7187 +7512 @@
                                                         timeout,
                                                         i,
-                                                        e->smbpid,
+                                                        e->smblctx,
                                                         e->brltype,
                                                         WINDOWS_LOCK,
                                                         e->offset,
                                                         e->count,
-                                                        block_smbpid)) {
+                                                        block_smblctx)) {
                                         TALLOC_FREE(br_lck);
                                         *async = true;
@@ -7224 +7549 @@
                         struct smbd_lock_element *e = &locks[i];
 
-                        do_unlock(smbd_messaging_context(),
+                        do_unlock(req->sconn->msg_ctx,
                                 fsp,
-                                e->smbpid,
+                                e->smblctx,
                                 e->count,
                                 e->offset,
@@ -7391 +7716 @@
            of smb_unlkrng structs */
         for(i = 0; i < (int)num_ulocks; i++) {
-                ulocks[i].smbpid = get_lock_pid(data, i, large_file_format);
+                ulocks[i].smblctx = get_lock_pid(data, i, large_file_format);
                 ulocks[i].count = get_lock_count(data, i, large_file_format);
                 ulocks[i].offset = get_lock_offset(data, i, large_file_format, &err);
@@ -7413 +7738 @@
 
         for(i = 0; i < (int)num_locks; i++) {
-                locks[i].smbpid = get_lock_pid(data, i, large_file_format);
+                locks[i].smblctx = get_lock_pid(data, i, large_file_format);
                 locks[i].count = get_lock_count(data, i, large_file_format);
                 locks[i].offset = get_lock_offset(data, i, large_file_format, &err);
@@ -7648 +7973 @@
                           convert_timespec_to_time_t(fsp->fsp_name->st.st_ex_mtime));
 
-        if (mode & aDIR) {
+        if (mode & FILE_ATTRIBUTE_DIRECTORY) {
                 SIVAL(req->outbuf, smb_vwv6, 0);
                 SIVAL(req->outbuf, smb_vwv8, 0);