bool test_persistent_open_lease(struct torture_context *tctx,
struct smb2_tree *tree)
{
char fname[256];
bool ret = true;
uint32_t caps;
bool share_is_ca;
struct durable_open_vs_lease *table;
caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
if (!(caps & SMB2_CAP_LEASING)) {
torture_skip(tctx, "leases are not supported");
}
/* Choose a random name in case the state is left a little funky. */
snprintf(fname, 256, "persistent_open_lease_%s.dat", generate_random_str(tctx, 8));
share_is_ca = tree->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY;
if (share_is_ca) {
table = persistent_open_lease_ca_table;
} else {
table = durable_open_vs_lease_table;
}
ret = test_durable_v2_open_lease_table(tctx, tree, fname,
true, /* request_persistent */
table,
NUM_LEASE_OPEN_TESTS);
talloc_free(tree);
return ret;
}
static bool test_lease_upgrade2(struct torture_context *tctx,
struct smb2_tree *tree)
{
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle h, hnew;
NTSTATUS status;
struct smb2_create io;
struct smb2_lease ls;
const char *fname = "lease.dat";
bool ret = true;
int i;
uint32_t caps;
caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
if (!(caps & SMB2_CAP_LEASING)) {
torture_skip(tctx, "leases are not supported");
}
for (i = 0; i < NUM_UPGRADE_TESTS; i++) {
struct lease_upgrade2_test t = lease_upgrade2_tests[i];
smb2_util_unlink(tree, fname);
/* Grab a lease. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.initial));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, t.initial, true, LEASE1);
h = io.out.file.handle;
/* Upgrade. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.upgrade_to));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, t.expected, true, LEASE1);
hnew = io.out.file.handle;
smb2_util_close(tree, hnew);
smb2_util_close(tree, h);
}
done:
smb2_util_close(tree, h);
smb2_util_close(tree, hnew);
smb2_util_unlink(tree, fname);
talloc_free(mem_ctx);
return ret;
}
bool test_session_bind1(struct torture_context *tctx, struct smb2_tree *tree1)
{
const char *host = torture_setting_string(tctx, "host", NULL);
const char *share = torture_setting_string(tctx, "share", NULL);
struct cli_credentials *credentials = cmdline_credentials;
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
char fname[256];
struct smb2_handle _h1;
struct smb2_handle *h1 = NULL;
struct smb2_create io1;
union smb_fileinfo qfinfo;
bool ret = false;
struct smb2_tree *tree2 = NULL;
struct smb2_transport *transport1 = tree1->session->transport;
struct smb2_transport *transport2 = NULL;
struct smb2_session *session1_1 = tree1->session;
struct smb2_session *session1_2 = NULL;
struct smb2_session *session2_1 = NULL;
struct smb2_session *session2_2 = NULL;
uint32_t caps;
caps = smb2cli_conn_server_capabilities(transport1->conn);
if (!(caps & SMB2_CAP_MULTI_CHANNEL)) {
torture_skip(tctx, "server doesn't support SMB2_CAP_MULTI_CHANNEL\n");
}
/* Add some random component to the file name. */
snprintf(fname, sizeof(fname), "session_bind1_%s.dat",
generate_random_str(tctx, 8));
smb2_util_unlink(tree1, fname);
smb2_oplock_create_share(&io1, fname,
smb2_util_share_access(""),
smb2_util_oplock_level("b"));
status = smb2_create(tree1, mem_ctx, &io1);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_create failed");
_h1 = io1.out.file.handle;
h1 = &_h1;
CHECK_CREATED(tctx, &io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
torture_assert_int_equal(tctx, io1.out.oplock_level,
smb2_util_oplock_level("b"),
"oplock_level incorrect");
status = smb2_connect(tctx,
host,
lpcfg_smb_ports(tctx->lp_ctx),
share,
lpcfg_resolve_context(tctx->lp_ctx),
credentials,
&tree2,
tctx->ev,
&transport1->options,
lpcfg_socket_options(tctx->lp_ctx),
lpcfg_gensec_settings(tctx, tctx->lp_ctx)
);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_connect failed");
session2_2 = tree2->session;
transport2 = tree2->session->transport;
/*
* Now bind the 2nd transport connection to the 1st session
*/
session1_2 = smb2_session_channel(transport2,
lpcfg_gensec_settings(tctx, tctx->lp_ctx),
tree2,
session1_1);
torture_assert(tctx, session1_2 != NULL, "smb2_session_channel failed");
status = smb2_session_setup_spnego(session1_2,
cmdline_credentials,
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
/* use the 1st connection, 1st session */
ZERO_STRUCT(qfinfo);
qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
qfinfo.generic.in.file.handle = _h1;
tree1->session = session1_1;
status = smb2_getinfo_file(tree1, mem_ctx, &qfinfo);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_getinfo_file failed");
/* use the 2nd connection, 1st session */
ZERO_STRUCT(qfinfo);
qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
qfinfo.generic.in.file.handle = _h1;
tree1->session = session1_2;
status = smb2_getinfo_file(tree1, mem_ctx, &qfinfo);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_getinfo_file failed");
tree1->session = session1_1;
status = smb2_util_close(tree1, *h1);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_util_close failed");
h1 = NULL;
/*
* Now bind the 1st transport connection to the 2nd session
*/
session2_1 = smb2_session_channel(transport1,
lpcfg_gensec_settings(tctx, tctx->lp_ctx),
tree1,
session2_2);
torture_assert(tctx, session2_1 != NULL, "smb2_session_channel failed");
status = smb2_session_setup_spnego(session2_1,
cmdline_credentials,
0 /* previous_session_id */);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_session_setup_spnego failed");
tree2->session = session2_1;
status = smb2_util_unlink(tree2, fname);
torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
"smb2_util_unlink failed");
ret = true;
done:
talloc_free(tree2);
tree1->session = session1_1;
if (h1 != NULL) {
smb2_util_close(tree1, *h1);
}
smb2_util_unlink(tree1, fname);
talloc_free(tree1);
talloc_free(mem_ctx);
return ret;
}
/**
* lease_v2 variant of reopen2
* basic test for doing a durable open
* tcp disconnect, reconnect, do a durable reopen (succeeds)
*/
bool test_durable_v2_open_reopen2_lease_v2(struct torture_context *tctx,
struct smb2_tree *tree)
{
NTSTATUS status;
TALLOC_CTX *mem_ctx = talloc_new(tctx);
char fname[256];
struct smb2_handle _h;
struct smb2_handle *h = NULL;
struct smb2_create io;
struct GUID create_guid = GUID_random();
struct smb2_lease ls;
uint64_t lease_key;
bool ret = true;
struct smbcli_options options;
uint32_t caps;
caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
if (!(caps & SMB2_CAP_LEASING)) {
torture_skip(tctx, "leases are not supported");
}
options = tree->session->transport->options;
/* Choose a random name in case the state is left a little funky. */
snprintf(fname, 256, "durable_v2_open_reopen2_%s.dat",
generate_random_str(tctx, 8));
smb2_util_unlink(tree, fname);
lease_key = random();
smb2_lease_v2_create(&io, &ls, false /* dir */, fname,
lease_key, 0, /* parent lease key */
smb2_util_lease_state("RWH"), 0 /* lease epoch */);
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);
_h = io.out.file.handle;
h = &_h;
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.durable_open, false);
CHECK_VAL(io.out.durable_open_v2, true);
CHECK_VAL(io.out.persistent_open, false);
CHECK_VAL(io.out.timeout, io.in.timeout);
CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
CHECK_VAL(io.out.lease_response_v2.lease_key.data[0], lease_key);
CHECK_VAL(io.out.lease_response_v2.lease_key.data[1], ~lease_key);
/* disconnect, reconnect and then do durable reopen */
TALLOC_FREE(tree);
if (!torture_smb2_connection_ext(tctx, 0, &options, &tree)) {
torture_warning(tctx, "couldn't reconnect, bailing\n");
ret = false;
goto done;
}
/* a few failure tests: */
/*
* several attempts without lease attached:
* all fail with NT_STATUS_OBJECT_NAME_NOT_FOUND
* irrespective of file name provided
*/
ZERO_STRUCT(io);
io.in.fname = "";
io.in.durable_handle_v2 = h;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
ZERO_STRUCT(io);
io.in.fname = "__non_existing_fname__";
io.in.durable_handle_v2 = h;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
ZERO_STRUCT(io);
io.in.fname = fname;
io.in.durable_handle_v2 = h;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
/*
* attempt with lease provided, but
* with a changed lease key. => fails
*/
ZERO_STRUCT(io);
io.in.fname = fname;
io.in.durable_open_v2 = false;
io.in.durable_handle_v2 = h;
io.in.create_guid = create_guid;
io.in.lease_request_v2 = &ls;
io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
/* a wrong lease key lets the request fail */
ls.lease_key.data[0]++;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
/* restore the correct lease key */
ls.lease_key.data[0]--;
/*
* this last failing attempt is almost correct:
* only problem is: we use the wrong filename...
* Note that this gives INVALID_PARAMETER.
* This is different from oplocks!
*/
ZERO_STRUCT(io);
io.in.fname = "__non_existing_fname__";
io.in.durable_open_v2 = false;
io.in.durable_handle_v2 = h;
io.in.create_guid = create_guid;
io.in.lease_request_v2 = &ls;
io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
/*
* Now for a succeeding reconnect:
*/
ZERO_STRUCT(io);
io.in.fname = fname;
io.in.durable_open_v2 = false;
io.in.durable_handle_v2 = h;
io.in.create_guid = create_guid;
io.in.lease_request_v2 = &ls;
io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
/* the requested lease state is irrelevant */
ls.lease_state = smb2_util_lease_state("");
h = NULL;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.durable_open, false);
CHECK_VAL(io.out.durable_open_v2, false); /* no dh2q response blob */
CHECK_VAL(io.out.persistent_open, false);
CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
CHECK_VAL(io.out.lease_response_v2.lease_key.data[0], lease_key);
CHECK_VAL(io.out.lease_response_v2.lease_key.data[1], ~lease_key);
CHECK_VAL(io.out.lease_response_v2.lease_state,
smb2_util_lease_state("RWH"));
CHECK_VAL(io.out.lease_response_v2.lease_flags, 0);
CHECK_VAL(io.out.lease_response_v2.lease_duration, 0);
_h = io.out.file.handle;
h = &_h;
/* disconnect one more time */
TALLOC_FREE(tree);
if (!torture_smb2_connection_ext(tctx, 0, &options, &tree)) {
torture_warning(tctx, "couldn't reconnect, bailing\n");
ret = false;
goto done;
}
/*
* demonstrate that various parameters are ignored
* in the reconnect
*/
ZERO_STRUCT(io);
/*
* These are completely ignored by the server
*/
io.in.security_flags = 0x78;
io.in.oplock_level = 0x78;
io.in.impersonation_level = 0x12345678;
io.in.create_flags = 0x12345678;
io.in.reserved = 0x12345678;
io.in.desired_access = 0x12345678;
io.in.file_attributes = 0x12345678;
io.in.share_access = 0x12345678;
io.in.create_disposition = 0x12345678;
io.in.create_options = 0x12345678;
io.in.fname = "__non_existing_fname__";
/*
* only these are checked:
* - io.in.fname
* - io.in.durable_handle_v2,
* - io.in.create_guid
* - io.in.lease_request_v2->lease_key
*/
io.in.fname = fname;
io.in.durable_open_v2 = false;
io.in.durable_handle_v2 = h;
io.in.create_guid = create_guid;
io.in.lease_request_v2 = &ls;
/* the requested lease state is irrelevant */
ls.lease_state = smb2_util_lease_state("");
h = NULL;
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.durable_open, false);
CHECK_VAL(io.out.durable_open_v2, false); /* no dh2q response blob */
CHECK_VAL(io.out.persistent_open, false);
CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
CHECK_VAL(io.out.lease_response_v2.lease_key.data[0], lease_key);
CHECK_VAL(io.out.lease_response_v2.lease_key.data[1], ~lease_key);
CHECK_VAL(io.out.lease_response_v2.lease_state,
smb2_util_lease_state("RWH"));
CHECK_VAL(io.out.lease_response_v2.lease_flags, 0);
CHECK_VAL(io.out.lease_response_v2.lease_duration, 0);
_h = io.out.file.handle;
h = &_h;
done:
if (h != NULL) {
smb2_util_close(tree, *h);
}
smb2_util_unlink(tree, fname);
talloc_free(tree);
talloc_free(mem_ctx);
return ret;
}
static bool test_lease_multibreak(struct torture_context *tctx,
struct smb2_tree *tree)
{
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_create io;
struct smb2_lease ls;
struct smb2_handle h, h2, h3;
struct smb2_write w;
NTSTATUS status;
const char *fname = "lease.dat";
bool ret = true;
uint32_t caps;
caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
if (!(caps & SMB2_CAP_LEASING)) {
torture_skip(tctx, "leases are not supported");
}
tree->session->transport->lease.handler = torture_lease_handler;
tree->session->transport->lease.private_data = tree;
tree->session->transport->oplock.handler = torture_oplock_handler;
tree->session->transport->oplock.private_data = tree;
smb2_util_unlink(tree, fname);
ZERO_STRUCT(break_info);
/* Grab lease, upgrade to RHW .. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h = io.out.file.handle;
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RH", true, LEASE1);
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h2 = io.out.file.handle;
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RHW", true, LEASE1);
/* Contend with LEASE2. */
smb2_lease_create(&io, &ls, false, fname, LEASE2, smb2_util_lease_state("RHW"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h3 = io.out.file.handle;
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RH", true, LEASE2);
/* Verify that we were only sent one break. */
CHECK_BREAK_INFO("RHW", "RH", LEASE1);
/* Drop LEASE1 / LEASE2 */
status = smb2_util_close(tree, h);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_util_close(tree, h2);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_util_close(tree, h3);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(break_info);
/* Grab an R lease. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("R"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h = io.out.file.handle;
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "R", true, LEASE1);
/* Grab a level-II oplock. */
smb2_oplock_create(&io, fname, smb2_util_oplock_level("s"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h2 = io.out.file.handle;
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("s"));
break_info.held_oplock_level = io.out.oplock_level;
/* Verify no breaks. */
CHECK_VAL(break_info.count, 0);
CHECK_VAL(break_info.failures, 0);
/* Open for truncate, force a break. */
smb2_generic_create(&io, NULL, false, fname,
NTCREATEX_DISP_OVERWRITE_IF, smb2_util_oplock_level(""), 0, 0);
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h3 = io.out.file.handle;
CHECK_CREATED(&io, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(""));
break_info.held_oplock_level = io.out.oplock_level;
/* Sleep, use a write to clear the recv queue. */
smb_msleep(250);
ZERO_STRUCT(w);
w.in.file.handle = h3;
w.in.offset = 0;
w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
memset(w.in.data.data, 'o', w.in.data.length);
status = smb2_write(tree, &w);
CHECK_STATUS(status, NT_STATUS_OK);
/* Verify one oplock break, one lease break. */
CHECK_VAL(break_info.oplock_count, 1);
CHECK_VAL(break_info.oplock_failures, 0);
CHECK_VAL(break_info.oplock_level, smb2_util_oplock_level(""));
CHECK_BREAK_INFO("R", "", LEASE1);
done:
smb2_util_close(tree, h);
smb2_util_close(tree, h2);
smb2_util_close(tree, h3);
smb2_util_unlink(tree, fname);
talloc_free(mem_ctx);
return ret;
}
static bool test_lease_oplock(struct torture_context *tctx,
struct smb2_tree *tree)
{
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_create io;
struct smb2_lease ls;
struct smb2_handle h, h2;
NTSTATUS status;
const char *fname = "lease.dat";
bool ret = true;
int i;
uint32_t caps;
caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
if (!(caps & SMB2_CAP_LEASING)) {
torture_skip(tctx, "leases are not supported");
}
tree->session->transport->lease.handler = torture_lease_handler;
tree->session->transport->lease.private_data = tree;
tree->session->transport->oplock.handler = torture_oplock_handler;
tree->session->transport->oplock.private_data = tree;
smb2_util_unlink(tree, fname);
for (i = 0; i < NOPLOCK_RESULTS; i++) {
const char *held = oplock_results[i][0];
const char *contend = oplock_results[i][1];
const char *brokento = oplock_results[i][2];
const char *granted = oplock_results[i][3];
torture_comment(tctx, "Hold %s(%x), requesting %s(%x), "
"expecting break to %s(%x) and grant of %s(%x)\n",
held, smb2_util_lease_state(held), contend, smb2_util_oplock_level(contend),
brokento, smb2_util_lease_state(brokento), granted, smb2_util_oplock_level(granted));
ZERO_STRUCT(break_info);
/* Grab lease. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(held));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h = io.out.file.handle;
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, held, true, LEASE1);
/* Does an oplock contend the lease? */
smb2_oplock_create(&io, fname, smb2_util_oplock_level(contend));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h2 = io.out.file.handle;
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(granted));
break_info.held_oplock_level = io.out.oplock_level;
if (smb2_util_lease_state(held) != smb2_util_lease_state(brokento)) {
CHECK_BREAK_INFO(held, brokento, LEASE1);
} else {
CHECK_VAL(break_info.count, 0);
CHECK_VAL(break_info.failures, 0);
}
smb2_util_close(tree, h);
smb2_util_close(tree, h2);
status = smb2_util_unlink(tree, fname);
CHECK_STATUS(status, NT_STATUS_OK);
}
for (i = 0; i < NOPLOCK_RESULTS; i++) {
const char *held = oplock_results_2[i][0];
const char *contend = oplock_results_2[i][1];
const char *brokento = oplock_results_2[i][2];
const char *granted = oplock_results_2[i][3];
torture_comment(tctx, "Hold %s(%x), requesting %s(%x), "
"expecting break to %s(%x) and grant of %s(%x)\n",
held, smb2_util_oplock_level(held), contend, smb2_util_lease_state(contend),
brokento, smb2_util_oplock_level(brokento), granted, smb2_util_lease_state(granted));
ZERO_STRUCT(break_info);
/* Grab an oplock. */
smb2_oplock_create(&io, fname, smb2_util_oplock_level(held));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h = io.out.file.handle;
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(held));
break_info.held_oplock_level = io.out.oplock_level;
/* Grab lease. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(contend));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h2 = io.out.file.handle;
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, granted, true, LEASE1);
if (smb2_util_oplock_level(held) != smb2_util_oplock_level(brokento)) {
CHECK_VAL(break_info.oplock_count, 1);
CHECK_VAL(break_info.oplock_failures, 0);
CHECK_VAL(break_info.oplock_level, smb2_util_oplock_level(brokento));
break_info.held_oplock_level = break_info.oplock_level;
} else {
CHECK_VAL(break_info.oplock_count, 0);
CHECK_VAL(break_info.oplock_failures, 0);
}
smb2_util_close(tree, h);
smb2_util_close(tree, h2);
status = smb2_util_unlink(tree, fname);
CHECK_STATUS(status, NT_STATUS_OK);
}
done:
smb2_util_close(tree, h);
smb2_util_close(tree, h2);
smb2_util_unlink(tree, fname);
talloc_free(mem_ctx);
return ret;
}
static bool test_lease_upgrade3(struct torture_context *tctx,
struct smb2_tree *tree)
{
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_handle h, h2, hnew;
NTSTATUS status;
struct smb2_create io;
struct smb2_lease ls;
const char *fname = "upgrade3.dat";
bool ret = true;
int i;
uint32_t caps;
caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
if (!(caps & SMB2_CAP_LEASING)) {
torture_skip(tctx, "leases are not supported");
}
tree->session->transport->lease.handler = torture_lease_handler;
tree->session->transport->lease.private_data = tree;
smb2_util_unlink(tree, fname);
for (i = 0; i < NUM_UPGRADE3_TESTS; i++) {
struct lease_upgrade3_test t = lease_upgrade3_tests[i];
smb2_util_unlink(tree, fname);
ZERO_STRUCT(break_info);
/* grab first lease */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.held1));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, t.held1, true, LEASE1);
h = io.out.file.handle;
/* grab second lease */
smb2_lease_create(&io, &ls, false, fname, LEASE2, smb2_util_lease_state(t.held2));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, t.held2, true, LEASE2);
h2 = io.out.file.handle;
/* no break has happened */
CHECK_VAL(break_info.count, 0);
CHECK_VAL(break_info.failures, 0);
/* try to upgrade lease1 */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.upgrade_to));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, t.upgraded_to, true, LEASE1);
hnew = io.out.file.handle;
/* no break has happened */
CHECK_VAL(break_info.count, 0);
CHECK_VAL(break_info.failures, 0);
smb2_util_close(tree, hnew);
smb2_util_close(tree, h);
smb2_util_close(tree, h2);
}
done:
smb2_util_close(tree, h);
smb2_util_close(tree, hnew);
smb2_util_close(tree, h2);
smb2_util_unlink(tree, fname);
talloc_free(mem_ctx);
return ret;
}
static bool test_lease_upgrade(struct torture_context *tctx,
struct smb2_tree *tree)
{
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_create io;
struct smb2_lease ls;
struct smb2_handle h, hnew;
NTSTATUS status;
const char *fname = "lease.dat";
bool ret = true;
uint32_t caps;
caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
if (!(caps & SMB2_CAP_LEASING)) {
torture_skip(tctx, "leases are not supported");
}
smb2_util_unlink(tree, fname);
/* Grab a RH lease. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RH", true, LEASE1);
h = io.out.file.handle;
/* Upgrades (sidegrades?) to RW leave us with an RH. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RW"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RH", true, LEASE1);
hnew = io.out.file.handle;
smb2_util_close(tree, hnew);
/* Upgrade to RHW lease. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RHW", true, LEASE1);
hnew = io.out.file.handle;
smb2_util_close(tree, h);
h = hnew;
/* Attempt to downgrade - original lease state is maintained. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RHW", true, LEASE1);
hnew = io.out.file.handle;
smb2_util_close(tree, hnew);
done:
smb2_util_close(tree, h);
smb2_util_close(tree, hnew);
smb2_util_unlink(tree, fname);
talloc_free(mem_ctx);
return ret;
}
static bool test_lease_request(struct torture_context *tctx,
struct smb2_tree *tree)
{
TALLOC_CTX *mem_ctx = talloc_new(tctx);
struct smb2_create io;
struct smb2_lease ls;
struct smb2_handle h1, h2;
NTSTATUS status;
const char *fname = "lease.dat";
const char *fname2 = "lease2.dat";
const char *sname = "lease.dat:stream";
const char *dname = "lease.dir";
bool ret = true;
int i;
uint32_t caps;
caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
if (!(caps & SMB2_CAP_LEASING)) {
torture_skip(tctx, "leases are not supported");
}
smb2_util_unlink(tree, fname);
smb2_util_unlink(tree, fname2);
smb2_util_rmdir(tree, dname);
/* Win7 is happy to grant RHW leases on files. */
smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h1 = io.out.file.handle;
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RHW", true, LEASE1);
/* But will reject leases on directories. */
smb2_lease_create(&io, &ls, true, dname, LEASE2, smb2_util_lease_state("RHW"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_DIRECTORY);
CHECK_LEASE(&io, "", false, 0);
smb2_util_close(tree, io.out.file.handle);
/* Also rejects multiple files leased under the same key. */
smb2_lease_create(&io, &ls, true, fname2, LEASE1, smb2_util_lease_state("RHW"));
status = smb2_create(tree, mem_ctx, &io);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
/* And grants leases on streams (with separate leasekey). */
smb2_lease_create(&io, &ls, false, sname, LEASE2, smb2_util_lease_state("RHW"));
status = smb2_create(tree, mem_ctx, &io);
h2 = io.out.file.handle;
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, "RHW", true, LEASE2);
smb2_util_close(tree, h2);
smb2_util_close(tree, h1);
/* Now see what combos are actually granted. */
for (i = 0; i < NREQUEST_RESULTS; i++) {
torture_comment(tctx, "Requesting lease type %s(%x),"
" expecting %s(%x)\n",
request_results[i][0], smb2_util_lease_state(request_results[i][0]),
request_results[i][1], smb2_util_lease_state(request_results[i][1]));
smb2_lease_create(&io, &ls, false, fname, LEASE1,
smb2_util_lease_state(request_results[i][0]));
status = smb2_create(tree, mem_ctx, &io);
h2 = io.out.file.handle;
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
CHECK_LEASE(&io, request_results[i][1], true, LEASE1);
smb2_util_close(tree, io.out.file.handle);
}
done:
smb2_util_close(tree, h1);
smb2_util_close(tree, h2);
smb2_util_unlink(tree, fname);
smb2_util_unlink(tree, fname2);
smb2_util_rmdir(tree, dname);
talloc_free(mem_ctx);
return ret;
}
