[PATCHES] smb3 create replay (for multi-channel)
Michael Adam
obnox at samba.org
Tue Mar 1 01:15:33 UTC 2016
Hi all,
here is an important step toward multi channel:
Implementation of create replay.
- This patchset includes the previously sent
patches for dbwrap_purge as the first patches.
- It then reworks several replay tests that work
on a single channel by splitting them up
into more easily understandable smaller tests
and extending them for better coverage.
- Next, preparation in smbXsrv_open are done
to implement a replay cache to find an open
based on the create_guid.
- finally, these mechanisms are used in smb2_create
to implement create replay.
Review appreciated.
Thanks - Michael
-------------- next part --------------
From 77309781475b78cd86df65f11745dbd0793e20eb Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Thu, 25 Feb 2016 16:02:36 +0100
Subject: [PATCH 01/16] dbwrap_util: improve a debug message in
dbwrap_delete_action()
Signed-off-by: Michael Adam <obnox at samba.org>
---
lib/dbwrap/dbwrap_util.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/lib/dbwrap/dbwrap_util.c b/lib/dbwrap/dbwrap_util.c
index 901ef56..5118fb7 100644
--- a/lib/dbwrap/dbwrap_util.c
+++ b/lib/dbwrap/dbwrap_util.c
@@ -412,7 +412,8 @@ static NTSTATUS dbwrap_delete_action(struct db_context * db, void *private_data)
status = dbwrap_record_delete(rec);
if (!NT_STATUS_IS_OK(status)) {
- DEBUG(5, ("delete_rec returned %s\n", nt_errstr(status)));
+ DBG_INFO("dbwrap_record_delete returned %s\n",
+ nt_errstr(status));
}
talloc_free(rec);
--
2.5.0
From 78a563c8ab045918515bcd77179bbc9941f4b221 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Thu, 25 Feb 2016 00:56:14 +0100
Subject: [PATCH 02/16] dbwrap: add dbwrap_purge[_bystring]
Variants of dbrwap_delete[_bysrting] that treats NOT FOUND
as success.
Signed-off-by: Michael Adam <obnox at samba.org>
---
lib/dbwrap/dbwrap.h | 2 ++
lib/dbwrap/dbwrap_util.c | 17 +++++++++++++++++
2 files changed, 19 insertions(+)
diff --git a/lib/dbwrap/dbwrap.h b/lib/dbwrap/dbwrap.h
index 5e13a59..2eded04 100644
--- a/lib/dbwrap/dbwrap.h
+++ b/lib/dbwrap/dbwrap.h
@@ -94,6 +94,8 @@ const char *dbwrap_name(struct db_context *db);
/* The following definitions come from lib/dbwrap_util.c */
+NTSTATUS dbwrap_purge(struct db_context *db, TDB_DATA key);
+NTSTATUS dbwrap_purge_bystring(struct db_context *db, const char *key);
NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key);
NTSTATUS dbwrap_store_bystring(struct db_context *db, const char *key,
TDB_DATA data, int flags);
diff --git a/lib/dbwrap/dbwrap_util.c b/lib/dbwrap/dbwrap_util.c
index 5118fb7..22f910d 100644
--- a/lib/dbwrap/dbwrap_util.c
+++ b/lib/dbwrap/dbwrap_util.c
@@ -528,6 +528,23 @@ NTSTATUS dbwrap_trans_traverse(struct db_context *db,
return dbwrap_trans_do(db, dbwrap_trans_traverse_action, &ctx);
}
+NTSTATUS dbwrap_purge(struct db_context *db, TDB_DATA key)
+{
+ NTSTATUS status;
+
+ status = dbwrap_delete(db, key);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+ status = NT_STATUS_OK;
+ }
+
+ return status;
+}
+
+NTSTATUS dbwrap_purge_bystring(struct db_context *db, const char *key)
+{
+ return dbwrap_purge(db, string_term_tdb_data(key));
+}
+
NTSTATUS dbwrap_delete_bystring(struct db_context *db, const char *key)
{
return dbwrap_delete(db, string_term_tdb_data(key));
--
2.5.0
From 8225f8a907d5a0f7b730c30d12aeaaa4e71a3b8f Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Thu, 25 Feb 2016 00:58:50 +0100
Subject: [PATCH 03/16] s3:registry: use dbwrap_purge_bystring instead of
dbwrap_delete_bystring
where appropriate
Signed-off-by: Michael Adam <obnox at samba.org>
---
source3/registry/reg_backend_db.c | 7 +------
1 file changed, 1 insertion(+), 6 deletions(-)
diff --git a/source3/registry/reg_backend_db.c b/source3/registry/reg_backend_db.c
index 7b3391d..bdfe7d2 100644
--- a/source3/registry/reg_backend_db.c
+++ b/source3/registry/reg_backend_db.c
@@ -966,12 +966,7 @@ static WERROR regdb_delete_key_with_prefix(struct db_context *db,
goto done;
}
- werr = ntstatus_to_werror(dbwrap_delete_bystring(db, path));
-
- /* treat "not found" as ok */
- if (W_ERROR_EQUAL(werr, WERR_NOT_FOUND)) {
- werr = WERR_OK;
- }
+ werr = ntstatus_to_werror(dbwrap_purge_bystring(db, path));
done:
talloc_free(mem_ctx);
--
2.5.0
From 49c2870de5b40fec80c885b4a8a5bd2f4ad41b51 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Thu, 25 Feb 2016 16:15:04 +0100
Subject: [PATCH 04/16] netlogon_creds_cli: use dbwrap_purge instead of
dbwrap_delete where appropriate
Signed-off-by: Michael Adam <obnox at samba.org>
---
libcli/auth/netlogon_creds_cli.c | 14 ++++----------
1 file changed, 4 insertions(+), 10 deletions(-)
diff --git a/libcli/auth/netlogon_creds_cli.c b/libcli/auth/netlogon_creds_cli.c
index 7c867cf..38b1351 100644
--- a/libcli/auth/netlogon_creds_cli.c
+++ b/libcli/auth/netlogon_creds_cli.c
@@ -1031,11 +1031,8 @@ struct tevent_req *netlogon_creds_cli_auth_send(TALLOC_CTX *mem_ctx,
return req;
}
- status = dbwrap_delete(state->context->db.ctx,
- state->context->db.key_data);
- if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
- status = NT_STATUS_OK;
- }
+ status = dbwrap_purge(state->context->db.ctx,
+ state->context->db.key_data);
if (tevent_req_nterror(req, status)) {
return tevent_req_post(req, ev);
}
@@ -1065,11 +1062,8 @@ static void netlogon_creds_cli_auth_locked(struct tevent_req *subreq)
}
state->locked_state->is_glocked = true;
- status = dbwrap_delete(state->context->db.ctx,
- state->context->db.key_data);
- if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
- status = NT_STATUS_OK;
- }
+ status = dbwrap_purge(state->context->db.ctx,
+ state->context->db.key_data);
if (tevent_req_nterror(req, status)) {
return;
}
--
2.5.0
From 2c315991301baf650a83875b4df76f4068ddbe9b Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Tue, 1 Mar 2016 01:14:48 +0100
Subject: [PATCH 05/16] torture:smb2: rename replay1 -> replay_commands
Signed-off-by: Michael Adam <obnox at samba.org>
---
selftest/knownfail | 2 +-
source4/torture/smb2/replay.c | 6 +++---
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/selftest/knownfail b/selftest/knownfail
index 04a0621..e6944a9 100644
--- a/selftest/knownfail
+++ b/selftest/knownfail
@@ -202,7 +202,7 @@
^samba3.smb2.setinfo.setinfo
^samba3.smb2.session.*reauth5 # some special anonymous checks?
^samba3.smb2.compound.interim2 # wrong return code (STATUS_CANCELLED)
-^samba3.smb2.replay.replay1
+^samba3.smb2.replay.replay_commands
^samba3.smb2.replay.replay2
^samba3.smb2.replay.replay3
^samba3.smb2.replay.replay4
diff --git a/source4/torture/smb2/replay.c b/source4/torture/smb2/replay.c
index 26c32d1..91ac6e6 100644
--- a/source4/torture/smb2/replay.c
+++ b/source4/torture/smb2/replay.c
@@ -161,7 +161,7 @@ static bool torture_oplock_ack_handler(struct smb2_transport *transport,
* Test what happens when SMB2_FLAGS_REPLAY_OPERATION is enabled for various
* commands. We want to verify if the server returns an error code or not.
*/
-static bool test_replay1(struct torture_context *tctx, struct smb2_tree *tree)
+static bool test_replay_commands(struct torture_context *tctx, struct smb2_tree *tree)
{
bool ret = true;
NTSTATUS status;
@@ -175,7 +175,7 @@ static bool test_replay1(struct torture_context *tctx, struct smb2_tree *tree)
struct smb2_lock_element el[2];
struct smb2_flush f;
TALLOC_CTX *tmp_ctx = talloc_new(tree);
- const char *fname = BASEDIR "\\replay1.dat";
+ const char *fname = BASEDIR "\\replay_commands.dat";
struct smb2_transport *transport = tree->session->transport;
if (smbXcli_conn_protocol(transport->conn) < PROTOCOL_SMB3_00) {
@@ -989,7 +989,7 @@ struct torture_suite *torture_smb2_replay_init(void)
struct torture_suite *suite =
torture_suite_create(talloc_autofree_context(), "replay");
- torture_suite_add_1smb2_test(suite, "replay1", test_replay1);
+ torture_suite_add_1smb2_test(suite, "replay_commands", test_replay_commands);
torture_suite_add_1smb2_test(suite, "replay2", test_replay2);
torture_suite_add_1smb2_test(suite, "replay3", test_replay3);
torture_suite_add_1smb2_test(suite, "replay4", test_replay4);
--
2.5.0
From 203a6a77c20a6569f40170e0df5010e7e35d2479 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Tue, 1 Mar 2016 01:18:03 +0100
Subject: [PATCH 06/16] torture:smb2: split rename2 into multiple tests and
extend these
- replay_regular
- replay_dhv2_oplock1
- replay_dhv2_oplock2
- replay_dhv2_oplock3
Signed-off-by: Michael Adam <obnox at samba.org>
---
selftest/knownfail | 5 +-
source4/torture/smb2/replay.c | 384 +++++++++++++++++++++++++++++++++++++-----
2 files changed, 342 insertions(+), 47 deletions(-)
diff --git a/selftest/knownfail b/selftest/knownfail
index e6944a9..bd3151c 100644
--- a/selftest/knownfail
+++ b/selftest/knownfail
@@ -203,7 +203,10 @@
^samba3.smb2.session.*reauth5 # some special anonymous checks?
^samba3.smb2.compound.interim2 # wrong return code (STATUS_CANCELLED)
^samba3.smb2.replay.replay_commands
-^samba3.smb2.replay.replay2
+^samba3.smb2.replay.replay_regular
+^samba3.smb2.replay.replay_dhv2_oplock1
+^samba3.smb2.replay.replay_dhv2_oplock2
+^samba3.smb2.replay.replay_dhv2_oplock3
^samba3.smb2.replay.replay3
^samba3.smb2.replay.replay4
^samba3.smb2.lock.*replay
diff --git a/source4/torture/smb2/replay.c b/source4/torture/smb2/replay.c
index 91ac6e6..e79d3c9 100644
--- a/source4/torture/smb2/replay.c
+++ b/source4/torture/smb2/replay.c
@@ -287,20 +287,136 @@ done:
}
/**
- * Test Durablity V2 Create Replay Detection on Single Channel. Also verify that
- * regular creates can not be replayed.
+ * Test replay detection without create GUID on single channel.
+ * Regular creates can not be replayed.
+ * The return code is unaffected of the REPLAY_OPERATION flag.
*/
-static bool test_replay2(struct torture_context *tctx, struct smb2_tree *tree)
+static bool test_replay_regular(struct torture_context *tctx,
+ struct smb2_tree *tree)
{
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle _h;
struct smb2_handle *h = NULL;
- struct smb2_create io, ref1, ref2;
- struct GUID create_guid = GUID_random();
+ struct smb2_create io;
uint32_t perms = 0;
bool ret = true;
- const char *fname = BASEDIR "\\replay2.dat";
+ const char *fname = BASEDIR "\\replay_regular.dat";
+ struct smb2_transport *transport = tree->session->transport;
+
+ if (smbXcli_conn_protocol(transport->conn) < PROTOCOL_SMB3_00) {
+ torture_skip(tctx, "SMB 3.X Dialect family required for "
+ "replay tests\n");
+ }
+
+ ZERO_STRUCT(break_info);
+ break_info.tctx = tctx;
+ tree->session->transport->oplock.handler = torture_oplock_ack_handler;
+ tree->session->transport->oplock.private_data = tree;
+
+ smb2_util_unlink(tree, fname);
+ status = torture_smb2_testdir(tree, BASEDIR, &_h);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ smb2_util_close(tree, _h);
+ CHECK_VAL(break_info.count, 0);
+
+ torture_comment(tctx, "No replay detection for regular create\n");
+
+ perms = SEC_STD_SYNCHRONIZE | SEC_STD_READ_CONTROL | SEC_STD_DELETE |
+ SEC_DIR_WRITE_ATTRIBUTE | SEC_DIR_READ_ATTRIBUTE |
+ SEC_DIR_WRITE_EA | SEC_FILE_APPEND_DATA |
+ SEC_FILE_WRITE_DATA;
+
+ io = (struct smb2_create) {
+ .in.desired_access = perms,
+ .in.file_attributes = 0,
+ .in.create_disposition = NTCREATEX_DISP_CREATE,
+ .in.share_access = NTCREATEX_SHARE_ACCESS_DELETE,
+ .in.create_options = 0x0,
+ .in.fname = fname
+ };
+
+ status = smb2_create(tree, tctx, &io);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ CHECK_VAL(break_info.count, 0);
+ _h = io.out.file.handle;
+ h = &_h;
+ CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
+
+ smb2cli_session_start_replay(tree->session->smbXcli);
+ status = smb2_create(tree, tctx, &io);
+ smb2cli_session_stop_replay(tree->session->smbXcli);
+ CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_COLLISION);
+ CHECK_VAL(break_info.count, 0);
+
+ smb2_util_close(tree, *h);
+ h = NULL;
+ smb2_util_unlink(tree, fname);
+
+ /*
+ * Same experiment with different create disposition.
+ */
+ io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
+ status = smb2_create(tree, tctx, &io);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ CHECK_VAL(break_info.count, 0);
+ _h = io.out.file.handle;
+ h = &_h;
+ CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
+
+ smb2cli_session_start_replay(tree->session->smbXcli);
+ status = smb2_create(tree, tctx, &io);
+ smb2cli_session_stop_replay(tree->session->smbXcli);
+ CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+ CHECK_VAL(break_info.count, 0);
+
+ smb2_util_close(tree, *h);
+ h = NULL;
+ smb2_util_unlink(tree, fname);
+
+ /*
+ * Now with more generous share mode.
+ */
+ io.in.share_access = smb2_util_share_access("RWD");
+ status = smb2_create(tree, tctx, &io);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ CHECK_VAL(break_info.count, 0);
+ _h = io.out.file.handle;
+ h = &_h;
+ CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
+
+ smb2cli_session_start_replay(tree->session->smbXcli);
+ status = smb2_create(tree, tctx, &io);
+ smb2cli_session_stop_replay(tree->session->smbXcli);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ CHECK_VAL(break_info.count, 0);
+
+done:
+ if (h != NULL) {
+ smb2_util_close(tree, *h);
+ }
+ smb2_deltree(tree, BASEDIR);
+
+ talloc_free(tree);
+ talloc_free(mem_ctx);
+
+ return ret;
+}
+
+/**
+ * Test Durablity V2 Create Replay Detection on Single Channel.
+ */
+static bool test_replay_dhv2_oplock1(struct torture_context *tctx,
+ struct smb2_tree *tree)
+{
+ NTSTATUS status;
+ TALLOC_CTX *mem_ctx = talloc_new(tctx);
+ struct smb2_handle _h;
+ struct smb2_handle *h = NULL;
+ struct smb2_create io, ref1;
+ struct GUID create_guid = GUID_random();
+ bool ret = true;
+ const char *fname = BASEDIR "\\replay_dhv2_oplock1.dat";
struct smb2_transport *transport = tree->session->transport;
uint32_t share_capabilities;
bool share_is_so;
@@ -362,14 +478,98 @@ static bool test_replay2(struct torture_context *tctx, struct smb2_tree *tree)
CHECK_CREATE_OUT(&io, &ref1);
CHECK_VAL(break_info.count, 0);
+done:
+ if (h != NULL) {
+ smb2_util_close(tree, *h);
+ }
+ smb2_deltree(tree, BASEDIR);
+
+ talloc_free(tree);
+ talloc_free(mem_ctx);
+
+ return ret;
+}
+
+/**
+ * Test Durablity V2 Create Replay Detection on Single Channel.
+ * Hand in a different oplock level in the replay.
+ * Server responds with the handed in oplock level and
+ * corresponding durable status, but does not change the
+ * oplock level or durable status of the opened file.
+ */
+static bool test_replay_dhv2_oplock2(struct torture_context *tctx,
+ struct smb2_tree *tree)
+{
+ NTSTATUS status;
+ TALLOC_CTX *mem_ctx = talloc_new(tctx);
+ struct smb2_handle _h;
+ struct smb2_handle *h = NULL;
+ struct smb2_create io, ref1, ref2;
+ struct GUID create_guid = GUID_random();
+ bool ret = true;
+ const char *fname = BASEDIR "\\replay_dhv2_oplock2.dat";
+ struct smb2_transport *transport = tree->session->transport;
+ uint32_t share_capabilities;
+ bool share_is_so;
+
+ if (smbXcli_conn_protocol(transport->conn) < PROTOCOL_SMB3_00) {
+ torture_skip(tctx, "SMB 3.X Dialect family required for "
+ "replay tests\n");
+ }
+
+ share_capabilities = smb2cli_tcon_capabilities(tree->smbXcli);
+ share_is_so = share_capabilities & SMB2_SHARE_CAP_SCALEOUT;
+
+ ZERO_STRUCT(break_info);
+ break_info.tctx = tctx;
+ tree->session->transport->oplock.handler = torture_oplock_ack_handler;
+ tree->session->transport->oplock.private_data = tree;
+
+ torture_comment(tctx, "Replay of DurableHandleReqV2 on Single "
+ "Channel\n");
+ smb2_util_unlink(tree, fname);
+ status = torture_smb2_testdir(tree, BASEDIR, &_h);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ smb2_util_close(tree, _h);
+ CHECK_VAL(break_info.count, 0);
+
+ smb2_oplock_create_share(&io, fname,
+ smb2_util_share_access(""),
+ smb2_util_oplock_level("b"));
+ io.in.durable_open = false;
+ io.in.durable_open_v2 = true;
+ io.in.persistent_open = false;
+ io.in.create_guid = create_guid;
+ io.in.timeout = UINT32_MAX;
+
+ status = smb2_create(tree, mem_ctx, &io);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ ref1 = io;
+ _h = io.out.file.handle;
+ h = &_h;
+ CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
+ CHECK_VAL(io.out.durable_open, false);
+ if (share_is_so) {
+ CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("s"));
+ CHECK_VAL(io.out.durable_open_v2, false);
+ CHECK_VAL(io.out.timeout, 0);
+ } else {
+ CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
+ CHECK_VAL(io.out.durable_open_v2, true);
+ CHECK_VAL(io.out.timeout, io.in.timeout);
+ }
+
/*
- * See how server behaves if we change some of the Create params while
- * Replaying. Change Share Access and Oplock Level. It seems the server
- * does not care for change in these parameters. The server seems to
- * only care for the File Name and GUID
+ * Replay durable v2 create on single channel:
+ *
+ * Replay the create with a different oplock (none).
+ * The server replies with the requested oplock level
+ * and also only replies with durable handle based
+ * on whether it could have been granted based on
+ * the requested oplock type.
*/
smb2_oplock_create_share(&io, fname,
- smb2_util_share_access("RWD"),
+ smb2_util_share_access(""),
smb2_util_oplock_level(""));
io.in.durable_open = false;
io.in.durable_open_v2 = true;
@@ -378,9 +578,7 @@ static bool test_replay2(struct torture_context *tctx, struct smb2_tree *tree)
io.in.timeout = UINT32_MAX;
/*
- * The output will just react on the
- * input, but it doesn't change the oplock
- * or share access values on the existing open
+ * Adapt the response to the exepected values
*/
ref2 = ref1;
ref2.out.oplock_level = smb2_util_oplock_level("");
@@ -396,11 +594,17 @@ static bool test_replay2(struct torture_context *tctx, struct smb2_tree *tree)
CHECK_VAL(break_info.count, 0);
/*
- * This is a normal open, which triggers an oplock
- * break and still gets NT_STATUS_SHARING_VIOLATION
+ * Prove that the open file still has a batch oplock
+ * by breaking it with another open.
*/
- io = ref1;
- io.in.durable_open_v2 = false;
+ smb2_oplock_create_share(&io, fname,
+ smb2_util_share_access(""),
+ smb2_util_oplock_level("b"));
+ io.in.durable_open = false;
+ io.in.durable_open_v2 = true;
+ io.in.persistent_open = false;
+ io.in.create_guid = GUID_random();
+ io.in.timeout = UINT32_MAX;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
@@ -411,48 +615,133 @@ static bool test_replay2(struct torture_context *tctx, struct smb2_tree *tree)
ZERO_STRUCT(break_info);
}
- smb2_util_close(tree, *h);
- h = NULL;
- status = smb2_util_unlink(tree, fname);
- CHECK_STATUS(status, NT_STATUS_OK);
- CHECK_VAL(break_info.count, 0);
+done:
+ if (h != NULL) {
+ smb2_util_close(tree, *h);
+ }
+ smb2_deltree(tree, BASEDIR);
- /*
- * No Replay detection for regular Creates
- */
- perms = SEC_STD_SYNCHRONIZE | SEC_STD_READ_CONTROL | SEC_STD_DELETE |
- SEC_DIR_WRITE_ATTRIBUTE | SEC_DIR_READ_ATTRIBUTE |
- SEC_DIR_WRITE_EA | SEC_FILE_APPEND_DATA |
- SEC_FILE_WRITE_DATA;
+ talloc_free(tree);
+ talloc_free(mem_ctx);
- io = (struct smb2_create) {
- .in.desired_access = perms,
- .in.file_attributes = 0,
- .in.create_disposition = NTCREATEX_DISP_CREATE,
- .in.share_access = NTCREATEX_SHARE_ACCESS_DELETE,
- .in.create_options = 0x0,
- .in.fname = fname
- };
+ return ret;
+}
- status = smb2_create(tree, tctx, &io);
+/**
+ * Test Durablity V2 Create Replay Detection on Single Channel.
+ * Replay with a different share mode. The share mode of
+ * the opened file is not changed by this.
+ */
+static bool test_replay_dhv2_oplock3(struct torture_context *tctx,
+ struct smb2_tree *tree)
+{
+ NTSTATUS status;
+ TALLOC_CTX *mem_ctx = talloc_new(tctx);
+ struct smb2_handle _h;
+ struct smb2_handle *h = NULL;
+ struct smb2_create io, ref1;
+ struct GUID create_guid = GUID_random();
+ bool ret = true;
+ const char *fname = BASEDIR "\\replay_dhv2_oplock3.dat";
+ struct smb2_transport *transport = tree->session->transport;
+ uint32_t share_capabilities;
+ bool share_is_so;
+
+ if (smbXcli_conn_protocol(transport->conn) < PROTOCOL_SMB3_00) {
+ torture_skip(tctx, "SMB 3.X Dialect family required for "
+ "replay tests\n");
+ }
+
+ share_capabilities = smb2cli_tcon_capabilities(tree->smbXcli);
+ share_is_so = share_capabilities & SMB2_SHARE_CAP_SCALEOUT;
+
+ ZERO_STRUCT(break_info);
+ break_info.tctx = tctx;
+ tree->session->transport->oplock.handler = torture_oplock_ack_handler;
+ tree->session->transport->oplock.private_data = tree;
+
+ torture_comment(tctx, "Replay of DurableHandleReqV2 on Single "
+ "Channel\n");
+ smb2_util_unlink(tree, fname);
+ status = torture_smb2_testdir(tree, BASEDIR, &_h);
CHECK_STATUS(status, NT_STATUS_OK);
+ smb2_util_close(tree, _h);
CHECK_VAL(break_info.count, 0);
+
+ smb2_oplock_create_share(&io, fname,
+ smb2_util_share_access(""),
+ smb2_util_oplock_level("b"));
+ io.in.durable_open = false;
+ io.in.durable_open_v2 = true;
+ io.in.persistent_open = false;
+ io.in.create_guid = create_guid;
+ io.in.timeout = UINT32_MAX;
+
+ status = smb2_create(tree, mem_ctx, &io);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ ref1 = io;
_h = io.out.file.handle;
h = &_h;
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
+ CHECK_VAL(io.out.durable_open, false);
+ if (share_is_so) {
+ CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("s"));
+ CHECK_VAL(io.out.durable_open_v2, false);
+ CHECK_VAL(io.out.timeout, 0);
+ } else {
+ CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
+ CHECK_VAL(io.out.durable_open_v2, true);
+ CHECK_VAL(io.out.timeout, io.in.timeout);
+ }
- torture_comment(tctx, "No Replay Detection for regular Create\n");
/*
- * Now replay the same create
+ * Replay durable v2 create on single channel:
+ *
+ * Replay the create with a different share mode.
+ * The server replies with the requested share
+ * mode instead of that which is associated to
+ * the handle.
*/
+ smb2_oplock_create_share(&io, fname,
+ smb2_util_share_access("RWD"),
+ smb2_util_oplock_level("b"));
+ io.in.durable_open = false;
+ io.in.durable_open_v2 = true;
+ io.in.persistent_open = false;
+ io.in.create_guid = create_guid;
+ io.in.timeout = UINT32_MAX;
+
smb2cli_session_start_replay(tree->session->smbXcli);
- status = smb2_create(tree, tctx, &io);
- CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_COLLISION);
+ status = smb2_create(tree, mem_ctx, &io);
+ smb2cli_session_stop_replay(tree->session->smbXcli);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ CHECK_CREATE_OUT(&io, &ref1);
CHECK_VAL(break_info.count, 0);
-done:
- smb2cli_session_stop_replay(tree->session->smbXcli);
+ /*
+ * In order to prove that the different share mode in the
+ * replayed create had no effect on the open file handle,
+ * show that a new create yields NT_STATUS_SHARING_VIOLATION.
+ */
+ smb2_oplock_create_share(&io, fname,
+ smb2_util_share_access(""),
+ smb2_util_oplock_level("b"));
+ io.in.durable_open = false;
+ io.in.durable_open_v2 = true;
+ io.in.persistent_open = false;
+ io.in.create_guid = GUID_random();
+ io.in.timeout = UINT32_MAX;
+ status = smb2_create(tree, mem_ctx, &io);
+ CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
+ if (!share_is_so) {
+ CHECK_VAL(break_info.count, 1);
+ CHECK_HANDLE(&break_info.handle, &ref1.out.file.handle);
+ CHECK_VAL(break_info.level, smb2_util_oplock_level("s"));
+ ZERO_STRUCT(break_info);
+ }
+
+done:
if (h != NULL) {
smb2_util_close(tree, *h);
}
@@ -990,7 +1279,10 @@ struct torture_suite *torture_smb2_replay_init(void)
torture_suite_create(talloc_autofree_context(), "replay");
torture_suite_add_1smb2_test(suite, "replay_commands", test_replay_commands);
- torture_suite_add_1smb2_test(suite, "replay2", test_replay2);
+ torture_suite_add_1smb2_test(suite, "replay_regular", test_replay_regular);
+ torture_suite_add_1smb2_test(suite, "replay_dhv2_oplock1", test_replay_dhv2_oplock1);
+ torture_suite_add_1smb2_test(suite, "replay_dhv2_oplock2", test_replay_dhv2_oplock2);
+ torture_suite_add_1smb2_test(suite, "replay_dhv2_oplock3", test_replay_dhv2_oplock3);
torture_suite_add_1smb2_test(suite, "replay3", test_replay3);
torture_suite_add_1smb2_test(suite, "replay4", test_replay4);
torture_suite_add_1smb2_test(suite, "replay5", test_replay5);
--
2.5.0
From 21245d31a09afe386c4cee1465ce4bdc685cf33a Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Mon, 29 Feb 2016 19:00:42 +0100
Subject: [PATCH 07/16] torture:smb2:replay: extend CHECK_CREATE_OUT() to know
leases
Signed-off-by: Michael Adam <obnox at samba.org>
---
source4/torture/smb2/replay.c | 5 +++++
1 file changed, 5 insertions(+)
diff --git a/source4/torture/smb2/replay.c b/source4/torture/smb2/replay.c
index e79d3c9..123e558 100644
--- a/source4/torture/smb2/replay.c
+++ b/source4/torture/smb2/replay.c
@@ -85,6 +85,11 @@
__IO_OUT_VAL(__io1, __io2, persistent_open); \
__IO_OUT_VAL(__io1, __io2, timeout); \
__IO_OUT_VAL(__io1, __io2, blobs.num_blobs); \
+ if ((__io1)->out.oplock_level == SMB2_OPLOCK_LEVEL_LEASE) { \
+ __IO_OUT_VAL(__io1, __io2, lease_response.lease_state);\
+ __IO_OUT_VAL(__io1, __io2, lease_response.lease_key.data[0]);\
+ __IO_OUT_VAL(__io1, __io2, lease_response.lease_key.data[1]);\
+ } \
} while(0)
#define BASEDIR "replaytestdir"
--
2.5.0
From d3002a96ace9acfa5bb97eb247bb649cf88a6709 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Mon, 29 Feb 2016 18:23:04 +0100
Subject: [PATCH 08/16] torture:smb2: add replay_dhv2_lease1 test
This is a variant of the replay_dhv2_oplock1 test for leases
instead of for oplocks.
Signed-off-by: Michael Adam <obnox at samba.org>
---
selftest/knownfail | 1 +
source4/torture/smb2/replay.c | 139 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 140 insertions(+)
diff --git a/selftest/knownfail b/selftest/knownfail
index bd3151c..7dc64e4 100644
--- a/selftest/knownfail
+++ b/selftest/knownfail
@@ -207,6 +207,7 @@
^samba3.smb2.replay.replay_dhv2_oplock1
^samba3.smb2.replay.replay_dhv2_oplock2
^samba3.smb2.replay.replay_dhv2_oplock3
+^samba3.smb2.replay.replay_dhv2_lease1
^samba3.smb2.replay.replay3
^samba3.smb2.replay.replay4
^samba3.smb2.lock.*replay
diff --git a/source4/torture/smb2/replay.c b/source4/torture/smb2/replay.c
index 123e558..a1728cb 100644
--- a/source4/torture/smb2/replay.c
+++ b/source4/torture/smb2/replay.c
@@ -759,6 +759,144 @@ done:
}
/**
+ * Test durablity v2 create replay detection on single channel.
+ * Variant with leases instead of oplocks:
+ * - open a file with a rh lease
+ * - upgrade to a rwh lease with a second create
+ * - replay the first create.
+ * ==> it gets back the upgraded lease level
+ */
+static bool test_replay_dhv2_lease1(struct torture_context *tctx,
+ struct smb2_tree *tree)
+{
+ NTSTATUS status;
+ TALLOC_CTX *mem_ctx = talloc_new(tctx);
+ struct smb2_handle _h1;
+ struct smb2_handle *h1 = NULL;
+ struct smb2_handle _h2;
+ struct smb2_handle *h2 = NULL;
+ struct smb2_create io1, io2, ref1;
+ struct GUID create_guid = GUID_random();
+ bool ret = true;
+ const char *fname = BASEDIR "\\replay2_lease1.dat";
+ struct smb2_transport *transport = tree->session->transport;
+ uint32_t share_capabilities;
+ bool share_is_so;
+ uint32_t server_capabilities;
+ struct smb2_lease ls1, ls2;
+ uint64_t lease_key;
+
+ if (smbXcli_conn_protocol(transport->conn) < PROTOCOL_SMB3_00) {
+ torture_skip(tctx, "SMB 3.X Dialect family required for "
+ "replay tests\n");
+ }
+
+ server_capabilities = smb2cli_conn_server_capabilities(transport->conn);
+ if (!(server_capabilities & SMB2_CAP_LEASING)) {
+ torture_skip(tctx, "leases are not supported");
+ }
+
+ share_capabilities = smb2cli_tcon_capabilities(tree->smbXcli);
+ share_is_so = share_capabilities & SMB2_SHARE_CAP_SCALEOUT;
+
+ ZERO_STRUCT(break_info);
+ break_info.tctx = tctx;
+ tree->session->transport->oplock.handler = torture_oplock_ack_handler;
+ tree->session->transport->oplock.private_data = tree;
+
+ torture_comment(tctx, "Replay of DurableHandleReqV2 with Lease "
+ "on Single Channel\n");
+ smb2_util_unlink(tree, fname);
+ status = torture_smb2_testdir(tree, BASEDIR, &_h1);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ smb2_util_close(tree, _h1);
+ CHECK_VAL(break_info.count, 0);
+
+ lease_key = random();
+
+ smb2_lease_create(&io1, &ls1, false /* dir */, fname,
+ lease_key, smb2_util_lease_state("RH"));
+ io1.in.durable_open = false;
+ io1.in.durable_open_v2 = true;
+ io1.in.persistent_open = false;
+ io1.in.create_guid = create_guid;
+ io1.in.timeout = UINT32_MAX;
+
+ status = smb2_create(tree, mem_ctx, &io1);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ ref1 = io1;
+ _h1 = io1.out.file.handle;
+ h1 = &_h1;
+ CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
+ CHECK_VAL(io1.out.durable_open, false);
+ CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
+ CHECK_VAL(io1.out.lease_response.lease_key.data[0], lease_key);
+ CHECK_VAL(io1.out.lease_response.lease_key.data[1], ~lease_key);
+ if (share_is_so) {
+ CHECK_VAL(io1.out.lease_response.lease_state,
+ smb2_util_lease_state("R"));
+ CHECK_VAL(io1.out.durable_open_v2, false);
+ CHECK_VAL(io1.out.timeout, 0);
+ } else {
+ CHECK_VAL(io1.out.lease_response.lease_state,
+ smb2_util_lease_state("RH"));
+ CHECK_VAL(io1.out.durable_open_v2, true);
+ CHECK_VAL(io1.out.timeout, io1.in.timeout);
+ }
+
+ /*
+ * Upgrade the lease to RWH
+ */
+ smb2_lease_create(&io2, &ls2, false /* dir */, fname,
+ lease_key, smb2_util_lease_state("RHW"));
+ io2.in.durable_open = false;
+ io2.in.durable_open_v2 = true;
+ io2.in.persistent_open = false;
+ io2.in.create_guid = GUID_random(); /* new guid... */
+ io2.in.timeout = UINT32_MAX;
+
+ status = smb2_create(tree, mem_ctx, &io2);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ _h2 = io2.out.file.handle;
+ h2 = &_h2;
+
+ /*
+ * Replay Durable V2 Create on single channel.
+ * We get the io from open #1 but with the
+ * upgraded lease.
+ */
+
+ /* adapt expected lease in response */
+ if (!share_is_so) {
+ ref1.out.lease_response.lease_state =
+ smb2_util_lease_state("RHW");
+ }
+
+ smb2cli_session_start_replay(tree->session->smbXcli);
+ status = smb2_create(tree, mem_ctx, &io1);
+ smb2cli_session_stop_replay(tree->session->smbXcli);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ CHECK_CREATE_OUT(&io1, &ref1);
+ CHECK_VAL(break_info.count, 0);
+
+done:
+ smb2cli_session_stop_replay(tree->session->smbXcli);
+
+ if (h1 != NULL) {
+ smb2_util_close(tree, *h1);
+ }
+ if (h2 != NULL) {
+ smb2_util_close(tree, *h2);
+ }
+ smb2_deltree(tree, BASEDIR);
+
+ talloc_free(tree);
+ talloc_free(mem_ctx);
+
+ return ret;
+}
+
+/**
* Test Durablity V2 Create Replay Detection on Multi Channel
*/
static bool test_replay3(struct torture_context *tctx, struct smb2_tree *tree1)
@@ -1288,6 +1426,7 @@ struct torture_suite *torture_smb2_replay_init(void)
torture_suite_add_1smb2_test(suite, "replay_dhv2_oplock1", test_replay_dhv2_oplock1);
torture_suite_add_1smb2_test(suite, "replay_dhv2_oplock2", test_replay_dhv2_oplock2);
torture_suite_add_1smb2_test(suite, "replay_dhv2_oplock3", test_replay_dhv2_oplock3);
+ torture_suite_add_1smb2_test(suite, "replay_dhv2_lease1", test_replay_dhv2_lease1);
torture_suite_add_1smb2_test(suite, "replay3", test_replay3);
torture_suite_add_1smb2_test(suite, "replay4", test_replay4);
torture_suite_add_1smb2_test(suite, "replay5", test_replay5);
--
2.5.0
From d9ce73df32ca09d257ff444643da2a504439398f Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Mon, 29 Feb 2016 19:04:32 +0100
Subject: [PATCH 09/16] torture:smb2: add replay2_dhv2_lease2
Signed-off-by: Michael Adam <obnox at samba.org>
---
selftest/knownfail | 1 +
source4/torture/smb2/replay.c | 152 ++++++++++++++++++++++++++++++++++++++++++
2 files changed, 153 insertions(+)
diff --git a/selftest/knownfail b/selftest/knownfail
index 7dc64e4..16162e3 100644
--- a/selftest/knownfail
+++ b/selftest/knownfail
@@ -208,6 +208,7 @@
^samba3.smb2.replay.replay_dhv2_oplock2
^samba3.smb2.replay.replay_dhv2_oplock3
^samba3.smb2.replay.replay_dhv2_lease1
+^samba3.smb2.replay.replay_dhv2_lease2
^samba3.smb2.replay.replay3
^samba3.smb2.replay.replay4
^samba3.smb2.lock.*replay
diff --git a/source4/torture/smb2/replay.c b/source4/torture/smb2/replay.c
index a1728cb..cf31750 100644
--- a/source4/torture/smb2/replay.c
+++ b/source4/torture/smb2/replay.c
@@ -897,6 +897,157 @@ done:
}
/**
+ * Test durablity v2 create replay detection on single channel.
+ * Variant with leases instead of oplocks, where the
+ * replay does not specify the original lease level but
+ * just a "R" lease. This still gives the upgraded lease
+ * level in the reply.
+ * - open a file with a rh lease
+ * - upgrade to a rwh lease with a second create
+ * - replay the first create.
+ * ==> it gets back the upgraded lease level
+ */
+static bool test_replay_dhv2_lease2(struct torture_context *tctx,
+ struct smb2_tree *tree)
+{
+ NTSTATUS status;
+ TALLOC_CTX *mem_ctx = talloc_new(tctx);
+ struct smb2_handle _h1;
+ struct smb2_handle *h1 = NULL;
+ struct smb2_handle _h2;
+ struct smb2_handle *h2 = NULL;
+ struct smb2_create io1, io2, ref1;
+ struct GUID create_guid = GUID_random();
+ bool ret = true;
+ const char *fname = BASEDIR "\\replay2_lease2.dat";
+ struct smb2_transport *transport = tree->session->transport;
+ uint32_t share_capabilities;
+ bool share_is_so;
+ uint32_t server_capabilities;
+ struct smb2_lease ls1, ls2;
+ uint64_t lease_key;
+
+ if (smbXcli_conn_protocol(transport->conn) < PROTOCOL_SMB3_00) {
+ torture_skip(tctx, "SMB 3.X Dialect family required for "
+ "replay tests\n");
+ }
+
+ server_capabilities = smb2cli_conn_server_capabilities(transport->conn);
+ if (!(server_capabilities & SMB2_CAP_LEASING)) {
+ torture_skip(tctx, "leases are not supported");
+ }
+
+ share_capabilities = smb2cli_tcon_capabilities(tree->smbXcli);
+ share_is_so = share_capabilities & SMB2_SHARE_CAP_SCALEOUT;
+
+ ZERO_STRUCT(break_info);
+ break_info.tctx = tctx;
+ tree->session->transport->oplock.handler = torture_oplock_ack_handler;
+ tree->session->transport->oplock.private_data = tree;
+
+ torture_comment(tctx, "Replay of DurableHandleReqV2 with Lease "
+ "on Single Channel\n");
+ smb2_util_unlink(tree, fname);
+ status = torture_smb2_testdir(tree, BASEDIR, &_h1);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ smb2_util_close(tree, _h1);
+ CHECK_VAL(break_info.count, 0);
+
+ lease_key = random();
+
+ smb2_lease_create(&io1, &ls1, false /* dir */, fname,
+ lease_key, smb2_util_lease_state("RH"));
+ io1.in.durable_open = false;
+ io1.in.durable_open_v2 = true;
+ io1.in.persistent_open = false;
+ io1.in.create_guid = create_guid;
+ io1.in.timeout = UINT32_MAX;
+
+ status = smb2_create(tree, mem_ctx, &io1);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
+ CHECK_VAL(io1.out.durable_open, false);
+ CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
+ CHECK_VAL(io1.out.lease_response.lease_key.data[0], lease_key);
+ CHECK_VAL(io1.out.lease_response.lease_key.data[1], ~lease_key);
+ if (share_is_so) {
+ CHECK_VAL(io1.out.lease_response.lease_state,
+ smb2_util_lease_state("R"));
+ CHECK_VAL(io1.out.durable_open_v2, false);
+ CHECK_VAL(io1.out.timeout, 0);
+ } else {
+ CHECK_VAL(io1.out.lease_response.lease_state,
+ smb2_util_lease_state("RH"));
+ CHECK_VAL(io1.out.durable_open_v2, true);
+ CHECK_VAL(io1.out.timeout, io1.in.timeout);
+ }
+ ref1 = io1;
+ _h1 = io1.out.file.handle;
+ h1 = &_h1;
+
+ /*
+ * Upgrade the lease to RWH
+ */
+ smb2_lease_create(&io2, &ls2, false /* dir */, fname,
+ lease_key, smb2_util_lease_state("RHW"));
+ io2.in.durable_open = false;
+ io2.in.durable_open_v2 = true;
+ io2.in.persistent_open = false;
+ io2.in.create_guid = GUID_random(); /* new guid... */
+ io2.in.timeout = UINT32_MAX;
+
+ status = smb2_create(tree, mem_ctx, &io2);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ _h2 = io2.out.file.handle;
+ h2 = &_h2;
+
+ /*
+ * Replay Durable V2 Create on single channel.
+ * Changing the requested lease level to "R"
+ * does not change the response:
+ * We get the reply from open #1 but with the
+ * upgraded lease.
+ */
+
+ /* adapt the expected response */
+ if (!share_is_so) {
+ ref1.out.lease_response.lease_state =
+ smb2_util_lease_state("RHW");
+ }
+
+ smb2_lease_create(&io1, &ls1, false /* dir */, fname,
+ lease_key, smb2_util_lease_state("R"));
+ io1.in.durable_open = false;
+ io1.in.durable_open_v2 = true;
+ io1.in.persistent_open = false;
+ io1.in.create_guid = create_guid;
+ io1.in.timeout = UINT32_MAX;
+
+ smb2cli_session_start_replay(tree->session->smbXcli);
+ status = smb2_create(tree, mem_ctx, &io1);
+ smb2cli_session_stop_replay(tree->session->smbXcli);
+ CHECK_STATUS(status, NT_STATUS_OK);
+ CHECK_CREATE_OUT(&io1, &ref1);
+ CHECK_VAL(break_info.count, 0);
+
+done:
+ smb2cli_session_stop_replay(tree->session->smbXcli);
+
+ if (h1 != NULL) {
+ smb2_util_close(tree, *h1);
+ }
+ if (h2 != NULL) {
+ smb2_util_close(tree, *h2);
+ }
+ smb2_deltree(tree, BASEDIR);
+
+ talloc_free(tree);
+ talloc_free(mem_ctx);
+
+ return ret;
+}
+
+/**
* Test Durablity V2 Create Replay Detection on Multi Channel
*/
static bool test_replay3(struct torture_context *tctx, struct smb2_tree *tree1)
@@ -1427,6 +1578,7 @@ struct torture_suite *torture_smb2_replay_init(void)
torture_suite_add_1smb2_test(suite, "replay_dhv2_oplock2", test_replay_dhv2_oplock2);
torture_suite_add_1smb2_test(suite, "replay_dhv2_oplock3", test_replay_dhv2_oplock3);
torture_suite_add_1smb2_test(suite, "replay_dhv2_lease1", test_replay_dhv2_lease1);
+ torture_suite_add_1smb2_test(suite, "replay_dhv2_lease2", test_replay_dhv2_lease2);
torture_suite_add_1smb2_test(suite, "replay3", test_replay3);
torture_suite_add_1smb2_test(suite, "replay4", test_replay4);
torture_suite_add_1smb2_test(suite, "replay5", test_replay5);
--
2.5.0
From d0d6d5231c3dfe72d29b0bd825352c33717d44f5 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Wed, 24 Feb 2016 15:53:57 +0100
Subject: [PATCH 10/16] smbd:smb2: allow the REPLAY_OPERATION flag for SMB3+
requests
Pair-Programmed-With: Stefan Metzmacher <metze at samba.org>
Signed-off-by: Michael Adam <obnox at samba.org>
Signed-off-by: Stefan Metzmacher <metze at samba.org>
---
source3/smbd/smb2_server.c | 3 +++
1 file changed, 3 insertions(+)
diff --git a/source3/smbd/smb2_server.c b/source3/smbd/smb2_server.c
index ac922a1..68d637e 100644
--- a/source3/smbd/smb2_server.c
+++ b/source3/smbd/smb2_server.c
@@ -2225,6 +2225,9 @@ NTSTATUS smbd_smb2_request_dispatch(struct smbd_smb2_request *req)
if (opcode == SMB2_OP_CANCEL) {
allowed_flags |= SMB2_HDR_FLAG_ASYNC;
}
+ if (xconn->protocol >= PROTOCOL_SMB2_22) {
+ allowed_flags |= SMB2_HDR_FLAG_REPLAY_OPERATION;
+ }
if ((flags & ~allowed_flags) != 0) {
return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
}
--
2.5.0
From 91e342d056d7dddd0c312230aa2b129e16bcfeaf Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Fri, 26 Feb 2016 13:44:13 +0100
Subject: [PATCH 11/16] librpc:smbXsrv.idl: add flags to smbXsrv_open
These flags reflect the need for and state of the replay cache.
Signed-off-by: Michael Adam <obnox at samba.org>
---
source3/librpc/idl/smbXsrv.idl | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/source3/librpc/idl/smbXsrv.idl b/source3/librpc/idl/smbXsrv.idl
index fe86545..c55ca31 100644
--- a/source3/librpc/idl/smbXsrv.idl
+++ b/source3/librpc/idl/smbXsrv.idl
@@ -404,6 +404,11 @@ interface smbXsrv
/* open files */
+ typedef [public,bitmap8bit] bitmap {
+ SMBXSRV_OPEN_NEED_REPLAY_CACHE = 0x01,
+ SMBXSRV_OPEN_HAVE_REPLAY_CACHE = 0x02
+ } smbXsrv_open_flags;
+
typedef struct {
[ignore] db_record *db_rec;
server_id server_id;
@@ -463,6 +468,7 @@ interface smbXsrv
NTSTATUS status;
NTTIME idle_time;
[ignore] files_struct *compat;
+ smbXsrv_open_flags flags;
} smbXsrv_open;
typedef union {
--
2.5.0
From ecb1e3389efbcdeee3a46c3f5a741d438f60fe98 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Wed, 24 Feb 2016 00:23:15 +0100
Subject: [PATCH 12/16] smbXsrv:open: maintain a replay cache
This caches a map create_guid -> file_id, so that
a replayed create can find the already created
open again.
This is automatically deleted once the first use
of the file handle is happening (triggered by
the lookup for the file-id).
Signed-off-by: Michael Adam <obnox at samba.org>
---
source3/smbd/smbXsrv_open.c | 108 +++++++++++++++++++++++++++++++++++++++++++-
1 file changed, 106 insertions(+), 2 deletions(-)
diff --git a/source3/smbd/smbXsrv_open.c b/source3/smbd/smbXsrv_open.c
index ee35f2d..3c66f42 100644
--- a/source3/smbd/smbXsrv_open.c
+++ b/source3/smbd/smbXsrv_open.c
@@ -34,6 +34,7 @@
struct smbXsrv_open_table {
struct {
struct db_context *db_ctx;
+ struct db_context *replay_cache_db_ctx;
uint32_t lowest_id;
uint32_t highest_id;
uint32_t max_opens;
@@ -225,6 +226,11 @@ static NTSTATUS smbXsrv_open_table_init(struct smbXsrv_connection *conn,
TALLOC_FREE(table);
return NT_STATUS_NO_MEMORY;
}
+ table->local.replay_cache_db_ctx = db_open_rbt(table);
+ if (table->local.replay_cache_db_ctx == NULL) {
+ TALLOC_FREE(table);
+ return NT_STATUS_NO_MEMORY;
+ }
table->local.lowest_id = lowest_id;
table->local.highest_id = highest_id;
table->local.max_opens = max_opens;
@@ -928,6 +934,73 @@ uint32_t smbXsrv_open_hash(struct smbXsrv_open *_open)
return ret;
}
+static NTSTATUS smbXsrv_open_set_replay_cache(struct smbXsrv_open *op)
+{
+ struct GUID *create_guid;
+ struct GUID_txt_buf buf;
+ char *guid_string;
+ struct db_context *db = op->table->local.replay_cache_db_ctx;
+ NTSTATUS status;
+
+ if (!(op->flags & SMBXSRV_OPEN_NEED_REPLAY_CACHE)) {
+ return NT_STATUS_OK;
+ }
+
+ if (op->flags & SMBXSRV_OPEN_HAVE_REPLAY_CACHE) {
+ return NT_STATUS_OK;
+ }
+
+ create_guid = &op->global->create_guid;
+ if (GUID_all_zero(create_guid)) {
+ return NT_STATUS_OK;
+ }
+
+ guid_string = GUID_buf_string(create_guid, &buf);
+ if (guid_string == NULL) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ status = dbwrap_store_uint32_bystring(db, guid_string, op->local_id);
+
+ if (NT_STATUS_IS_OK(status)) {
+ op->flags |= SMBXSRV_OPEN_HAVE_REPLAY_CACHE;
+ op->flags &= ~SMBXSRV_OPEN_NEED_REPLAY_CACHE;
+ }
+
+ return status;
+}
+
+static NTSTATUS smbXsrv_open_clear_replay_cache(struct smbXsrv_open *op)
+{
+ struct GUID *create_guid;
+ struct GUID_txt_buf buf;
+ char *guid_string;
+ struct db_context *db = op->table->local.replay_cache_db_ctx;
+ NTSTATUS status;
+
+ if (!(op->flags & SMBXSRV_OPEN_HAVE_REPLAY_CACHE)) {
+ return NT_STATUS_OK;
+ }
+
+ create_guid = &op->global->create_guid;
+ if (GUID_all_zero(create_guid)) {
+ return NT_STATUS_OK;
+ }
+
+ guid_string = GUID_buf_string(create_guid, &buf);
+ if (guid_string == NULL) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ status = dbwrap_purge_bystring(db, guid_string);
+
+ if (NT_STATUS_IS_OK(status)) {
+ op->flags &= ~SMBXSRV_OPEN_HAVE_REPLAY_CACHE;
+ }
+
+ return status;
+}
+
NTSTATUS smbXsrv_open_update(struct smbXsrv_open *op)
{
struct smbXsrv_open_table *table = op->table;
@@ -957,6 +1030,13 @@ NTSTATUS smbXsrv_open_update(struct smbXsrv_open *op)
return status;
}
+ status = smbXsrv_open_set_replay_cache(op);
+ if (!NT_STATUS_IS_OK(status)) {
+ DBG_ERR("smbXsrv_open_set_replay_cache failed: %s\n",
+ nt_errstr(status));
+ return status;
+ }
+
if (CHECK_DEBUGLVL(10)) {
struct smbXsrv_openB open_blob;
@@ -980,8 +1060,14 @@ NTSTATUS smbXsrv_open_close(struct smbXsrv_open *op, NTTIME now)
NTSTATUS status;
NTSTATUS error = NT_STATUS_OK;
+ error = smbXsrv_open_clear_replay_cache(op);
+ if (!NT_STATUS_IS_OK(error)) {
+ DBG_ERR("smbXsrv_open_clear_replay_cache failed: %s\n",
+ nt_errstr(error));
+ }
+
if (op->table == NULL) {
- return NT_STATUS_OK;
+ return error;
}
table = op->table;
@@ -1157,6 +1243,7 @@ NTSTATUS smb2srv_open_lookup(struct smbXsrv_connection *conn,
uint64_t local_zeros = volatile_id & 0xFFFFFFFF00000000LLU;
uint32_t global_id = persistent_id & UINT32_MAX;
uint64_t global_zeros = persistent_id & 0xFFFFFFFF00000000LLU;
+ NTSTATUS status;
if (local_zeros != 0) {
return NT_STATUS_FILE_CLOSED;
@@ -1170,7 +1257,24 @@ NTSTATUS smb2srv_open_lookup(struct smbXsrv_connection *conn,
return NT_STATUS_FILE_CLOSED;
}
- return smbXsrv_open_local_lookup(table, local_id, global_id, now, _open);
+ status = smbXsrv_open_local_lookup(table, local_id, global_id, now,
+ _open);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ /*
+ * Clear the replay cache for this create_guid if it exists:
+ * This is based on the assumption that this lookup will be
+ * triggered by a client request using the file-id for lookup.
+ * Hence the client has proven that it has in fact seen the
+ * reply to its initial create call. So subsequent create replays
+ * should be treated as invalid. Hence the index for create_guid
+ * lookup needs to be removed.
+ */
+ status = smbXsrv_open_clear_replay_cache(*_open);
+
+ return status;
}
NTSTATUS smb2srv_open_recreate(struct smbXsrv_connection *conn,
--
2.5.0
From 2c77dec2d3c74f610f47dabc660afd82cd410b61 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Fri, 26 Feb 2016 13:53:25 +0100
Subject: [PATCH 13/16] smb2:create: create replay cache when request has a
create_guid
Signed-off-by: Michael Adam <obnox at samba.org>
---
source3/smbd/smb2_create.c | 10 ++++++++++
1 file changed, 10 insertions(+)
diff --git a/source3/smbd/smb2_create.c b/source3/smbd/smb2_create.c
index 7917d42..6f01c39 100644
--- a/source3/smbd/smb2_create.c
+++ b/source3/smbd/smb2_create.c
@@ -668,6 +668,7 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
struct smb2_lease lease;
struct smb2_lease *lease_ptr = NULL;
ssize_t lease_len = -1;
+ bool need_replay_cache = false;
#if 0
struct smb2_create_blob *svhdx = NULL;
#endif
@@ -804,6 +805,12 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
update_open = true;
/*
+ * And we need to create a cache for replaying the
+ * create.
+ */
+ need_replay_cache = true;
+
+ /*
* durable handle v2 request processed below
*/
durable_requested = true;
@@ -1154,6 +1161,9 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
if (update_open) {
op->global->create_guid = _create_guid;
+ if (need_replay_cache) {
+ op->flags |= SMBXSRV_OPEN_NEED_REPLAY_CACHE;
+ }
status = smbXsrv_open_update(op);
DEBUG(10, ("smb2_create_send: smbXsrv_open_update "
--
2.5.0
From f7ce0e306a322b6ccfe5134af87d304ec7ac06e5 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Sat, 27 Feb 2016 03:23:27 +0100
Subject: [PATCH 14/16] smbXsrv:open: add smb2srv_open_lookup_replay_cache()
A function to find an open from the replay cache,
based on the create_guid handed in.
Signed-off-by: Michael Adam <obnox at samba.org>
---
source3/smbd/globals.h | 4 ++++
source3/smbd/smbXsrv_open.c | 38 ++++++++++++++++++++++++++++++++++++++
2 files changed, 42 insertions(+)
diff --git a/source3/smbd/globals.h b/source3/smbd/globals.h
index 1ca1389..c843f5a 100644
--- a/source3/smbd/globals.h
+++ b/source3/smbd/globals.h
@@ -641,6 +641,10 @@ NTSTATUS smb2srv_open_lookup(struct smbXsrv_connection *conn,
uint64_t volatile_id,
NTTIME now,
struct smbXsrv_open **_open);
+NTSTATUS smb2srv_open_lookup_replay_cache(struct smbXsrv_connection *conn,
+ const struct GUID *create_guid,
+ NTTIME now,
+ struct smbXsrv_open **_open);
NTSTATUS smb2srv_open_recreate(struct smbXsrv_connection *conn,
struct auth_session_info *session_info,
uint64_t persistent_id,
diff --git a/source3/smbd/smbXsrv_open.c b/source3/smbd/smbXsrv_open.c
index 3c66f42..50e0280 100644
--- a/source3/smbd/smbXsrv_open.c
+++ b/source3/smbd/smbXsrv_open.c
@@ -1277,6 +1277,44 @@ NTSTATUS smb2srv_open_lookup(struct smbXsrv_connection *conn,
return status;
}
+NTSTATUS smb2srv_open_lookup_replay_cache(struct smbXsrv_connection *conn,
+ const struct GUID *create_guid,
+ NTTIME now, /* TODO: needed ? */
+ struct smbXsrv_open **_open)
+{
+ NTSTATUS status;
+ char *guid_string;
+ struct GUID_txt_buf buf;
+ uint32_t local_id = 0;
+ struct smbXsrv_open_table *table = conn->client->open_table;
+ struct db_context *db = table->local.replay_cache_db_ctx;
+
+ if (GUID_all_zero(create_guid)) {
+ return NT_STATUS_NOT_FOUND;
+ }
+
+ guid_string = GUID_buf_string(create_guid, &buf);
+ if (guid_string == NULL) {
+ return NT_STATUS_INVALID_PARAMETER;
+ }
+
+ status = dbwrap_fetch_uint32_bystring(db, guid_string, &local_id);
+ if (!NT_STATUS_IS_OK(status)) {
+ DBG_ERR("failed to fetch local_id from replay cache: %s\n",
+ nt_errstr(status));
+ return status;
+ }
+
+ status = smbXsrv_open_local_lookup(table, local_id, 0, /* global_id */
+ now, _open);
+ if (!NT_STATUS_IS_OK(status)) {
+ DBG_ERR("smbXsrv_open_local_lookup failed for local_id %u\n",
+ (unsigned)local_id);
+ }
+
+ return status;
+}
+
NTSTATUS smb2srv_open_recreate(struct smbXsrv_connection *conn,
struct auth_session_info *session_info,
uint64_t persistent_id,
--
2.5.0
From d46635307d596ef5456152df8ac0fc5f7d4c8f86 Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Mon, 29 Feb 2016 02:11:26 +0100
Subject: [PATCH 15/16] smbXsrv.idl: add create_action to smbXsrv_open
Needed for create replay.
Signed-off-by: Michael Adam <obnox at samba.org>
---
source3/librpc/idl/smbXsrv.idl | 1 +
1 file changed, 1 insertion(+)
diff --git a/source3/librpc/idl/smbXsrv.idl b/source3/librpc/idl/smbXsrv.idl
index c55ca31..4c6895a 100644
--- a/source3/librpc/idl/smbXsrv.idl
+++ b/source3/librpc/idl/smbXsrv.idl
@@ -469,6 +469,7 @@ interface smbXsrv
NTTIME idle_time;
[ignore] files_struct *compat;
smbXsrv_open_flags flags;
+ uint32 create_action;
} smbXsrv_open;
typedef union {
--
2.5.0
From fc80988d4b46d23d07bf3248d2b4d81df9ad59ee Mon Sep 17 00:00:00 2001
From: Michael Adam <obnox at samba.org>
Date: Sun, 28 Feb 2016 02:32:36 +0100
Subject: [PATCH 16/16] smbd:smb2: implement create replay
Signed-off-by: Michael Adam <obnox at samba.org>
---
selftest/knownfail | 8 ------
source3/smbd/smb2_create.c | 68 ++++++++++++++++++++++++++++++++++++++++++----
2 files changed, 62 insertions(+), 14 deletions(-)
diff --git a/selftest/knownfail b/selftest/knownfail
index 16162e3..9326083 100644
--- a/selftest/knownfail
+++ b/selftest/knownfail
@@ -202,14 +202,6 @@
^samba3.smb2.setinfo.setinfo
^samba3.smb2.session.*reauth5 # some special anonymous checks?
^samba3.smb2.compound.interim2 # wrong return code (STATUS_CANCELLED)
-^samba3.smb2.replay.replay_commands
-^samba3.smb2.replay.replay_regular
-^samba3.smb2.replay.replay_dhv2_oplock1
-^samba3.smb2.replay.replay_dhv2_oplock2
-^samba3.smb2.replay.replay_dhv2_oplock3
-^samba3.smb2.replay.replay_dhv2_lease1
-^samba3.smb2.replay.replay_dhv2_lease2
-^samba3.smb2.replay.replay3
^samba3.smb2.replay.replay4
^samba3.smb2.lock.*replay
^samba3.raw.session.*reauth2 # maybe fix this?
diff --git a/source3/smbd/smb2_create.c b/source3/smbd/smb2_create.c
index 6f01c39..bd64df7 100644
--- a/source3/smbd/smb2_create.c
+++ b/source3/smbd/smb2_create.c
@@ -475,6 +475,7 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
struct smb2_create_blob *dh2q = NULL;
struct smb2_create_blob *rqls = NULL;
struct smbXsrv_open *op = NULL;
+ bool replay_operation = false;
if(lp_fake_oplocks(SNUM(smb2req->tcon->compat))) {
requested_oplock_level = SMB2_OPLOCK_LEVEL_NONE;
@@ -779,6 +780,8 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
const uint8_t *p = dh2q->data.data;
uint32_t durable_v2_timeout = 0;
DATA_BLOB create_guid_blob;
+ const uint8_t *hdr;
+ uint32_t flags;
if (dh2q->data.length != 32) {
tevent_req_nterror(req, NT_STATUS_INVALID_PARAMETER);
@@ -823,6 +826,38 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
*/
durable_timeout_msec = (60*1000);
}
+
+ /*
+ * Check for replay operation.
+ * Only consider it when we have dh2q.
+ * If we do not have a replay operation, verify that
+ * the create_guid is not cached for replay.
+ */
+ hdr = SMBD_SMB2_IN_HDR_PTR(smb2req);
+ flags = IVAL(hdr, SMB2_HDR_FLAGS);
+ replay_operation =
+ !!(flags & SMB2_HDR_FLAG_REPLAY_OPERATION);
+
+ status = smb2srv_open_lookup_replay_cache(
+ smb2req->xconn, create_guid,
+ 0 /* now */, &op);
+
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
+ replay_operation = false;
+ } else if (tevent_req_nterror(req, status)) {
+ DBG_WARNING("smb2srv_open_lookup_replay_cache "
+ "failed: %s\n", nt_errstr(status));
+ return tevent_req_post(req, ev);
+ } else if (!replay_operation) {
+ /*
+ * If a create without replay operation flag
+ * is sent but with a create_guid that is
+ * currently in the replay cache -- fail.
+ */
+ status = NT_STATUS_DUPLICATE_OBJECTID;
+ (void)tevent_req_nterror(req, status);
+ return tevent_req_post(req, ev);
+ }
}
if (dhnc) {
@@ -930,9 +965,15 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
/*
* For the backend file open procedure, there are
- * two possible modes: durable_reconnect or not.
+ * three possible modes: replay operation (in which case
+ * there is nothing else to do), durable_reconnect or
+ * new open.
*/
- if (do_durable_reconnect) {
+ if (replay_operation) {
+ result = op->compat;
+ update_open = false;
+ info = op->create_action;
+ } else if (do_durable_reconnect) {
DATA_BLOB new_cookie = data_blob_null;
NTTIME now = timeval_to_nttime(&smb2req->request_time);
@@ -1142,7 +1183,7 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
}
}
- if (durable_requested &&
+ if (!replay_operation && durable_requested &&
(fsp_lease_type(result) & SMB2_LEASE_HANDLE))
{
status = SMB_VFS_DURABLE_COOKIE(result,
@@ -1152,7 +1193,8 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
op->global->backend_cookie = data_blob_null;
}
}
- if (op->global->backend_cookie.length > 0) {
+ if (!replay_operation && op->global->backend_cookie.length > 0)
+ {
update_open = true;
op->global->durable = true;
@@ -1189,7 +1231,18 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
}
}
- if (dh2q && op->global->durable) {
+ if (dh2q && op->global->durable &&
+ /*
+ * For replay operations, we return the dh2q blob
+ * in the case of oplocks not based on the state of
+ * the open, but on whether it could have been granted
+ * for the request data. In the case of leases instead,
+ * the state of the open is used...
+ */
+ (!replay_operation ||
+ in_oplock_level == SMB2_OPLOCK_LEVEL_BATCH ||
+ in_oplock_level == SMB2_OPLOCK_LEVEL_LEASE))
+ {
uint8_t p[8] = { 0, };
DATA_BLOB blob = data_blob_const(p, sizeof(p));
uint32_t durable_v2_response_flags = 0;
@@ -1261,7 +1314,9 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
smb2req->compat_chain_fsp = smb1req->chain_fsp;
- if(lp_fake_oplocks(SNUM(smb2req->tcon->compat))) {
+ if (replay_operation) {
+ state->out_oplock_level = in_oplock_level;
+ } else if (lp_fake_oplocks(SNUM(smb2req->tcon->compat))) {
state->out_oplock_level = in_oplock_level;
} else {
state->out_oplock_level = map_samba_oplock_levels_to_smb2(result->oplock_type);
@@ -1273,6 +1328,7 @@ static struct tevent_req *smbd_smb2_create_send(TALLOC_CTX *mem_ctx,
} else {
state->out_create_action = info;
}
+ op->create_action = state->out_create_action;
state->out_file_attributes = dos_mode(result->conn,
result->fsp_name);
--
2.5.0
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 198 bytes
Desc: not available
URL: <http://lists.samba.org/pipermail/samba-technical/attachments/20160301/16f67f4e/signature.sig>
More information about the samba-technical
mailing list