smbd: some write time fixes
[tprouty/samba.git] / source / smbd / nttrans.c
index 01ac1abeb0a98191ea08966d2ef663374685d759..0b48fa2c4d522104de041149bb013ccec8ead3b7 100644 (file)
@@ -66,7 +66,8 @@ static char *nttrans_realloc(char **ptr, size_t size)
  HACK ! Always assumes smb_setup field is zero.
 ****************************************************************************/
 
-void send_nt_replies(struct smb_request *req, NTSTATUS nt_error,
+void send_nt_replies(connection_struct *conn,
+                       struct smb_request *req, NTSTATUS nt_error,
                     char *params, int paramsize,
                     char *pdata, int datasize)
 {
@@ -242,8 +243,10 @@ void send_nt_replies(struct smb_request *req, NTSTATUS nt_error,
 
                /* Send the packet */
                show_msg((char *)req->outbuf);
-               if (!send_smb(smbd_server_fd(),(char *)req->outbuf)) {
-                       exit_server_cleanly("send_nt_replies: send_smb failed.");
+               if (!srv_send_smb(smbd_server_fd(),
+                               (char *)req->outbuf,
+                               IS_CONN_ENCRYPTED(conn))) {
+                       exit_server_cleanly("send_nt_replies: srv_send_smb failed.");
                }
 
                TALLOC_FREE(req->outbuf);
@@ -268,6 +271,9 @@ void send_nt_replies(struct smb_request *req, NTSTATUS nt_error,
 
 /****************************************************************************
  Is it an NTFS stream name ?
+ An NTFS file name is <path>.<extention>:<stream name>:<stream type>
+ $DATA can be used as both a stream name and a stream type. A missing stream
+ name or type implies $DATA.
 ****************************************************************************/
 
 bool is_ntfs_stream_name(const char *fname)
@@ -410,8 +416,9 @@ static void do_ntcreate_pipe_open(connection_struct *conn,
  Reply to an NT create and X call.
 ****************************************************************************/
 
-void reply_ntcreate_and_X(connection_struct *conn, struct smb_request *req)
+void reply_ntcreate_and_X(struct smb_request *req)
 {
+       connection_struct *conn = req->conn;
        char *fname = NULL;
        uint32 flags;
        uint32 access_mask;
@@ -433,6 +440,7 @@ void reply_ntcreate_and_X(connection_struct *conn, struct smb_request *req)
        struct timespec a_timespec;
        struct timespec m_timespec;
        NTSTATUS status;
+       int oplock_request;
        uint8_t oplock_granted = NO_OPLOCK_RETURN;
        TALLOC_CTX *ctx = talloc_tos();
 
@@ -481,6 +489,12 @@ void reply_ntcreate_and_X(connection_struct *conn, struct smb_request *req)
                        (unsigned int)root_dir_fid,
                        fname));
 
+       /*
+        * we need to remove ignored bits when they come directly from the client
+        * because we reuse some of them for internal stuff
+        */
+       create_options &= ~NTCREATEX_OPTIONS_MUST_IGNORE_MASK;
+
        /*
         * If it's an IPC, use the pipe handler.
         */
@@ -490,18 +504,22 @@ void reply_ntcreate_and_X(connection_struct *conn, struct smb_request *req)
                        do_ntcreate_pipe_open(conn, req);
                        END_PROFILE(SMBntcreateX);
                        return;
-               } else {
-                       reply_doserror(req, ERRDOS, ERRnoaccess);
-                       END_PROFILE(SMBntcreateX);
-                       return;
                }
+               reply_doserror(req, ERRDOS, ERRnoaccess);
+               END_PROFILE(SMBntcreateX);
+               return;
        }
 
-       status = create_file(conn, req, root_dir_fid, fname, flags,
+       oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
+       if (oplock_request) {
+               oplock_request |= (flags & REQUEST_BATCH_OPLOCK)
+                       ? BATCH_OPLOCK : 0;
+       }
+
+       status = create_file(conn, req, root_dir_fid, fname,
                             access_mask, share_access, create_disposition,
-                            create_options, file_attributes,
-                            allocation_size, NULL, NULL,
-                            &fsp, &info, &oplock_granted, &sbuf);
+                            create_options, file_attributes, oplock_request,
+                            allocation_size, NULL, NULL, &fsp, &info, &sbuf);
 
        if (!NT_STATUS_IS_OK(status)) {
                if (open_was_deferred(req->mid)) {
@@ -519,8 +537,33 @@ void reply_ntcreate_and_X(connection_struct *conn, struct smb_request *req)
                return;
        }
 
+       /*
+        * If the caller set the extended oplock request bit
+        * and we granted one (by whatever means) - set the
+        * correct bit for extended oplock reply.
+        */
+
+       if (oplock_request &&
+           (lp_fake_oplocks(SNUM(conn))
+            || EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))) {
+
+               /*
+                * Exclusive oplock granted
+                */
+
+               if (flags & REQUEST_BATCH_OPLOCK) {
+                       oplock_granted = BATCH_OPLOCK_RETURN;
+               } else {
+                       oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
+               }
+       } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
+               oplock_granted = LEVEL_II_OPLOCK_RETURN;
+       } else {
+               oplock_granted = NO_OPLOCK_RETURN;
+       }
+
        file_len = sbuf.st_size;
-       fattr = dos_mode(conn,fname,&sbuf);
+       fattr = dos_mode(conn,fsp->fsp_name,&sbuf);
        if (fattr == 0) {
                fattr = FILE_ATTRIBUTE_NORMAL;
        }
@@ -588,7 +631,7 @@ void reply_ntcreate_and_X(connection_struct *conn, struct smb_request *req)
                uint32 perms = 0;
                p += 25;
                if (fsp->is_directory
-                   || can_write_to_file(conn, fname, &sbuf)) {
+                   || can_write_to_file(conn, fsp->fsp_name, &sbuf)) {
                        perms = FILE_GENERIC_ALL;
                } else {
                        perms = FILE_GENERIC_READ|FILE_EXECUTE;
@@ -695,7 +738,7 @@ static void do_nt_transact_create_pipe(connection_struct *conn,
        DEBUG(5,("do_nt_transact_create_pipe: open name = %s\n", fname));
 
        /* Send the required number of replies */
-       send_nt_replies(req, NT_STATUS_OK, params, param_len, *ppdata, 0);
+       send_nt_replies(conn, req, NT_STATUS_OK, params, param_len, *ppdata, 0);
 
        return;
 }
@@ -704,46 +747,20 @@ static void do_nt_transact_create_pipe(connection_struct *conn,
  Internal fn to set security descriptors.
 ****************************************************************************/
 
-static NTSTATUS set_sd(files_struct *fsp, char *data, uint32 sd_len, uint32 security_info_sent)
+static NTSTATUS set_sd(files_struct *fsp, uint8 *data, uint32 sd_len,
+                      uint32 security_info_sent)
 {
-       prs_struct pd;
        SEC_DESC *psd = NULL;
-       TALLOC_CTX *mem_ctx;
        NTSTATUS status;
 
        if (sd_len == 0 || !lp_nt_acl_support(SNUM(fsp->conn))) {
                return NT_STATUS_OK;
        }
 
-       /*
-        * Init the parse struct we will unmarshall from.
-        */
-
-       if ((mem_ctx = talloc_init("set_sd")) == NULL) {
-               DEBUG(0,("set_sd: talloc_init failed.\n"));
-               return NT_STATUS_NO_MEMORY;
-       }
-
-       prs_init(&pd, 0, mem_ctx, UNMARSHALL);
-
-       /*
-        * Setup the prs_struct to point at the memory we just
-        * allocated.
-        */
-
-       prs_give_memory( &pd, data, sd_len, False);
+       status = unmarshall_sec_desc(talloc_tos(), data, sd_len, &psd);
 
-       /*
-        * Finally, unmarshall from the data buffer.
-        */
-
-       if(!sec_io_desc( "sd data", &psd, &pd, 1)) {
-               DEBUG(0,("set_sd: Error in unmarshalling security descriptor.\n"));
-               /*
-                * Return access denied for want of a better error message..
-                */
-               talloc_destroy(mem_ctx);
-               return NT_STATUS_NO_MEMORY;
+       if (!NT_STATUS_IS_OK(status)) {
+               return status;
        }
 
        if (psd->owner_sid==0) {
@@ -759,9 +776,16 @@ static NTSTATUS set_sd(files_struct *fsp, char *data, uint32 sd_len, uint32 secu
                security_info_sent &= ~DACL_SECURITY_INFORMATION;
        }
 
-       status = SMB_VFS_FSET_NT_ACL( fsp, fsp->fh->fd, security_info_sent, psd);
+       if (fsp->fh->fd != -1) {
+               status = SMB_VFS_FSET_NT_ACL(fsp, security_info_sent, psd);
+       }
+       else {
+               status = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name,
+                                           security_info_sent, psd);
+       }
+
+       TALLOC_FREE(psd);
 
-       talloc_destroy(mem_ctx);
        return status;
 }
 
@@ -834,6 +858,7 @@ static void call_nt_transact_create(connection_struct *conn,
        NTSTATUS status;
        size_t param_len;
        SMB_BIG_UINT allocation_size;
+       int oplock_request;
        uint8_t oplock_granted;
        TALLOC_CTX *ctx = talloc_tos();
 
@@ -851,10 +876,9 @@ static void call_nt_transact_create(connection_struct *conn,
                                ppparams, parameter_count,
                                ppdata, data_count);
                        return;
-               } else {
-                       reply_doserror(req, ERRDOS, ERRnoaccess);
-                       return;
                }
+               reply_doserror(req, ERRDOS, ERRnoaccess);
+               return;
        }
 
        /*
@@ -881,6 +905,12 @@ static void call_nt_transact_create(connection_struct *conn,
        allocation_size |= (((SMB_BIG_UINT)IVAL(params,16)) << 32);
 #endif
 
+       /*
+        * we need to remove ignored bits when they come directly from the client
+        * because we reuse some of them for internal stuff
+        */
+       create_options &= ~NTCREATEX_OPTIONS_MUST_IGNORE_MASK;
+
        /* Ensure the data_len is correct for the sd and ea values given. */
        if ((ea_len + sd_len > data_count)
            || (ea_len > data_count) || (sd_len > data_count)
@@ -941,28 +971,53 @@ static void call_nt_transact_create(connection_struct *conn,
                return;
        }
 
-       status = create_file(conn, req, root_dir_fid, fname, flags,
+       oplock_request = (flags & REQUEST_OPLOCK) ? EXCLUSIVE_OPLOCK : 0;
+       if (oplock_request) {
+               oplock_request |= (flags & REQUEST_BATCH_OPLOCK)
+                       ? BATCH_OPLOCK : 0;
+       }
+
+       status = create_file(conn, req, root_dir_fid, fname,
                             access_mask, share_access, create_disposition,
-                            create_options, file_attributes,
-                            allocation_size, sd, ea_list,
-                            &fsp, &info, &oplock_granted, &sbuf);
+                            create_options, file_attributes, oplock_request,
+                            allocation_size, sd, ea_list, &fsp, &info, &sbuf);
 
        if(!NT_STATUS_IS_OK(status)) {
                if (open_was_deferred(req->mid)) {
                        /* We have re-scheduled this call, no error. */
                        return;
                }
-               if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_COLLISION)) {
-                       reply_botherror(req, status, ERRDOS, ERRfilexists);
-               }
-               else {
-                       reply_nterror(req, status);
-               }
+               reply_openerror(req, status);
                return;
        }
 
+       /*
+        * If the caller set the extended oplock request bit
+        * and we granted one (by whatever means) - set the
+        * correct bit for extended oplock reply.
+        */
+
+       if (oplock_request &&
+           (lp_fake_oplocks(SNUM(conn))
+            || EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))) {
+
+               /*
+                * Exclusive oplock granted
+                */
+
+               if (flags & REQUEST_BATCH_OPLOCK) {
+                       oplock_granted = BATCH_OPLOCK_RETURN;
+               } else {
+                       oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
+               }
+       } else if (fsp->oplock_type == LEVEL_II_OPLOCK) {
+               oplock_granted = LEVEL_II_OPLOCK_RETURN;
+       } else {
+               oplock_granted = NO_OPLOCK_RETURN;
+       }
+
        file_len = sbuf.st_size;
-       fattr = dos_mode(conn,fname,&sbuf);
+       fattr = dos_mode(conn,fsp->fsp_name,&sbuf);
        if (fattr == 0) {
                fattr = FILE_ATTRIBUTE_NORMAL;
        }
@@ -1030,7 +1085,7 @@ static void call_nt_transact_create(connection_struct *conn,
                uint32 perms = 0;
                p += 25;
                if (fsp->is_directory
-                   || can_write_to_file(conn, fname, &sbuf)) {
+                   || can_write_to_file(conn, fsp->fsp_name, &sbuf)) {
                        perms = FILE_GENERIC_ALL;
                } else {
                        perms = FILE_GENERIC_READ|FILE_EXECUTE;
@@ -1038,10 +1093,10 @@ static void call_nt_transact_create(connection_struct *conn,
                SIVAL(p,0,perms);
        }
 
-       DEBUG(5,("call_nt_transact_create: open name = %s\n", fname));
+       DEBUG(5,("call_nt_transact_create: open name = %s\n", fsp->fsp_name));
 
        /* Send the required number of replies */
-       send_nt_replies(req, NT_STATUS_OK, params, param_len, *ppdata, 0);
+       send_nt_replies(conn, req, NT_STATUS_OK, params, param_len, *ppdata, 0);
 
        return;
 }
@@ -1051,7 +1106,7 @@ static void call_nt_transact_create(connection_struct *conn,
  conn POINTER CAN BE NULL HERE !
 ****************************************************************************/
 
-void reply_ntcancel(connection_struct *conn, struct smb_request *req)
+void reply_ntcancel(struct smb_request *req)
 {
        /*
         * Go through and cancel any pending change notifies.
@@ -1188,7 +1243,7 @@ static NTSTATUS copy_internals(TALLOC_CTX *ctx,
        close_file(fsp1,NORMAL_CLOSE);
 
        /* Ensure the modtime is set correctly on the destination file. */
-       fsp_set_pending_modtime(fsp2, get_mtimespec(&sbuf1));
+       set_close_write_time(fsp2, get_mtimespec(&sbuf1));
 
        status = close_file(fsp2,NORMAL_CLOSE);
 
@@ -1213,8 +1268,9 @@ static NTSTATUS copy_internals(TALLOC_CTX *ctx,
  Reply to a NT rename request.
 ****************************************************************************/
 
-void reply_ntrename(connection_struct *conn, struct smb_request *req)
+void reply_ntrename(struct smb_request *req)
 {
+       connection_struct *conn = req->conn;
        char *oldname = NULL;
        char *newname = NULL;
        char *p;
@@ -1307,7 +1363,7 @@ void reply_ntrename(connection_struct *conn, struct smb_request *req)
                case RENAME_FLAG_RENAME:
                        status = rename_internals(ctx, conn, req, oldname,
                                        newname, attrs, False, src_has_wcard,
-                                       dest_has_wcard);
+                                       dest_has_wcard, DELETE_ACCESS);
                        break;
                case RENAME_FLAG_HARD_LINK:
                        if (src_has_wcard || dest_has_wcard) {
@@ -1435,7 +1491,7 @@ static void call_nt_transact_notify_change(connection_struct *conn,
                 * here.
                 */
 
-               change_notify_reply(req->inbuf, max_param_count, fsp->notify);
+               change_notify_reply(fsp->conn, req->inbuf, max_param_count, fsp->notify);
 
                /*
                 * change_notify_reply() above has independently sent its
@@ -1448,7 +1504,9 @@ static void call_nt_transact_notify_change(connection_struct *conn,
         * No changes pending, queue the request
         */
 
-       status = change_notify_add_request(req->inbuf, max_param_count, filter,
+       status = change_notify_add_request(req,
+                       max_param_count,
+                       filter,
                        recursive, fsp);
        if (!NT_STATUS_IS_OK(status)) {
                reply_nterror(req, status);
@@ -1470,7 +1528,6 @@ static void call_nt_transact_rename(connection_struct *conn,
        char *params = *ppparams;
        char *new_name = NULL;
        files_struct *fsp = NULL;
-       bool replace_if_exists = False;
        bool dest_has_wcard = False;
        NTSTATUS status;
        TALLOC_CTX *ctx = talloc_tos();
@@ -1481,7 +1538,6 @@ static void call_nt_transact_rename(connection_struct *conn,
        }
 
        fsp = file_fsp(SVAL(params, 0));
-       replace_if_exists = (SVAL(params,2) & RENAME_REPLACE_IF_EXISTS) ? True : False;
        if (!check_fsp(conn, req, fsp, &current_user)) {
                return;
        }
@@ -1493,31 +1549,13 @@ static void call_nt_transact_rename(connection_struct *conn,
                return;
        }
 
-       status = rename_internals(ctx,
-                       conn,
-                       req,
-                       fsp->fsp_name,
-                       new_name,
-                       0,
-                       replace_if_exists,
-                       False,
-                       dest_has_wcard);
-
-       if (!NT_STATUS_IS_OK(status)) {
-               if (open_was_deferred(req->mid)) {
-                       /* We have re-scheduled this call. */
-                       return;
-               }
-               reply_nterror(req, status);
-               return;
-       }
-
        /*
-        * Rename was successful.
+        * W2K3 ignores this request as the RAW-RENAME test
+        * demonstrates, so we do.
         */
-       send_nt_replies(req, NT_STATUS_OK, NULL, 0, NULL, 0);
+       send_nt_replies(conn, req, NT_STATUS_OK, NULL, 0, NULL, 0);
 
-       DEBUG(3,("nt transact rename from = %s, to = %s succeeded.\n",
+       DEBUG(3,("nt transact rename from = %s, to = %s ignored!\n",
                 fsp->fsp_name, new_name));
 
        return;
@@ -1556,13 +1594,12 @@ static void call_nt_transact_query_security_desc(connection_struct *conn,
 {
        char *params = *ppparams;
        char *data = *ppdata;
-       prs_struct pd;
        SEC_DESC *psd = NULL;
        size_t sd_size;
        uint32 security_info_wanted;
-       TALLOC_CTX *mem_ctx;
        files_struct *fsp = NULL;
        NTSTATUS status;
+       DATA_BLOB blob;
 
         if(parameter_count < 8) {
                reply_doserror(req, ERRDOS, ERRbadfunc);
@@ -1586,40 +1623,37 @@ static void call_nt_transact_query_security_desc(connection_struct *conn,
                return;
        }
 
-       if ((mem_ctx = talloc_init("call_nt_transact_query_security_desc")) == NULL) {
-               DEBUG(0,("call_nt_transact_query_security_desc: talloc_init failed.\n"));
-               reply_doserror(req, ERRDOS, ERRnomem);
-               return;
-       }
-
        /*
         * Get the permissions to return.
         */
 
        if (!lp_nt_acl_support(SNUM(conn))) {
-               status = get_null_nt_acl(mem_ctx, &psd);
+               status = get_null_nt_acl(talloc_tos(), &psd);
        } else {
-               status = SMB_VFS_FGET_NT_ACL(fsp, fsp->fh->fd,
-                                            security_info_wanted, &psd);
+               if (fsp->fh->fd != -1) {
+                       status = SMB_VFS_FGET_NT_ACL(
+                               fsp, security_info_wanted, &psd);
+               }
+               else {
+                       status = SMB_VFS_GET_NT_ACL(
+                               conn, fsp->fsp_name, security_info_wanted, &psd);
+               }
        }
 
        if (!NT_STATUS_IS_OK(status)) {
-               talloc_destroy(mem_ctx);
                reply_nterror(req, status);
                return;
        }
 
-       sd_size = sec_desc_size(psd);
+       sd_size = ndr_size_security_descriptor(psd, 0);
 
        DEBUG(3,("call_nt_transact_query_security_desc: sd_size = %lu.\n",(unsigned long)sd_size));
 
        SIVAL(params,0,(uint32)sd_size);
 
-       if(max_data_count < sd_size) {
-
-               send_nt_replies(req, NT_STATUS_BUFFER_TOO_SMALL,
+       if (max_data_count < sd_size) {
+               send_nt_replies(conn, req, NT_STATUS_BUFFER_TOO_SMALL,
                                params, 4, *ppdata, 0);
-               talloc_destroy(mem_ctx);
                return;
        }
 
@@ -1629,46 +1663,23 @@ static void call_nt_transact_query_security_desc(connection_struct *conn,
 
        data = nttrans_realloc(ppdata, sd_size);
        if(data == NULL) {
-               talloc_destroy(mem_ctx);
                reply_doserror(req, ERRDOS, ERRnomem);
                return;
        }
 
-       /*
-        * Init the parse struct we will marshall into.
-        */
-
-       prs_init(&pd, 0, mem_ctx, MARSHALL);
-
-       /*
-        * Setup the prs_struct to point at the memory we just
-        * allocated.
-        */
-
-       prs_give_memory( &pd, data, (uint32)sd_size, False);
-
-       /*
-        * Finally, linearize into the outgoing buffer.
-        */
+       status = marshall_sec_desc(talloc_tos(), psd,
+                                  &blob.data, &blob.length);
 
-       if(!sec_io_desc( "sd data", &psd, &pd, 1)) {
-               DEBUG(0,("call_nt_transact_query_security_desc: Error in marshalling \
-security descriptor.\n"));
-               /*
-                * Return access denied for want of a better error message..
-                */
-               talloc_destroy(mem_ctx);
-               reply_unixerror(req, ERRDOS, ERRnoaccess);
+       if (!NT_STATUS_IS_OK(status)) {
+               reply_nterror(req, status);
                return;
        }
 
-       /*
-        * Now we can delete the security descriptor.
-        */
+       SMB_ASSERT(sd_size == blob.length);
+       memcpy(data, blob.data, sd_size);
 
-       talloc_destroy(mem_ctx);
+       send_nt_replies(conn, req, NT_STATUS_OK, params, 4, data, (int)sd_size);
 
-       send_nt_replies(req, NT_STATUS_OK, params, 4, data, (int)sd_size);
        return;
 }
 
@@ -1690,7 +1701,7 @@ static void call_nt_transact_set_security_desc(connection_struct *conn,
        char *data = *ppdata;
        files_struct *fsp = NULL;
        uint32 security_info_sent = 0;
-       NTSTATUS nt_status;
+       NTSTATUS status;
 
        if(parameter_count < 8) {
                reply_doserror(req, ERRDOS, ERRbadfunc);
@@ -1716,14 +1727,15 @@ static void call_nt_transact_set_security_desc(connection_struct *conn,
                return;
        }
 
-       if (!NT_STATUS_IS_OK(nt_status = set_sd( fsp, data, data_count, security_info_sent))) {
-               reply_nterror(req, nt_status);
+       status = set_sd(fsp, (uint8 *)data, data_count, security_info_sent);
+
+       if (!NT_STATUS_IS_OK(status)) {
+               reply_nterror(req, status);
                return;
        }
 
   done:
-
-       send_nt_replies(req, NT_STATUS_OK, NULL, 0, NULL, 0);
+       send_nt_replies(conn, req, NT_STATUS_OK, NULL, 0, NULL, 0);
        return;
 }
 
@@ -1772,7 +1784,7 @@ static void call_nt_transact_ioctl(connection_struct *conn,
                   so we can know if we need to pre-allocate or not */
 
                DEBUG(10,("FSCTL_SET_SPARSE: called on FID[0x%04X](but not implemented)\n", fidnum));
-               send_nt_replies(req, NT_STATUS_OK, NULL, 0, NULL, 0);
+               send_nt_replies(conn, req, NT_STATUS_OK, NULL, 0, NULL, 0);
                return;
 
        case FSCTL_CREATE_OR_GET_OBJECT_ID:
@@ -1798,7 +1810,7 @@ static void call_nt_transact_ioctl(connection_struct *conn,
                push_file_id_16(pdata, &fsp->file_id);
                memcpy(pdata+16,create_volume_objectid(conn,objid),16);
                push_file_id_16(pdata+32, &fsp->file_id);
-               send_nt_replies(req, NT_STATUS_OK, NULL, 0,
+               send_nt_replies(conn, req, NT_STATUS_OK, NULL, 0,
                                pdata, data_count);
                return;
        }
@@ -1943,7 +1955,7 @@ static void call_nt_transact_ioctl(connection_struct *conn,
 
                talloc_destroy(shadow_data->mem_ctx);
 
-               send_nt_replies(req, NT_STATUS_OK, NULL, 0,
+               send_nt_replies(conn, req, NT_STATUS_OK, NULL, 0,
                                pdata, data_count);
 
                return;
@@ -1971,11 +1983,12 @@ static void call_nt_transact_ioctl(connection_struct *conn,
                /*unknown = IVAL(pdata,0);*/
 
                sid_parse(pdata+4,sid_len,&sid);
-               DEBUGADD(10,("for SID: %s\n",sid_string_static(&sid)));
+               DEBUGADD(10, ("for SID: %s\n", sid_string_dbg(&sid)));
 
                if (!sid_to_uid(&sid, &uid)) {
                        DEBUG(0,("sid_to_uid: failed, sid[%s] sid_len[%lu]\n",
-                               sid_string_static(&sid),(unsigned long)sid_len));
+                                sid_string_dbg(&sid),
+                                (unsigned long)sid_len));
                        uid = (-1);
                }
 
@@ -1998,7 +2011,7 @@ static void call_nt_transact_ioctl(connection_struct *conn,
                 */
 
                /* this works for now... */
-               send_nt_replies(req, NT_STATUS_OK, NULL, 0, NULL, 0);
+               send_nt_replies(conn, req, NT_STATUS_OK, NULL, 0, NULL, 0);
                return;
        }
        default:
@@ -2152,7 +2165,8 @@ static void call_nt_transact_get_user_quota(connection_struct *conn,
                        for (;((tmp_list!=NULL)&&((qt_len +40+SID_MAX_SIZE)<max_data_count));
                                tmp_list=tmp_list->next,entry+=entry_len,qt_len+=entry_len) {
 
-                               sid_len = sid_size(&tmp_list->quotas->sid);
+                               sid_len = ndr_size_dom_sid(
+                                       &tmp_list->quotas->sid, 0);
                                entry_len = 40 + sid_len;
 
                                /* nextoffset entry 4 bytes */
@@ -2283,7 +2297,7 @@ static void call_nt_transact_get_user_quota(connection_struct *conn,
                        break;
        }
 
-       send_nt_replies(req, nt_status, params, param_len,
+       send_nt_replies(conn, req, nt_status, params, param_len,
                        pdata, data_len);
 }
 
@@ -2404,7 +2418,7 @@ static void call_nt_transact_set_user_quota(connection_struct *conn,
 #endif /* LARGE_SMB_OFF_T */
 
        sid_parse(pdata+40,sid_len,&sid);
-       DEBUGADD(8,("SID: %s\n",sid_string_static(&sid)));
+       DEBUGADD(8,("SID: %s\n", sid_string_dbg(&sid)));
 
        /* 44 unknown bytes left... */
 
@@ -2413,7 +2427,7 @@ static void call_nt_transact_set_user_quota(connection_struct *conn,
                return;
        }
 
-       send_nt_replies(req, NT_STATUS_OK, params, param_len,
+       send_nt_replies(conn, req, NT_STATUS_OK, params, param_len,
                        pdata, data_len);
 }
 #endif /* HAVE_SYS_QUOTAS */
@@ -2550,16 +2564,18 @@ static void handle_nttrans(connection_struct *conn,
  Reply to a SMBNTtrans.
 ****************************************************************************/
 
-void reply_nttrans(connection_struct *conn, struct smb_request *req)
+void reply_nttrans(struct smb_request *req)
 {
-       uint32 pscnt;
-       uint32 psoff;
-       uint32 dscnt;
-       uint32 dsoff;
+       connection_struct *conn = req->conn;
+       uint32_t pscnt;
+       uint32_t psoff;
+       uint32_t dscnt;
+       uint32_t dsoff;
        uint16 function_code;
        NTSTATUS result;
        struct trans_state *state;
-       int size;
+       uint32_t size;
+       uint32_t av_size;
 
        START_PROFILE(SMBnttrans);
 
@@ -2570,6 +2586,7 @@ void reply_nttrans(connection_struct *conn, struct smb_request *req)
        }
 
        size = smb_len(req->inbuf) + 4;
+       av_size = smb_len(req->inbuf);
        pscnt = IVAL(req->inbuf,smb_nt_ParameterCount);
        psoff = IVAL(req->inbuf,smb_nt_ParameterOffset);
        dscnt = IVAL(req->inbuf,smb_nt_DataCount);
@@ -2645,12 +2662,17 @@ void reply_nttrans(connection_struct *conn, struct smb_request *req)
                        END_PROFILE(SMBnttrans);
                        return;
                }
-               if ((dsoff+dscnt < dsoff) || (dsoff+dscnt < dscnt))
+
+               if (dscnt > state->total_data ||
+                               dsoff+dscnt < dsoff) {
                        goto bad_param;
-               if ((smb_base(req->inbuf)+dsoff+dscnt
-                    > (char *)req->inbuf + size) ||
-                   (smb_base(req->inbuf)+dsoff+dscnt < smb_base(req->inbuf)))
+               }
+
+               if (dsoff > av_size ||
+                               dscnt > av_size ||
+                               dsoff+dscnt > av_size) {
                        goto bad_param;
+               }
 
                memcpy(state->data,smb_base(req->inbuf)+dsoff,dscnt);
        }
@@ -2667,12 +2689,17 @@ void reply_nttrans(connection_struct *conn, struct smb_request *req)
                        END_PROFILE(SMBnttrans);
                        return;
                }
-               if ((psoff+pscnt < psoff) || (psoff+pscnt < pscnt))
+
+               if (pscnt > state->total_param ||
+                               psoff+pscnt < psoff) {
                        goto bad_param;
-               if ((smb_base(req->inbuf)+psoff+pscnt
-                    > (char *)req->inbuf + size) ||
-                   (smb_base(req->inbuf)+psoff+pscnt < smb_base(req->inbuf)))
+               }
+
+               if (psoff > av_size ||
+                               pscnt > av_size ||
+                               psoff+pscnt > av_size) {
                        goto bad_param;
+               }
 
                memcpy(state->param,smb_base(req->inbuf)+psoff,pscnt);
        }
@@ -2741,12 +2768,13 @@ void reply_nttrans(connection_struct *conn, struct smb_request *req)
  Reply to a SMBnttranss
  ****************************************************************************/
 
-void reply_nttranss(connection_struct *conn, struct smb_request *req)
+void reply_nttranss(struct smb_request *req)
 {
-       unsigned int pcnt,poff,dcnt,doff,pdisp,ddisp;
+       connection_struct *conn = req->conn;
+       uint32_t pcnt,poff,dcnt,doff,pdisp,ddisp;
        struct trans_state *state;
-
-       int size;
+       uint32_t av_size;
+       uint32_t size;
 
        START_PROFILE(SMBnttranss);
 
@@ -2783,6 +2811,7 @@ void reply_nttranss(connection_struct *conn, struct smb_request *req)
        }
 
        size = smb_len(req->inbuf) + 4;
+       av_size = smb_len(req->inbuf);
 
        pcnt = IVAL(req->inbuf,smb_nts_ParameterCount);
        poff = IVAL(req->inbuf, smb_nts_ParameterOffset);
@@ -2800,38 +2829,38 @@ void reply_nttranss(connection_struct *conn, struct smb_request *req)
                goto bad_param;
 
        if (pcnt) {
-               if (pdisp+pcnt > state->total_param)
+               if (pdisp > state->total_param ||
+                               pcnt > state->total_param ||
+                               pdisp+pcnt > state->total_param ||
+                               pdisp+pcnt < pdisp) {
                        goto bad_param;
-               if ((pdisp+pcnt < pdisp) || (pdisp+pcnt < pcnt))
-                       goto bad_param;
-               if (pdisp > state->total_param)
-                       goto bad_param;
-               if ((smb_base(req->inbuf) + poff + pcnt
-                    > (char *)req->inbuf + size) ||
-                   (smb_base(req->inbuf) + poff + pcnt
-                    < smb_base(req->inbuf)))
-                       goto bad_param;
-               if (state->param + pdisp < state->param)
+               }
+
+               if (poff > av_size ||
+                               pcnt > av_size ||
+                               poff+pcnt > av_size ||
+                               poff+pcnt < poff) {
                        goto bad_param;
+               }
 
                memcpy(state->param+pdisp, smb_base(req->inbuf)+poff,
                       pcnt);
        }
 
        if (dcnt) {
-               if (ddisp+dcnt > state->total_data)
-                       goto bad_param;
-               if ((ddisp+dcnt < ddisp) || (ddisp+dcnt < dcnt))
-                       goto bad_param;
-               if (ddisp > state->total_data)
+               if (ddisp > state->total_data ||
+                               dcnt > state->total_data ||
+                               ddisp+dcnt > state->total_data ||
+                               ddisp+dcnt < ddisp) {
                        goto bad_param;
-               if ((smb_base(req->inbuf) + doff + dcnt
-                    > (char *)req->inbuf + size) ||
-                   (smb_base(req->inbuf) + doff + dcnt
-                    < smb_base(req->inbuf)))
-                       goto bad_param;
-               if (state->data + ddisp < state->data)
+               }
+
+               if (ddisp > av_size ||
+                               dcnt > av_size ||
+                               ddisp+dcnt > av_size ||
+                               ddisp+dcnt < ddisp) {
                        goto bad_param;
+               }
 
                memcpy(state->data+ddisp, smb_base(req->inbuf)+doff,
                       dcnt);