r14504: make trans and trans2 able to use async ntvfs backends

tridge: can you review this please

metze
(This used to be commit f2e9b2c3a2304320ac090549815b174887b3e466)

1 files changed, 534 insertions, 408 deletions

diff --git a/source4/smb_server/smb/trans2.c b/source4/smb_server/smb/trans2.c
index faf204607e..e350d6d9e3 100644
--- a/source4/smb_server/smb/trans2.c
+++ b/source4/smb_server/smb/trans2.c
@@ -28,6 +28,18 @@
 #include "ntvfs/ntvfs.h"
 #include "libcli/raw/libcliraw.h"
 
+/*
+  hold the state of a nttrans op while in progress. Needed to allow for async backend
+  functions.
+*/
+struct trans_op {
+	struct smbsrv_request *req;
+	struct smb_trans2 *trans;
+	uint8_t command;
+	NTSTATUS (*send_fn)(struct trans_op *);
+	void *op_info;
+};
+
 #define CHECK_MIN_BLOB_SIZE(blob, size) do { \
 	if ((blob)->length < (size)) { \
 		return NT_STATUS_INFO_LENGTH_MISMATCH; \
@@ -36,25 +48,23 @@
 /* grow the data allocation size of a trans2 reply - this guarantees
    that requests to grow the data size later will not change the
    pointer */
-static BOOL trans2_grow_data_allocation(struct smbsrv_request *req, 
-					struct smb_trans2 *trans,
+static BOOL trans2_grow_data_allocation(struct smb_trans2 *trans,
 					uint32_t new_size)
 {
 	if (new_size <= trans->out.data.length) {
 		return True;
 	}
-	trans->out.data.data = talloc_realloc(req, trans->out.data.data, 
+	trans->out.data.data = talloc_realloc(trans, trans->out.data.data, 
 					      uint8_t, new_size);
 	return (trans->out.data.data != NULL);
 }
 
 
 /* grow the data size of a trans2 reply */
-static BOOL trans2_grow_data(struct smbsrv_request *req, 
-			     struct smb_trans2 *trans,
+static BOOL trans2_grow_data(struct smb_trans2 *trans,
 			     uint32_t new_size)
 {
-	if (!trans2_grow_data_allocation(req, trans, new_size)) {
+	if (!trans2_grow_data_allocation(trans, new_size)) {
 		return False;
 	}
 	trans->out.data.length = new_size;
@@ -62,12 +72,11 @@ static BOOL trans2_grow_data(struct smbsrv_request *req,
 }
 
 /* grow the data, zero filling any new bytes */
-static BOOL trans2_grow_data_fill(struct smbsrv_request *req, 
-				  struct smb_trans2 *trans,
+static BOOL trans2_grow_data_fill(struct smb_trans2 *trans,
 				  uint32_t new_size)
 {
 	uint32_t old_size = trans->out.data.length;
-	if (!trans2_grow_data(req, trans, new_size)) {
+	if (!trans2_grow_data(trans, new_size)) {
 		return False;
 	}
 	if (new_size > old_size) {
@@ -78,17 +87,16 @@ static BOOL trans2_grow_data_fill(struct smbsrv_request *req,
 
 
 /* setup a trans2 reply, given the data and params sizes */
-static void trans2_setup_reply(struct smbsrv_request *req, 
-			       struct smb_trans2 *trans,
+static void trans2_setup_reply(struct smb_trans2 *trans,
 			       uint16_t param_size, uint16_t data_size,
 			       uint16_t setup_count)
 {
 	trans->out.setup_count = setup_count;
 	if (setup_count != 0) {
-		trans->out.setup = talloc_zero_array(req, uint16_t, setup_count);
+		trans->out.setup = talloc_zero_array(trans, uint16_t, setup_count);
 	}
-	trans->out.params = data_blob_talloc(req, NULL, param_size);
-	trans->out.data = data_blob_talloc(req, NULL, data_size);
+	trans->out.params = data_blob_talloc(trans, NULL, param_size);
+	trans->out.data = data_blob_talloc(trans, NULL, data_size);
 }
 
 
@@ -199,9 +207,9 @@ static void trans2_append_data_string(struct smbsrv_request *req,
 	const int max_bytes_per_char = 3;
 
 	offset = trans->out.data.length;
-	trans2_grow_data(req, trans, offset + (2+strlen_m(str->s))*max_bytes_per_char);
+	trans2_grow_data(trans, offset + (2+strlen_m(str->s))*max_bytes_per_char);
 	ret = trans2_push_data_string(req, trans, len_offset, offset, str, -1, flags);
-	trans2_grow_data(req, trans, offset + ret);
+	trans2_grow_data(trans, offset + ret);
 }
 
 /*
@@ -212,191 +220,129 @@ static void trans2_align_data(struct smbsrv_request *req, struct smb_trans2 *tra
 	if ((trans->out.data.length & 1) == 0) {
 		return;
 	}
-	trans2_grow_data(req, trans, trans->out.data.length+1);
+	trans2_grow_data(trans, trans->out.data.length+1);
 	SCVAL(trans->out.data.data, trans->out.data.length-1, 0);
 }
 
 
 /*
-  trans2 qfsinfo implementation
+  trans2 qfsinfo implementation send
 */
-static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_qfsinfo_send(struct trans_op *op)
 {
-	union smb_fsinfo fsinfo;
+	struct smbsrv_request *req = op->req;
+	struct smb_trans2 *trans = op->trans;
+	union smb_fsinfo *fsinfo;
 	NTSTATUS status;
-	uint16_t level;
 	uint_t i;
 	DATA_BLOB guid_blob;
 
-	/* make sure we got enough parameters */
-	if (trans->in.params.length != 2) {
-		return NT_STATUS_FOOBAR;
+	if (!NT_STATUS_IS_OK(req->async_states->status)) {
+		return req->async_states->status;
 	}
 
-	level = SVAL(trans->in.params.data, 0);
+	fsinfo = talloc_get_type(op->op_info, union smb_fsinfo);
 
-	switch (level) {
+	switch (fsinfo->generic.level) {
 	case SMB_QFS_ALLOCATION:
-		fsinfo.allocation.level = RAW_QFS_ALLOCATION;
-
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-
-		trans2_setup_reply(req, trans, 0, 18, 0);
+		trans2_setup_reply(trans, 0, 18, 0);
 
-		SIVAL(trans->out.data.data,  0, fsinfo.allocation.out.fs_id);
-		SIVAL(trans->out.data.data,  4, fsinfo.allocation.out.sectors_per_unit);
-		SIVAL(trans->out.data.data,  8, fsinfo.allocation.out.total_alloc_units);
-		SIVAL(trans->out.data.data, 12, fsinfo.allocation.out.avail_alloc_units);
-		SSVAL(trans->out.data.data, 16, fsinfo.allocation.out.bytes_per_sector);
+		SIVAL(trans->out.data.data,  0, fsinfo->allocation.out.fs_id);
+		SIVAL(trans->out.data.data,  4, fsinfo->allocation.out.sectors_per_unit);
+		SIVAL(trans->out.data.data,  8, fsinfo->allocation.out.total_alloc_units);
+		SIVAL(trans->out.data.data, 12, fsinfo->allocation.out.avail_alloc_units);
+		SSVAL(trans->out.data.data, 16, fsinfo->allocation.out.bytes_per_sector);
 
 		return NT_STATUS_OK;
 
 	case SMB_QFS_VOLUME:
-		fsinfo.volume.level = RAW_QFS_VOLUME;
+		trans2_setup_reply(trans, 0, 5, 0);
 
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-
-		trans2_setup_reply(req, trans, 0, 5, 0);
-
-		SIVAL(trans->out.data.data,       0, fsinfo.volume.out.serial_number);
+		SIVAL(trans->out.data.data,       0, fsinfo->volume.out.serial_number);
 		/* w2k3 implements this incorrectly for unicode - it
 		 * leaves the last byte off the string */
 		trans2_append_data_string(req, trans, 
-					  &fsinfo.volume.out.volume_name, 
+					  &fsinfo->volume.out.volume_name, 
 					  4, STR_LEN8BIT|STR_NOALIGN);
 
 		return NT_STATUS_OK;
 
 	case SMB_QFS_VOLUME_INFO:
 	case SMB_QFS_VOLUME_INFORMATION:
-		fsinfo.volume_info.level = RAW_QFS_VOLUME_INFO;
-
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-
-		trans2_setup_reply(req, trans, 0, 18, 0);
+		trans2_setup_reply(trans, 0, 18, 0);
 
-		push_nttime(trans->out.data.data, 0, fsinfo.volume_info.out.create_time);
-		SIVAL(trans->out.data.data,       8, fsinfo.volume_info.out.serial_number);
+		push_nttime(trans->out.data.data, 0, fsinfo->volume_info.out.create_time);
+		SIVAL(trans->out.data.data,       8, fsinfo->volume_info.out.serial_number);
 		SSVAL(trans->out.data.data,      16, 0); /* padding */
 		trans2_append_data_string(req, trans, 
-					  &fsinfo.volume_info.out.volume_name, 
+					  &fsinfo->volume_info.out.volume_name, 
 					  12, STR_UNICODE);
 
 		return NT_STATUS_OK;
 
 	case SMB_QFS_SIZE_INFO:
 	case SMB_QFS_SIZE_INFORMATION:
-		fsinfo.size_info.level = RAW_QFS_SIZE_INFO;
+		trans2_setup_reply(trans, 0, 24, 0);
 
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-
-		trans2_setup_reply(req, trans, 0, 24, 0);
-
-		SBVAL(trans->out.data.data,  0, fsinfo.size_info.out.total_alloc_units);
-		SBVAL(trans->out.data.data,  8, fsinfo.size_info.out.avail_alloc_units);
-		SIVAL(trans->out.data.data, 16, fsinfo.size_info.out.sectors_per_unit);
-		SIVAL(trans->out.data.data, 20, fsinfo.size_info.out.bytes_per_sector);
+		SBVAL(trans->out.data.data,  0, fsinfo->size_info.out.total_alloc_units);
+		SBVAL(trans->out.data.data,  8, fsinfo->size_info.out.avail_alloc_units);
+		SIVAL(trans->out.data.data, 16, fsinfo->size_info.out.sectors_per_unit);
+		SIVAL(trans->out.data.data, 20, fsinfo->size_info.out.bytes_per_sector);
 
 		return NT_STATUS_OK;
 
 	case SMB_QFS_DEVICE_INFO:
 	case SMB_QFS_DEVICE_INFORMATION:
-		fsinfo.device_info.level = RAW_QFS_DEVICE_INFO;
-
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-		trans2_setup_reply(req, trans, 0, 8, 0);
-		SIVAL(trans->out.data.data,      0, fsinfo.device_info.out.device_type);
-		SIVAL(trans->out.data.data,      4, fsinfo.device_info.out.characteristics);
+		trans2_setup_reply(trans, 0, 8, 0);
+		SIVAL(trans->out.data.data,      0, fsinfo->device_info.out.device_type);
+		SIVAL(trans->out.data.data,      4, fsinfo->device_info.out.characteristics);
 		return NT_STATUS_OK;
 
 
 	case SMB_QFS_ATTRIBUTE_INFO:
 	case SMB_QFS_ATTRIBUTE_INFORMATION:
-		fsinfo.attribute_info.level = RAW_QFS_ATTRIBUTE_INFO;
+		trans2_setup_reply(trans, 0, 12, 0);
 
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-
-		trans2_setup_reply(req, trans, 0, 12, 0);
-
-		SIVAL(trans->out.data.data, 0, fsinfo.attribute_info.out.fs_attr);
-		SIVAL(trans->out.data.data, 4, fsinfo.attribute_info.out.max_file_component_length);
+		SIVAL(trans->out.data.data, 0, fsinfo->attribute_info.out.fs_attr);
+		SIVAL(trans->out.data.data, 4, fsinfo->attribute_info.out.max_file_component_length);
 		/* this must not be null terminated or win98 gets
 		   confused!  also note that w2k3 returns this as
 		   unicode even when ascii is negotiated */
 		trans2_append_data_string(req, trans, 
-					  &fsinfo.attribute_info.out.fs_type,
+					  &fsinfo->attribute_info.out.fs_type,
 					  8, STR_UNICODE);
 		return NT_STATUS_OK;
 
 
 	case SMB_QFS_QUOTA_INFORMATION:
-		fsinfo.quota_information.level = RAW_QFS_QUOTA_INFORMATION;
-
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-
-		trans2_setup_reply(req, trans, 0, 48, 0);
+		trans2_setup_reply(trans, 0, 48, 0);
 
-		SBVAL(trans->out.data.data,   0, fsinfo.quota_information.out.unknown[0]);
-		SBVAL(trans->out.data.data,   8, fsinfo.quota_information.out.unknown[1]);
-		SBVAL(trans->out.data.data,  16, fsinfo.quota_information.out.unknown[2]);
-		SBVAL(trans->out.data.data,  24, fsinfo.quota_information.out.quota_soft);
-		SBVAL(trans->out.data.data,  32, fsinfo.quota_information.out.quota_hard);
-		SBVAL(trans->out.data.data,  40, fsinfo.quota_information.out.quota_flags);
+		SBVAL(trans->out.data.data,   0, fsinfo->quota_information.out.unknown[0]);
+		SBVAL(trans->out.data.data,   8, fsinfo->quota_information.out.unknown[1]);
+		SBVAL(trans->out.data.data,  16, fsinfo->quota_information.out.unknown[2]);
+		SBVAL(trans->out.data.data,  24, fsinfo->quota_information.out.quota_soft);
+		SBVAL(trans->out.data.data,  32, fsinfo->quota_information.out.quota_hard);
+		SBVAL(trans->out.data.data,  40, fsinfo->quota_information.out.quota_flags);
 
 		return NT_STATUS_OK;
 
 
 	case SMB_QFS_FULL_SIZE_INFORMATION:
-		fsinfo.full_size_information.level = RAW_QFS_FULL_SIZE_INFORMATION;
+		trans2_setup_reply(trans, 0, 32, 0);
 
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-
-		trans2_setup_reply(req, trans, 0, 32, 0);
-
-		SBVAL(trans->out.data.data,  0, fsinfo.full_size_information.out.total_alloc_units);
-		SBVAL(trans->out.data.data,  8, fsinfo.full_size_information.out.call_avail_alloc_units);
-		SBVAL(trans->out.data.data, 16, fsinfo.full_size_information.out.actual_avail_alloc_units);
-		SIVAL(trans->out.data.data, 24, fsinfo.full_size_information.out.sectors_per_unit);
-		SIVAL(trans->out.data.data, 28, fsinfo.full_size_information.out.bytes_per_sector);
+		SBVAL(trans->out.data.data,  0, fsinfo->full_size_information.out.total_alloc_units);
+		SBVAL(trans->out.data.data,  8, fsinfo->full_size_information.out.call_avail_alloc_units);
+		SBVAL(trans->out.data.data, 16, fsinfo->full_size_information.out.actual_avail_alloc_units);
+		SIVAL(trans->out.data.data, 24, fsinfo->full_size_information.out.sectors_per_unit);
+		SIVAL(trans->out.data.data, 28, fsinfo->full_size_information.out.bytes_per_sector);
 
 		return NT_STATUS_OK;
 
 	case SMB_QFS_OBJECTID_INFORMATION:
-		fsinfo.objectid_information.level = RAW_QFS_OBJECTID_INFORMATION;
-
-		status = ntvfs_fsinfo(req, &fsinfo);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-
-		trans2_setup_reply(req, trans, 0, 64, 0);
+		trans2_setup_reply(trans, 0, 64, 0);
 
 		status = ndr_push_struct_blob(&guid_blob, req, 
-					      &fsinfo.objectid_information.out.guid,
+					      &fsinfo->objectid_information.out.guid,
 					      (ndr_push_flags_fn_t)ndr_push_GUID);
 		if (!NT_STATUS_IS_OK(status)) {
 			return status;
@@ -405,7 +351,7 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr
 		memcpy(trans->out.data.data, guid_blob.data, guid_blob.length);
 
 		for (i=0;i<6;i++) {
-			SBVAL(trans->out.data.data, 16 + 8*i, fsinfo.objectid_information.out.unknown[i]);
+			SBVAL(trans->out.data.data, 16 + 8*i, fsinfo->objectid_information.out.unknown[i]);
 		}
 		return NT_STATUS_OK;
 	}
@@ -413,12 +359,113 @@ static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct smb_trans2 *tr
 	return NT_STATUS_INVALID_LEVEL;
 }
 
+/*
+  trans2 qfsinfo implementation
+*/
+static NTSTATUS trans2_qfsinfo(struct smbsrv_request *req, struct trans_op *op)
+{
+	struct smb_trans2 *trans = op->trans;
+	union smb_fsinfo *fsinfo;
+	uint16_t level;
+
+	/* make sure we got enough parameters */
+	if (trans->in.params.length != 2) {
+		return NT_STATUS_FOOBAR;
+	}
+
+	fsinfo = talloc(op, union smb_fsinfo);
+	NT_STATUS_HAVE_NO_MEMORY(fsinfo);
+
+	op->op_info = fsinfo;
+	op->send_fn = trans2_qfsinfo_send;
+
+	level = SVAL(trans->in.params.data, 0);
+
+	switch (level) {
+	case SMB_QFS_ALLOCATION:
+		fsinfo->allocation.level = RAW_QFS_ALLOCATION;
+		return ntvfs_fsinfo(req, fsinfo);
+
+	case SMB_QFS_VOLUME:
+		fsinfo->volume.level = RAW_QFS_VOLUME;
+		return ntvfs_fsinfo(req, fsinfo);
+
+	case SMB_QFS_VOLUME_INFO:
+	case SMB_QFS_VOLUME_INFORMATION:
+		fsinfo->volume_info.level = RAW_QFS_VOLUME_INFO;
+		return ntvfs_fsinfo(req, fsinfo);
+
+	case SMB_QFS_SIZE_INFO:
+	case SMB_QFS_SIZE_INFORMATION:
+		fsinfo->size_info.level = RAW_QFS_SIZE_INFO;
+		return ntvfs_fsinfo(req, fsinfo);
+
+	case SMB_QFS_DEVICE_INFO:
+	case SMB_QFS_DEVICE_INFORMATION:
+		fsinfo->device_info.level = RAW_QFS_DEVICE_INFO;
+		return ntvfs_fsinfo(req, fsinfo);
+
+	case SMB_QFS_ATTRIBUTE_INFO:
+	case SMB_QFS_ATTRIBUTE_INFORMATION:
+		fsinfo->attribute_info.level = RAW_QFS_ATTRIBUTE_INFO;
+		return ntvfs_fsinfo(req, fsinfo);
+
+	case SMB_QFS_QUOTA_INFORMATION:
+		fsinfo->quota_information.level = RAW_QFS_QUOTA_INFORMATION;
+		return ntvfs_fsinfo(req, fsinfo);
+
+	case SMB_QFS_FULL_SIZE_INFORMATION:
+		fsinfo->full_size_information.level = RAW_QFS_FULL_SIZE_INFORMATION;
+		return ntvfs_fsinfo(req, fsinfo);
+
+	case SMB_QFS_OBJECTID_INFORMATION:
+		fsinfo->objectid_information.level = RAW_QFS_OBJECTID_INFORMATION;
+		return ntvfs_fsinfo(req, fsinfo);
+	}
+
+	return NT_STATUS_INVALID_LEVEL;
+}
+
+
+/*
+  trans2 open implementation send
+*/
+static NTSTATUS trans2_open_send(struct trans_op *op)
+{
+	struct smbsrv_request *req = op->req;
+	struct smb_trans2 *trans = op->trans;
+	union smb_open *io;
+
+	if (!NT_STATUS_IS_OK(req->async_states->status)) {
+		return req->async_states->status;
+	}
+
+	io = talloc_get_type(op->op_info, union smb_open);
+
+	trans2_setup_reply(trans, 30, 0, 0);
+
+	SSVAL(trans->out.params.data, VWV(0), io->t2open.out.file.fnum);
+	SSVAL(trans->out.params.data, VWV(1), io->t2open.out.attrib);
+	srv_push_dos_date3(req->smb_conn, trans->out.params.data, 
+			   VWV(2), io->t2open.out.write_time);
+	SIVAL(trans->out.params.data, VWV(4), io->t2open.out.size);
+	SSVAL(trans->out.params.data, VWV(6), io->t2open.out.access);
+	SSVAL(trans->out.params.data, VWV(7), io->t2open.out.ftype);
+	SSVAL(trans->out.params.data, VWV(8), io->t2open.out.devstate);
+	SSVAL(trans->out.params.data, VWV(9), io->t2open.out.action);
+	SIVAL(trans->out.params.data, VWV(10), 0); /* reserved */
+	SSVAL(trans->out.params.data, VWV(12), 0); /* EaErrorOffset */
+	SIVAL(trans->out.params.data, VWV(13), 0); /* EaLength */
+
+	return NT_STATUS_OK;
+}
 
 /*
   trans2 open implementation
 */
-static NTSTATUS trans2_open(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_open(struct smbsrv_request *req, struct trans_op *op)
 {
+	struct smb_trans2 *trans = op->trans;
 	union smb_open *io;
 	NTSTATUS status;
 
@@ -427,10 +474,8 @@ static NTSTATUS trans2_open(struct smbsrv_request *req, struct smb_trans2 *trans
 		return NT_STATUS_FOOBAR;
 	}
 
-	io = talloc(req, union smb_open);
-	if (io == NULL) {
-		return NT_STATUS_NO_MEMORY;
-	}
+	io = talloc(op, union smb_open);
+	NT_STATUS_HAVE_NO_MEMORY(io);
 
 	io->t2open.level           = RAW_OPEN_T2OPEN;
 	io->t2open.in.flags        = SVAL(trans->in.params.data, VWV(0));
@@ -448,39 +493,40 @@ static NTSTATUS trans2_open(struct smbsrv_request *req, struct smb_trans2 *trans
 	trans2_pull_blob_string(req, &trans->in.params, 28, &io->t2open.in.fname, 0);
 
 	status = ea_pull_list(&trans->in.data, io, &io->t2open.in.num_eas, &io->t2open.in.eas);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
+	NT_STATUS_NOT_OK_RETURN(status);
 
-	status = ntvfs_open(req, io);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+	op->op_info = io;
+	op->send_fn = trans2_open_send;
+
+	return ntvfs_open(req, io);
+}
+
+
+/*
+  trans2 simple send
+*/
+static NTSTATUS trans2_simple_send(struct trans_op *op)
+{
+	struct smbsrv_request *req = op->req;
+	struct smb_trans2 *trans = op->trans;
+
+	if (!NT_STATUS_IS_OK(req->async_states->status)) {
+		return req->async_states->status;
 	}
 
-	trans2_setup_reply(req, trans, 30, 0, 0);
+	trans2_setup_reply(trans, 2, 0, 0);
 
-	SSVAL(trans->out.params.data, VWV(0), io->t2open.out.file.fnum);
-	SSVAL(trans->out.params.data, VWV(1), io->t2open.out.attrib);
-	srv_push_dos_date3(req->smb_conn, trans->out.params.data, 
-			   VWV(2), io->t2open.out.write_time);
-	SIVAL(trans->out.params.data, VWV(4), io->t2open.out.size);
-	SSVAL(trans->out.params.data, VWV(6), io->t2open.out.access);
-	SSVAL(trans->out.params.data, VWV(7), io->t2open.out.ftype);
-	SSVAL(trans->out.params.data, VWV(8), io->t2open.out.devstate);
-	SSVAL(trans->out.params.data, VWV(9), io->t2open.out.action);
-	SIVAL(trans->out.params.data, VWV(10), 0); /* reserved */
-	SSVAL(trans->out.params.data, VWV(12), 0); /* EaErrorOffset */
-	SIVAL(trans->out.params.data, VWV(13), 0); /* EaLength */
+	SSVAL(trans->out.params.data, VWV(0), 0);
 
-	return status;
+	return NT_STATUS_OK;
 }
 
-
 /*
   trans2 mkdir implementation
 */
-static NTSTATUS trans2_mkdir(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_mkdir(struct smbsrv_request *req, struct trans_op *op)
 {
+	struct smb_trans2 *trans = op->trans;
 	union smb_mkdir *io;
 	NTSTATUS status;
 
@@ -489,10 +535,8 @@ static NTSTATUS trans2_mkdir(struct smbsrv_request *req, struct smb_trans2 *tran
 		return NT_STATUS_FOOBAR;
 	}
 
-	io = talloc(req, union smb_mkdir);
-	if (io == NULL) {
-		return NT_STATUS_NO_MEMORY;
-	}
+	io = talloc(op, union smb_mkdir);
+	NT_STATUS_HAVE_NO_MEMORY(io);
 
 	io->t2mkdir.level = RAW_MKDIR_T2MKDIR;
 	trans2_pull_blob_string(req, &trans->in.params, 4, &io->t2mkdir.in.path, 0);
@@ -500,31 +544,31 @@ static NTSTATUS trans2_mkdir(struct smbsrv_request *req, struct smb_trans2 *tran
 	status = ea_pull_list(&trans->in.data, io, 
 			      &io->t2mkdir.in.num_eas, 
 			      &io->t2mkdir.in.eas);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
-
-	status = ntvfs_mkdir(req, io);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
-
-	trans2_setup_reply(req, trans, 2, 0, 0);
+	NT_STATUS_NOT_OK_RETURN(status);
 
-	SSVAL(trans->out.params.data, VWV(0), 0);
+	op->op_info = io;
+	op->send_fn = trans2_simple_send;
 
-	return status;
+	return ntvfs_mkdir(req, io);
 }
 
 /*
   fill in the reply from a qpathinfo or qfileinfo call
 */
-static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_trans2 *trans,
-				     union smb_fileinfo *st)
+static NTSTATUS trans2_fileinfo_send(struct trans_op *op)
 {
+	struct smbsrv_request *req = op->req;
+	struct smb_trans2 *trans = op->trans;
+	union smb_fileinfo *st;
 	uint_t i;
 	uint32_t list_size;
-	
+
+	if (!NT_STATUS_IS_OK(req->async_states->status)) {
+		return req->async_states->status;
+	}
+
+	st = talloc_get_type(op->op_info, union smb_fileinfo);
+
 	switch (st->generic.level) {
 	case RAW_FILEINFO_GENERIC:
 	case RAW_FILEINFO_GETATTR:
@@ -535,7 +579,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 
 	case RAW_FILEINFO_BASIC_INFO:
 	case RAW_FILEINFO_BASIC_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 40, 0);
+		trans2_setup_reply(trans, 2, 40, 0);
 
 		SSVAL(trans->out.params.data, 0, 0);
 		push_nttime(trans->out.data.data,  0, st->basic_info.out.create_time);
@@ -547,7 +591,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_STANDARD:
-		trans2_setup_reply(req, trans, 2, 22, 0);
+		trans2_setup_reply(trans, 2, 22, 0);
 
 		SSVAL(trans->out.params.data, 0, 0);
 		srv_push_dos_date2(req->smb_conn, trans->out.data.data, 0, st->standard.out.create_time);
@@ -559,7 +603,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_EA_SIZE:
-		trans2_setup_reply(req, trans, 2, 26, 0);
+		trans2_setup_reply(trans, 2, 26, 0);
 
 		SSVAL(trans->out.params.data, 0, 0);
 		srv_push_dos_date2(req->smb_conn, trans->out.data.data, 0, st->ea_size.out.create_time);
@@ -572,7 +616,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_NETWORK_OPEN_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 56, 0);
+		trans2_setup_reply(trans, 2, 56, 0);
 
 		SSVAL(trans->out.params.data, 0, 0);
 		push_nttime(trans->out.data.data,  0, st->network_open_information.out.create_time);
@@ -587,7 +631,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 
 	case RAW_FILEINFO_STANDARD_INFO:
 	case RAW_FILEINFO_STANDARD_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 24, 0);
+		trans2_setup_reply( trans, 2, 24, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SBVAL(trans->out.data.data,  0, st->standard_info.out.alloc_size);
 		SBVAL(trans->out.data.data,  8, st->standard_info.out.size);
@@ -598,7 +642,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_ATTRIBUTE_TAG_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 8, 0);
+		trans2_setup_reply(trans, 2, 8, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SIVAL(trans->out.data.data,  0, st->attribute_tag_information.out.attrib);
 		SIVAL(trans->out.data.data,  4, st->attribute_tag_information.out.reparse_tag);
@@ -606,19 +650,19 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 
 	case RAW_FILEINFO_EA_INFO:
 	case RAW_FILEINFO_EA_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 4, 0);
+		trans2_setup_reply(trans, 2, 4, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SIVAL(trans->out.data.data,  0, st->ea_info.out.ea_size);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_MODE_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 4, 0);
+		trans2_setup_reply(trans, 2, 4, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SIVAL(trans->out.data.data,  0, st->mode_information.out.mode);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_ALIGNMENT_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 4, 0);
+		trans2_setup_reply(trans, 2, 4, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SIVAL(trans->out.data.data,  0, 
 		      st->alignment_information.out.alignment_requirement);
@@ -627,7 +671,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 	case RAW_FILEINFO_EA_LIST:
 		list_size = ea_list_size(st->ea_list.out.num_eas,
 					 st->ea_list.out.eas);
-		trans2_setup_reply(req, trans, 2, list_size, 0);
+		trans2_setup_reply(trans, 2, list_size, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		ea_put_list(trans->out.data.data, 
 			    st->ea_list.out.num_eas, st->ea_list.out.eas);
@@ -636,27 +680,27 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 	case RAW_FILEINFO_ALL_EAS:
 		list_size = ea_list_size(st->all_eas.out.num_eas,
 						  st->all_eas.out.eas);
-		trans2_setup_reply(req, trans, 2, list_size, 0);
+		trans2_setup_reply(trans, 2, list_size, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		ea_put_list(trans->out.data.data, 
 			    st->all_eas.out.num_eas, st->all_eas.out.eas);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_ACCESS_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 4, 0);
+		trans2_setup_reply(trans, 2, 4, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SIVAL(trans->out.data.data,  0, st->access_information.out.access_flags);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_POSITION_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 8, 0);
+		trans2_setup_reply(trans, 2, 8, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SBVAL(trans->out.data.data,  0, st->position_information.out.position);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_COMPRESSION_INFO:
 	case RAW_FILEINFO_COMPRESSION_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 16, 0);
+		trans2_setup_reply(trans, 2, 16, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SBVAL(trans->out.data.data,  0, st->compression_info.out.compressed_size);
 		SSVAL(trans->out.data.data,  8, st->compression_info.out.format);
@@ -668,19 +712,19 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_IS_NAME_VALID:
-		trans2_setup_reply(req, trans, 2, 0, 0);
+		trans2_setup_reply(trans, 2, 0, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_INTERNAL_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 8, 0);
+		trans2_setup_reply(trans, 2, 8, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		SBVAL(trans->out.data.data,  0, st->internal_information.out.file_id);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_ALL_INFO:
 	case RAW_FILEINFO_ALL_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 72, 0);
+		trans2_setup_reply(trans, 2, 72, 0);
 
 		SSVAL(trans->out.params.data, 0, 0);
 		push_nttime(trans->out.data.data,  0, st->all_info.out.create_time);
@@ -702,21 +746,21 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 
 	case RAW_FILEINFO_NAME_INFO:
 	case RAW_FILEINFO_NAME_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 4, 0);
+		trans2_setup_reply(trans, 2, 4, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		trans2_append_data_string(req, trans, &st->name_info.out.fname, 0, STR_UNICODE);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_ALT_NAME_INFO:
 	case RAW_FILEINFO_ALT_NAME_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 4, 0);
+		trans2_setup_reply(trans, 2, 4, 0);
 		SSVAL(trans->out.params.data, 0, 0);
 		trans2_append_data_string(req, trans, &st->alt_name_info.out.fname, 0, STR_UNICODE);
 		return NT_STATUS_OK;
 
 	case RAW_FILEINFO_STREAM_INFO:
 	case RAW_FILEINFO_STREAM_INFORMATION:
-		trans2_setup_reply(req, trans, 2, 0, 0);
+		trans2_setup_reply(trans, 2, 0, 0);
 
 		SSVAL(trans->out.params.data, 0, 0);
 
@@ -724,7 +768,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 			uint32_t data_size = trans->out.data.length;
 			uint8_t *data;
 
-			trans2_grow_data(req, trans, data_size + 24);
+			trans2_grow_data(trans, data_size + 24);
 			data = trans->out.data.data + data_size;
 			SBVAL(data,  8, st->stream_info.out.streams[i].size);
 			SBVAL(data, 16, st->stream_info.out.streams[i].alloc_size);
@@ -734,7 +778,7 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 			if (i == st->stream_info.out.num_streams - 1) {
 				SIVAL(trans->out.data.data, data_size, 0);
 			} else {
-				trans2_grow_data_fill(req, trans, (trans->out.data.length+7)&~7);
+				trans2_grow_data_fill(trans, (trans->out.data.length+7)&~7);
 				SIVAL(trans->out.data.data, data_size, 
 				      trans->out.data.length - data_size);
 			}
@@ -756,9 +800,10 @@ static NTSTATUS trans2_fileinfo_fill(struct smbsrv_request *req, struct smb_tran
 /*
   trans2 qpathinfo implementation
 */
-static NTSTATUS trans2_qpathinfo(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_qpathinfo(struct smbsrv_request *req, struct trans_op *op)
 {
-	union smb_fileinfo st;
+	struct smb_trans2 *trans = op->trans;
+	union smb_fileinfo *st;
 	NTSTATUS status;
 	uint16_t level;
 
@@ -767,83 +812,75 @@ static NTSTATUS trans2_qpathinfo(struct smbsrv_request *req, struct smb_trans2 *
 		return NT_STATUS_FOOBAR;
 	}
 
+	st = talloc(op, union smb_fileinfo);
+	NT_STATUS_HAVE_NO_MEMORY(st);
+
 	level = SVAL(trans->in.params.data, 0);
 
-	trans2_pull_blob_string(req, &trans->in.params, 6, &st.generic.in.file.path, 0);
-	if (st.generic.in.file.path == NULL) {
+	trans2_pull_blob_string(req, &trans->in.params, 6, &st->generic.in.file.path, 0);
+	if (st->generic.in.file.path == NULL) {
 		return NT_STATUS_FOOBAR;
 	}
 
 	/* work out the backend level - we make it 1-1 in the header */
-	st.generic.level = (enum smb_fileinfo_level)level;
-	if (st.generic.level >= RAW_FILEINFO_GENERIC) {
+	st->generic.level = (enum smb_fileinfo_level)level;
+	if (st->generic.level >= RAW_FILEINFO_GENERIC) {
 		return NT_STATUS_INVALID_LEVEL;
 	}
 
-	if (st.generic.level == RAW_FILEINFO_EA_LIST) {
+	if (st->generic.level == RAW_FILEINFO_EA_LIST) {
 		status = ea_pull_name_list(&trans->in.data, req, 
-					   &st.ea_list.in.num_names,
-					   &st.ea_list.in.ea_names);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
-	}
-
-	/* call the backend */
-	status = ntvfs_qpathinfo(req, &st);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+					   &st->ea_list.in.num_names,
+					   &st->ea_list.in.ea_names);
+		NT_STATUS_NOT_OK_RETURN(status);
 	}
 
-	/* fill in the reply parameters */
-	status = trans2_fileinfo_fill(req, trans, &st);
+	op->op_info = st;
+	op->send_fn = trans2_fileinfo_send;
 
-	return status;
+	return ntvfs_qpathinfo(req, st);
 }
 
 
 /*
   trans2 qpathinfo implementation
 */
-static NTSTATUS trans2_qfileinfo(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_qfileinfo(struct smbsrv_request *req, struct trans_op *op)
 {
-	union smb_fileinfo st;
+	struct smb_trans2 *trans = op->trans;
+	union smb_fileinfo *st;
 	NTSTATUS status;
-	uint16_t level;
+	uint16_t level, fnum;
 
 	/* make sure we got enough parameters */
 	if (trans->in.params.length < 4) {
 		return NT_STATUS_FOOBAR;
 	}
 
-	st.generic.in.file.fnum  = SVAL(trans->in.params.data, 0);
+	st = talloc(op, union smb_fileinfo);
+	NT_STATUS_HAVE_NO_MEMORY(st);
+
+	fnum  = SVAL(trans->in.params.data, 0);
 	level = SVAL(trans->in.params.data, 2);
 
+	st->generic.in.file.fnum = fnum;
 	/* work out the backend level - we make it 1-1 in the header */
-	st.generic.level = (enum smb_fileinfo_level)level;
-	if (st.generic.level >= RAW_FILEINFO_GENERIC) {
+	st->generic.level = (enum smb_fileinfo_level)level;
+	if (st->generic.level >= RAW_FILEINFO_GENERIC) {
 		return NT_STATUS_INVALID_LEVEL;
 	}
 
-	if (st.generic.level == RAW_FILEINFO_EA_LIST) {
+	if (st->generic.level == RAW_FILEINFO_EA_LIST) {
 		status = ea_pull_name_list(&trans->in.data, req, 
-					   &st.ea_list.in.num_names,
-					   &st.ea_list.in.ea_names);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
+					   &st->ea_list.in.num_names,
+					   &st->ea_list.in.ea_names);
+		NT_STATUS_NOT_OK_RETURN(status);
 	}
 
-	/* call the backend */
-	status = ntvfs_qfileinfo(req, &st);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
+	op->op_info = st;
+	op->send_fn = trans2_fileinfo_send;
 
-	/* fill in the reply parameters */
-	status = trans2_fileinfo_fill(req, trans, &st);
-
-	return status;
+	return ntvfs_qfileinfo(req, st);
 }
 
 
@@ -946,85 +983,85 @@ static NTSTATUS trans2_parse_sfileinfo(struct smbsrv_request *req,
 /*
   trans2 setfileinfo implementation
 */
-static NTSTATUS trans2_setfileinfo(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_setfileinfo(struct smbsrv_request *req, struct trans_op *op)
 {
-	union smb_setfileinfo st;
+	struct smb_trans2 *trans = op->trans;
+	union smb_setfileinfo *st;
 	NTSTATUS status;
 	uint16_t level, fnum;
-	DATA_BLOB *blob;
 
 	/* make sure we got enough parameters */
 	if (trans->in.params.length < 4) {
 		return NT_STATUS_FOOBAR;
 	}
 
+	st = talloc(op, union smb_setfileinfo);
+	NT_STATUS_HAVE_NO_MEMORY(st);
+
 	fnum  = SVAL(trans->in.params.data, 0);
 	level = SVAL(trans->in.params.data, 2);
 
-	blob = &trans->in.data;
-
-	st.generic.in.file.fnum = fnum;
-	st.generic.level = (enum smb_setfileinfo_level)level;
-
-	status = trans2_parse_sfileinfo(req, &st, blob);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+	st->generic.in.file.fnum = fnum;
+	/* work out the backend level - we make it 1-1 in the header */
+	st->generic.level = (enum smb_setfileinfo_level)level;
+	if (st->generic.level >= RAW_SFILEINFO_GENERIC) {
+		return NT_STATUS_INVALID_LEVEL;
 	}
 
-	status = ntvfs_setfileinfo(req, &st);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
+	status = trans2_parse_sfileinfo(req, st, &trans->in.data);
+	NT_STATUS_NOT_OK_RETURN(status);
 
-	trans2_setup_reply(req, trans, 2, 0, 0);
-	SSVAL(trans->out.params.data, 0, 0);
-	return NT_STATUS_OK;
+	op->op_info = st;
+	op->send_fn = trans2_simple_send;
+
+	return ntvfs_setfileinfo(req, st);
 }
 
 /*
   trans2 setpathinfo implementation
 */
-static NTSTATUS trans2_setpathinfo(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_setpathinfo(struct smbsrv_request *req, struct trans_op *op)
 {
-	union smb_setfileinfo st;
+	struct smb_trans2 *trans = op->trans;
+	union smb_setfileinfo *st;
 	NTSTATUS status;
 	uint16_t level;
-	DATA_BLOB *blob;
 
 	/* make sure we got enough parameters */
 	if (trans->in.params.length < 4) {
 		return NT_STATUS_FOOBAR;
 	}
 
+	st = talloc(op, union smb_setfileinfo);
+	NT_STATUS_HAVE_NO_MEMORY(st);
+
 	level = SVAL(trans->in.params.data, 0);
-	blob = &trans->in.data;
-	st.generic.level = (enum smb_setfileinfo_level)level;
 
-	trans2_pull_blob_string(req, &trans->in.params, 6, &st.generic.in.file.path, 0);
-	if (st.generic.in.file.path == NULL) {
+	trans2_pull_blob_string(req, &trans->in.params, 6, &st->generic.in.file.path, 0);
+	if (st->generic.in.file.path == NULL) {
 		return NT_STATUS_FOOBAR;
 	}
 
-	status = trans2_parse_sfileinfo(req, &st, blob);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
+	/* work out the backend level - we make it 1-1 in the header */
+	st->generic.level = (enum smb_setfileinfo_level)level;
+	if (st->generic.level >= RAW_SFILEINFO_GENERIC) {
+		return NT_STATUS_INVALID_LEVEL;
 	}
 
-	status = ntvfs_setpathinfo(req, &st);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
+	status = trans2_parse_sfileinfo(req, st, &trans->in.data);
+	NT_STATUS_NOT_OK_RETURN(status);
 
-	trans2_setup_reply(req, trans, 2, 0, 0);
-	SSVAL(trans->out.params.data, 0, 0);
-	return NT_STATUS_OK;
+	op->op_info = st;
+	op->send_fn = trans2_simple_send;
+
+	return ntvfs_setpathinfo(req, st);
 }
 
 
 /* a structure to encapsulate the state information about an in-progress ffirst/fnext operation */
 struct find_state {
-	struct smbsrv_request *req;
-	struct smb_trans2 *trans;
+	struct trans_op *op;
+	void *search;
 	enum smb_search_level level;
 	uint16_t last_entry_offset;
 	uint16_t flags;
@@ -1033,11 +1070,11 @@ struct find_state {
 /*
   fill a single entry in a trans2 find reply 
 */
-static BOOL find_fill_info(struct smbsrv_request *req,
-			   struct smb_trans2 *trans, 
-			   struct find_state *state,
+static BOOL find_fill_info(struct find_state *state,
 			   union smb_search_data *file)
 {
+	struct smbsrv_request *req = state->op->req;
+	struct smb_trans2 *trans = state->op->trans;
 	uint8_t *data;
 	uint_t ofs = trans->out.data.length;
 	uint32_t ea_size;
@@ -1052,11 +1089,11 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 
 	case RAW_SEARCH_STANDARD:
 		if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
-			trans2_grow_data(req, trans, ofs + 27);
+			trans2_grow_data(trans, ofs + 27);
 			SIVAL(trans->out.data.data, ofs, file->standard.resume_key);
 			ofs += 4;
 		} else {
-			trans2_grow_data(req, trans, ofs + 23);
+			trans2_grow_data(trans, ofs + 23);
 		}
 		data = trans->out.data.data + ofs;
 		srv_push_dos_date2(req->smb_conn, data, 0, file->standard.create_time);
@@ -1071,11 +1108,11 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 
 	case RAW_SEARCH_EA_SIZE:
 		if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
-			trans2_grow_data(req, trans, ofs + 31);
+			trans2_grow_data(trans, ofs + 31);
 			SIVAL(trans->out.data.data, ofs, file->ea_size.resume_key);
 			ofs += 4;
 		} else {
-			trans2_grow_data(req, trans, ofs + 27);
+			trans2_grow_data(trans, ofs + 27);
 		}
 		data = trans->out.data.data + ofs;
 		srv_push_dos_date2(req->smb_conn, data, 0, file->ea_size.create_time);
@@ -1087,20 +1124,20 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 		SIVAL(data, 22, file->ea_size.ea_size);
 		trans2_append_data_string(req, trans, &file->ea_size.name, 
 					  ofs + 26, STR_LEN8BIT | STR_NOALIGN);
-		trans2_grow_data(req, trans, trans->out.data.length + 1);
+		trans2_grow_data(trans, trans->out.data.length + 1);
 		trans->out.data.data[trans->out.data.length-1] = 0;
 		break;
 
 	case RAW_SEARCH_EA_LIST:
 		ea_size = ea_list_size(file->ea_list.eas.num_eas, file->ea_list.eas.eas);
 		if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
-			if (!trans2_grow_data(req, trans, ofs + 27 + ea_size)) {
+			if (!trans2_grow_data(trans, ofs + 27 + ea_size)) {
 				return False;
 			}
 			SIVAL(trans->out.data.data, ofs, file->ea_list.resume_key);
 			ofs += 4;
 		} else {
-			if (!trans2_grow_data(req, trans, ofs + 23 + ea_size)) {
+			if (!trans2_grow_data(trans, ofs + 23 + ea_size)) {
 				return False;
 			}
 		}
@@ -1114,12 +1151,12 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 		ea_put_list(data+22, file->ea_list.eas.num_eas, file->ea_list.eas.eas);
 		trans2_append_data_string(req, trans, &file->ea_list.name, 
 					  ofs + 22 + ea_size, STR_LEN8BIT | STR_NOALIGN);
-		trans2_grow_data(req, trans, trans->out.data.length + 1);
+		trans2_grow_data(trans, trans->out.data.length + 1);
 		trans->out.data.data[trans->out.data.length-1] = 0;
 		break;
 
 	case RAW_SEARCH_DIRECTORY_INFO:
-		trans2_grow_data(req, trans, ofs + 64);
+		trans2_grow_data(trans, ofs + 64);
 		data = trans->out.data.data + ofs;
 		SIVAL(data,          4, file->directory_info.file_index);
 		push_nttime(data,    8, file->directory_info.create_time);
@@ -1136,7 +1173,7 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 		break;
 
 	case RAW_SEARCH_FULL_DIRECTORY_INFO:
-		trans2_grow_data(req, trans, ofs + 68);
+		trans2_grow_data(trans, ofs + 68);
 		data = trans->out.data.data + ofs;
 		SIVAL(data,          4, file->full_directory_info.file_index);
 		push_nttime(data,    8, file->full_directory_info.create_time);
@@ -1154,7 +1191,7 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 		break;
 
 	case RAW_SEARCH_NAME_INFO:
-		trans2_grow_data(req, trans, ofs + 12);
+		trans2_grow_data(trans, ofs + 12);
 		data = trans->out.data.data + ofs;
 		SIVAL(data,          4, file->name_info.file_index);
 		trans2_append_data_string(req, trans, &file->name_info.name, 
@@ -1164,7 +1201,7 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 		break;
 
 	case RAW_SEARCH_BOTH_DIRECTORY_INFO:
-		trans2_grow_data(req, trans, ofs + 94);
+		trans2_grow_data(trans, ofs + 94);
 		data = trans->out.data.data + ofs;
 		SIVAL(data,          4, file->both_directory_info.file_index);
 		push_nttime(data,    8, file->both_directory_info.create_time);
@@ -1189,7 +1226,7 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 		break;
 
 	case RAW_SEARCH_ID_FULL_DIRECTORY_INFO:
-		trans2_grow_data(req, trans, ofs + 80);
+		trans2_grow_data(trans, ofs + 80);
 		data = trans->out.data.data + ofs;
 		SIVAL(data,          4, file->id_full_directory_info.file_index);
 		push_nttime(data,    8, file->id_full_directory_info.create_time);
@@ -1209,7 +1246,7 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 		break;
 
 	case RAW_SEARCH_ID_BOTH_DIRECTORY_INFO:
-		trans2_grow_data(req, trans, ofs + 104);
+		trans2_grow_data(trans, ofs + 104);
 		data = trans->out.data.data + ofs;
 		SIVAL(data,          4, file->id_both_directory_info.file_index);
 		push_nttime(data,    8, file->id_both_directory_info.create_time);
@@ -1240,16 +1277,16 @@ static BOOL find_fill_info(struct smbsrv_request *req,
 /* callback function for trans2 findfirst/findnext */
 static BOOL find_callback(void *private, union smb_search_data *file)
 {
-	struct find_state *state = (struct find_state *)private;
-	struct smb_trans2 *trans = state->trans;
+	struct find_state *state = talloc_get_type(private, struct find_state);
+	struct smb_trans2 *trans = state->op->trans;
 	uint_t old_length;
 
 	old_length = trans->out.data.length;
 
-	if (!find_fill_info(state->req, trans, state, file) ||
+	if (!find_fill_info(state, file) ||
 	    trans->out.data.length > trans->in.max_data) {
 		/* restore the old length and tell the backend to stop */
-		trans2_grow_data(state->req, trans, old_length);
+		trans2_grow_data(trans, old_length);
 		return False;
 	}
 
@@ -1257,74 +1294,125 @@ static BOOL find_callback(void *private, union smb_search_data *file)
 	return True;
 }
 
+/*
+  trans2 findfirst send
+ */
+static NTSTATUS trans2_findfirst_send(struct trans_op *op)
+{
+	struct smbsrv_request *req = op->req;
+	struct smb_trans2 *trans = op->trans;
+	union smb_search_first *search;
+	struct find_state *state;
+	uint8_t *param;
+
+	if (!NT_STATUS_IS_OK(req->async_states->status)) {
+		trans2_setup_reply(trans, 0, 0, 0);
+		return req->async_states->status;
+	}
+
+	state = talloc_get_type(op->op_info, struct find_state);
+	search = talloc_get_type(state->search, union smb_search_first);
+
+	/* fill in the findfirst reply header */
+	param = trans->out.params.data;
+	SSVAL(param, VWV(0), search->t2ffirst.out.handle);
+	SSVAL(param, VWV(1), search->t2ffirst.out.count);
+	SSVAL(param, VWV(2), search->t2ffirst.out.end_of_search);
+	SSVAL(param, VWV(3), 0);
+	SSVAL(param, VWV(4), state->last_entry_offset);
+
+	return NT_STATUS_OK;
+}
+
 
 /*
   trans2 findfirst implementation
 */
-static NTSTATUS trans2_findfirst(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_findfirst(struct smbsrv_request *req, struct trans_op *op)
 {
-	union smb_search_first search;
+	struct smb_trans2 *trans = op->trans;
+	union smb_search_first *search;
 	NTSTATUS status;
 	uint16_t level;
-	uint8_t *param;
-	struct find_state state;
+	struct find_state *state;
 
 	/* make sure we got all the parameters */
 	if (trans->in.params.length < 14) {
 		return NT_STATUS_FOOBAR;
 	}
 
-	search.t2ffirst.in.search_attrib = SVAL(trans->in.params.data, 0);
-	search.t2ffirst.in.max_count     = SVAL(trans->in.params.data, 2);
-	search.t2ffirst.in.flags         = SVAL(trans->in.params.data, 4);
-	level                            = SVAL(trans->in.params.data, 6);
-	search.t2ffirst.in.storage_type  = IVAL(trans->in.params.data, 8);
+	search = talloc(op, union smb_search_first);
+	NT_STATUS_HAVE_NO_MEMORY(search);
 
-	trans2_pull_blob_string(req, &trans->in.params, 12, &search.t2ffirst.in.pattern, 0);
-	if (search.t2ffirst.in.pattern == NULL) {
+	search->t2ffirst.in.search_attrib = SVAL(trans->in.params.data, 0);
+	search->t2ffirst.in.max_count     = SVAL(trans->in.params.data, 2);
+	search->t2ffirst.in.flags         = SVAL(trans->in.params.data, 4);
+	level                             = SVAL(trans->in.params.data, 6);
+	search->t2ffirst.in.storage_type  = IVAL(trans->in.params.data, 8);
+
+	trans2_pull_blob_string(req, &trans->in.params, 12, &search->t2ffirst.in.pattern, 0);
+	if (search->t2ffirst.in.pattern == NULL) {
 		return NT_STATUS_FOOBAR;
 	}
 
-	search.t2ffirst.level = (enum smb_search_level)level;
-	if (search.t2ffirst.level >= RAW_SEARCH_GENERIC) {
+	search->t2ffirst.level = (enum smb_search_level)level;
+	if (search->t2ffirst.level >= RAW_SEARCH_GENERIC) {
 		return NT_STATUS_INVALID_LEVEL;
 	}
 
-	if (search.t2ffirst.level == RAW_SEARCH_EA_LIST) {
+	if (search->t2ffirst.level == RAW_SEARCH_EA_LIST) {
 		status = ea_pull_name_list(&trans->in.data, req,
-					   &search.t2ffirst.in.num_names, 
-					   &search.t2ffirst.in.ea_names);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
+					   &search->t2ffirst.in.num_names, 
+					   &search->t2ffirst.in.ea_names);
+		NT_STATUS_NOT_OK_RETURN(status);
 	}
 
 	/* setup the private state structure that the backend will
 	   give us in the callback */
-	state.req = req;
-	state.trans = trans;
-	state.level = search.t2ffirst.level;
-	state.last_entry_offset = 0;
-	state.flags = search.t2ffirst.in.flags;
+	state = talloc(op, struct find_state);
+	NT_STATUS_HAVE_NO_MEMORY(state);
+	state->op		= op;
+	state->search		= search;
+	state->level		= search->t2ffirst.level;
+	state->last_entry_offset= 0;
+	state->flags		= search->t2ffirst.in.flags;
 
 	/* setup for just a header in the reply */
-	trans2_setup_reply(req, trans, 10, 0, 0);
+	trans2_setup_reply(trans, 10, 0, 0);
 
-	/* call the backend */
-	status = ntvfs_search_first(req, &search, &state, find_callback);
-	if (!NT_STATUS_IS_OK(status)) {
-		trans2_setup_reply(req, trans, 0, 0, 0);
-		return status;
+	op->op_info = state;
+	op->send_fn = trans2_findfirst_send;
+
+	return ntvfs_search_first(req, search, state, find_callback);
+}
+
+
+/*
+  trans2 findnext send
+*/
+static NTSTATUS trans2_findnext_send(struct trans_op *op)
+{
+	struct smbsrv_request *req = op->req;
+	struct smb_trans2 *trans = op->trans;
+	union smb_search_next *search;
+	struct find_state *state;
+	uint8_t *param;
+
+	if (!NT_STATUS_IS_OK(req->async_states->status)) {
+		trans2_setup_reply(trans, 0, 0, 0);
+		return req->async_states->status;
 	}
 
+	state = talloc_get_type(op->op_info, struct find_state);
+	search = talloc_get_type(state->search, union smb_search_next);
+
 	/* fill in the findfirst reply header */
 	param = trans->out.params.data;
-	SSVAL(param, VWV(0), search.t2ffirst.out.handle);
-	SSVAL(param, VWV(1), search.t2ffirst.out.count);
-	SSVAL(param, VWV(2), search.t2ffirst.out.end_of_search);
-	SSVAL(param, VWV(3), 0);
-	SSVAL(param, VWV(4), state.last_entry_offset);
-
+	SSVAL(param, VWV(0), search->t2fnext.out.count);
+	SSVAL(param, VWV(1), search->t2fnext.out.end_of_search);
+	SSVAL(param, VWV(2), 0);
+	SSVAL(param, VWV(3), state->last_entry_offset);
+	
 	return NT_STATUS_OK;
 }
 
@@ -1332,76 +1420,70 @@ static NTSTATUS trans2_findfirst(struct smbsrv_request *req, struct smb_trans2 *
 /*
   trans2 findnext implementation
 */
-static NTSTATUS trans2_findnext(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_findnext(struct smbsrv_request *req, struct trans_op *op)
 {
-	union smb_search_next search;
+	struct smb_trans2 *trans = op->trans;
+	union smb_search_next *search;
 	NTSTATUS status;
 	uint16_t level;
-	uint8_t *param;
-	struct find_state state;
+	struct find_state *state;
 
 	/* make sure we got all the parameters */
 	if (trans->in.params.length < 12) {
 		return NT_STATUS_FOOBAR;
 	}
 
-	search.t2fnext.in.handle        = SVAL(trans->in.params.data, 0);
-	search.t2fnext.in.max_count     = SVAL(trans->in.params.data, 2);
-	level                           = SVAL(trans->in.params.data, 4);
-	search.t2fnext.in.resume_key    = IVAL(trans->in.params.data, 6);
-	search.t2fnext.in.flags         = SVAL(trans->in.params.data, 10);
+	search = talloc(op, union smb_search_next);
+	NT_STATUS_HAVE_NO_MEMORY(search);
+
+	search->t2fnext.in.handle        = SVAL(trans->in.params.data, 0);
+	search->t2fnext.in.max_count     = SVAL(trans->in.params.data, 2);
+	level                            = SVAL(trans->in.params.data, 4);
+	search->t2fnext.in.resume_key    = IVAL(trans->in.params.data, 6);
+	search->t2fnext.in.flags         = SVAL(trans->in.params.data, 10);
 
-	trans2_pull_blob_string(req, &trans->in.params, 12, &search.t2fnext.in.last_name, 0);
-	if (search.t2fnext.in.last_name == NULL) {
+	trans2_pull_blob_string(req, &trans->in.params, 12, &search->t2fnext.in.last_name, 0);
+	if (search->t2fnext.in.last_name == NULL) {
 		return NT_STATUS_FOOBAR;
 	}
 
-	search.t2fnext.level = (enum smb_search_level)level;
-	if (search.t2fnext.level >= RAW_SEARCH_GENERIC) {
+	search->t2fnext.level = (enum smb_search_level)level;
+	if (search->t2fnext.level >= RAW_SEARCH_GENERIC) {
 		return NT_STATUS_INVALID_LEVEL;
 	}
 
-	if (search.t2fnext.level == RAW_SEARCH_EA_LIST) {
+	if (search->t2fnext.level == RAW_SEARCH_EA_LIST) {
 		status = ea_pull_name_list(&trans->in.data, req,
-					   &search.t2fnext.in.num_names, 
-					   &search.t2fnext.in.ea_names);
-		if (!NT_STATUS_IS_OK(status)) {
-			return status;
-		}
+					   &search->t2fnext.in.num_names, 
+					   &search->t2fnext.in.ea_names);
+		NT_STATUS_NOT_OK_RETURN(status);
 	}
 
 	/* setup the private state structure that the backend will give us in the callback */
-	state.req = req;
-	state.trans = trans;
-	state.level = search.t2fnext.level;
-	state.last_entry_offset = 0;
-	state.flags = search.t2fnext.in.flags;
+	state = talloc(op, struct find_state);
+	NT_STATUS_HAVE_NO_MEMORY(state);
+	state->op		= op;
+	state->search		= search;
+	state->level		= search->t2fnext.level;
+	state->last_entry_offset= 0;
+	state->flags		= search->t2fnext.in.flags;
 
 	/* setup for just a header in the reply */
-	trans2_setup_reply(req, trans, 8, 0, 0);
+	trans2_setup_reply(trans, 8, 0, 0);
 
-	/* call the backend */
-	status = ntvfs_search_next(req, &search, &state, find_callback);
-	if (!NT_STATUS_IS_OK(status)) {
-		return status;
-	}
+	op->op_info = state;
+	op->send_fn = trans2_findnext_send;
 
-	/* fill in the findfirst reply header */
-	param = trans->out.params.data;
-	SSVAL(param, VWV(0), search.t2fnext.out.count);
-	SSVAL(param, VWV(1), search.t2fnext.out.end_of_search);
-	SSVAL(param, VWV(2), 0);
-	SSVAL(param, VWV(3), state.last_entry_offset);
-	
-	return NT_STATUS_OK;
+	return ntvfs_search_next(req, search, state, find_callback);
 }
 
 
 /*
   backend for trans2 requests
 */
-static NTSTATUS trans2_backend(struct smbsrv_request *req, struct smb_trans2 *trans)
+static NTSTATUS trans2_backend(struct smbsrv_request *req, struct trans_op *op)
 {
+	struct smb_trans2 *trans = op->trans;
 	NTSTATUS status;
 
 	/* direct trans2 pass thru */
@@ -1418,23 +1500,23 @@ static NTSTATUS trans2_backend(struct smbsrv_request *req, struct smb_trans2 *tr
 	/* the trans2 command is in setup[0] */
 	switch (trans->in.setup[0]) {
 	case TRANSACT2_FINDFIRST:
-		return trans2_findfirst(req, trans);
+		return trans2_findfirst(req, op);
 	case TRANSACT2_FINDNEXT:
-		return trans2_findnext(req, trans);
+		return trans2_findnext(req, op);
 	case TRANSACT2_QPATHINFO:
-		return trans2_qpathinfo(req, trans);
+		return trans2_qpathinfo(req, op);
 	case TRANSACT2_QFILEINFO:
-		return trans2_qfileinfo(req, trans);
+		return trans2_qfileinfo(req, op);
 	case TRANSACT2_SETFILEINFO:
-		return trans2_setfileinfo(req, trans);
+		return trans2_setfileinfo(req, op);
 	case TRANSACT2_SETPATHINFO:
-		return trans2_setpathinfo(req, trans);
+		return trans2_setpathinfo(req, op);
 	case TRANSACT2_QFSINFO:
-		return trans2_qfsinfo(req, trans);
+		return trans2_qfsinfo(req, op);
 	case TRANSACT2_OPEN:
-		return trans2_open(req, trans);
+		return trans2_open(req, op);
 	case TRANSACT2_MKDIR:
-		return trans2_mkdir(req, trans);
+		return trans2_mkdir(req, op);
 	}
 
 	/* an unknown trans2 command */
@@ -1445,7 +1527,7 @@ static NTSTATUS trans2_backend(struct smbsrv_request *req, struct smb_trans2 *tr
 /*
   send a continue request
 */
-static void reply_trans_continue(struct smbsrv_request *req, uint8_t command, 
+static void reply_trans_continue(struct smbsrv_request *req, uint8_t command,
 				 struct smb_trans2 *trans)
 {
 	struct smbsrv_trans_partial *tp;
@@ -1475,24 +1557,31 @@ static void reply_trans_continue(struct smbsrv_request *req, uint8_t command,
 /*
   answer a reconstructed trans request
 */
-static void reply_trans_complete(struct smbsrv_request *req, uint8_t command, 
-				 struct smb_trans2 *trans)
+static void reply_trans_send(struct smbsrv_request *req)
 {
+	struct trans_op *op;
+	struct smb_trans2 *trans;
 	uint16_t params_left, data_left;
 	uint8_t *params, *data;
-	NTSTATUS status;
 	int i;
 
-	/* its a full request, give it to the backend */
-	if (command == SMBtrans) {
-		status = ntvfs_trans(req, trans);
-	} else {
-		status = trans2_backend(req, trans);
+	if (NT_STATUS_IS_ERR(req->async_states->status)) {
+		smbsrv_send_error(req, req->async_states->status);
+		return;
 	}
 
-	if (NT_STATUS_IS_ERR(status)) {
-		smbsrv_send_error(req, status);
-		return;
+	op = talloc_get_type(req->async_states->private_data, struct trans_op);
+	trans = op->trans;
+
+	/* if this function needs work to form the nttrans reply buffer, then
+	   call that now */
+	if (op->send_fn != NULL) {
+		NTSTATUS status;
+		status = op->send_fn(op);
+		if (!NT_STATUS_IS_OK(status)) {
+			smbsrv_send_error(req, status);
+			return;
+		}
 	}
 
 	params_left = trans->out.params.length;
@@ -1502,8 +1591,8 @@ static void reply_trans_complete(struct smbsrv_request *req, uint8_t command,
 
 	smbsrv_setup_reply(req, 10 + trans->out.setup_count, 0);
 
-	if (!NT_STATUS_IS_OK(status)) {
-		smbsrv_setup_error(req, status);
+	if (!NT_STATUS_IS_OK(req->async_states->status)) {
+		smbsrv_setup_error(req, req->async_states->status);
 	}
 
 	/* we need to divide up the reply into chunks that fit into
@@ -1574,6 +1663,42 @@ static void reply_trans_complete(struct smbsrv_request *req, uint8_t command,
 
 
 /*
+  answer a reconstructed trans request
+*/
+static void reply_trans_complete(struct smbsrv_request *req, uint8_t command,
+				 struct smb_trans2 *trans)
+{
+	struct trans_op *op;
+
+	op = talloc(trans, struct trans_op);
+	if (op == NULL) {
+		smbsrv_send_error(req, NT_STATUS_NO_MEMORY);
+		return;
+	}
+
+	op->req		= req;
+	op->trans	= trans;
+	op->command	= command;
+	op->op_info	= NULL;
+	op->send_fn	= NULL;
+
+	req->async_states->state |= NTVFS_ASYNC_STATE_MAY_ASYNC;
+	req->async_states->send_fn = reply_trans_send;
+	req->async_states->private_data = op;
+
+	/* its a full request, give it to the backend */
+	if (command == SMBtrans) {
+		req->async_states->status = ntvfs_trans(req, trans);
+	} else {
+		req->async_states->status = trans2_backend(req, op);
+	}
+
+	if (!(req->async_states->state & NTVFS_ASYNC_STATE_ASYNC)) {
+		req->async_states->send_fn(req);
+	}
+}
+
+/*
   Reply to an SMBtrans or SMBtrans2 request
 */
 static void reply_trans_generic(struct smbsrv_request *req, uint8_t command)
@@ -1584,18 +1709,18 @@ static void reply_trans_generic(struct smbsrv_request *req, uint8_t command)
 	uint16_t param_count, data_count;
 	uint16_t param_total, data_total;
 
-	trans = talloc(req, struct smb_trans2);
-	if (trans == NULL) {
-		smbsrv_send_error(req, NT_STATUS_NO_MEMORY);
-		return;
-	}
-
 	/* parse request */
 	if (req->in.wct < 14) {
 		smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER);
 		return;
 	}
 
+	trans = talloc(req, struct smb_trans2);
+	if (trans == NULL) {
+		smbsrv_send_error(req, NT_STATUS_NO_MEMORY);
+		return;
+	}
+
 	param_total           = SVAL(req->in.vwv, VWV(0));
 	data_total            = SVAL(req->in.vwv, VWV(1));
 	trans->in.max_param   = SVAL(req->in.vwv, VWV(2));
@@ -1615,7 +1740,7 @@ static void reply_trans_generic(struct smbsrv_request *req, uint8_t command)
 	}
 
 	/* parse out the setup words */
-	trans->in.setup = talloc_array(req, uint16_t, trans->in.setup_count);
+	trans->in.setup = talloc_array(trans, uint16_t, trans->in.setup_count);
 	if (trans->in.setup_count && !trans->in.setup) {
 		smbsrv_send_error(req, NT_STATUS_NO_MEMORY);
 		return;
@@ -1657,9 +1782,16 @@ static void reply_transs_generic(struct smbsrv_request *req, uint8_t command)
 	uint16_t param_total, data_total;
 	DATA_BLOB params, data;
 
+	/* parse request */
+	if (req->in.wct < 8) {
+		smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER);
+		return;
+	}
+
 	for (tp=req->smb_conn->trans_partial;tp;tp=tp->next) {
 		if (tp->command == command &&
 		    SVAL(tp->req->in.hdr, HDR_MID) == SVAL(req->in.hdr, HDR_MID)) {
+/* TODO: check the VUID, PID and TID too? */
 			break;
 		}
 	}
@@ -1671,12 +1803,6 @@ static void reply_transs_generic(struct smbsrv_request *req, uint8_t command)
 
 	trans = tp->trans;
 
-	/* parse request */
-	if (req->in.wct < 8) {
-		smbsrv_send_error(req, NT_STATUS_INVALID_PARAMETER);
-		return;
-	}
-
 	param_total           = SVAL(req->in.vwv, VWV(0));
 	data_total            = SVAL(req->in.vwv, VWV(1));
 	param_count           = SVAL(req->in.vwv, VWV(2));