sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-25 23:21:54 +03:00
Code
c761f9f7d2
samba-mirror/source4/torture/smb2/lock.c
Volker Lendecke beda6d3d48 torture: Fix uninitialized variables 
Signed-off-by: Volker Lendecke <vl@samba.org>
Reviewed-by: Jeremy Allison <jra@samba.org>

Autobuild-User(master): Jeremy Allison <jra@samba.org>
Autobuild-Date(master): Thu Oct 20 02:48:30 CEST 2016 on sn-devel-144
2016-10-20 02:48:30 +02:00

3156 lines
92 KiB
C
Raw Blame History

/*
Unix SMB/CIFS implementation.
SMB2 lock test suite
Copyright (C) Stefan Metzmacher 2006
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
#include "../libcli/smb/smbXcli_base.h"
#include "torture/torture.h"
#include "torture/smb2/proto.h"
#include "torture/util.h"
#include "lib/events/events.h"
#include "param/param.h"
#define CHECK_STATUS(status, correct) do { \
const char *_cmt = "(" __location__ ")"; \
torture_assert_ntstatus_equal_goto(torture,status,correct, \
ret,done,_cmt); \
} while (0)
#define CHECK_STATUS_CMT(status, correct, cmt) do { \
torture_assert_ntstatus_equal_goto(torture,status,correct, \
ret,done,cmt); \
} while (0)
#define CHECK_STATUS_CONT(status, correct) do { \
if (!NT_STATUS_EQUAL(status, correct)) { \
torture_result(torture, TORTURE_FAIL, \
"(%s) Incorrect status %s - should be %s\n", \
__location__, nt_errstr(status), nt_errstr(correct)); \
ret = false; \
}} while (0)
#define CHECK_VALUE(v, correct) do { \
const char *_cmt = "(" __location__ ")"; \
torture_assert_int_equal_goto(torture,v,correct,ret,done,_cmt); \
} while (0)
#define BASEDIR "testlock"
#define TARGET_SUPPORTS_INVALID_LOCK_RANGE(_tctx) \
(torture_setting_bool(_tctx, "invalid_lock_range_support", true))
#define TARGET_IS_W2K8(_tctx) (torture_setting_bool(_tctx, "w2k8", false))
#define WAIT_FOR_ASYNC_RESPONSE(req) \
while (!req->cancel.can_cancel && req->state <= SMB2_REQUEST_RECV) { \
if (tevent_loop_once(torture->ev) != 0) { \
break; \
} \
}
static bool test_valid_request(struct torture_context *torture,
struct smb2_tree *tree)
{
bool ret = true;
NTSTATUS status;
struct smb2_handle h;
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[2];
ZERO_STRUCT(buf);
status = torture_smb2_testfile(tree, "lock1.txt", &h);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.locks = el;
torture_comment(torture, "Test request with 0 locks.\n");
lck.in.lock_count = 0x0000;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0x0000000000000000;
el[0].length = 0x0000000000000000;
el[0].reserved = 0x0000000000000000;
el[0].flags = 0x00000000;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
lck.in.lock_count = 0x0000;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 0;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_SHARED;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 0;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_NONE;
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_OK);
torture_warning(torture, "Target has bug validating lock flags "
"parameter.\n");
} else {
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
}
torture_comment(torture, "Test >63-bit lock requests.\n");
lck.in.file.handle.data[0] +=1;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
lck.in.file.handle.data[0] -=1;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x123ab1;
lck.in.file.handle = h;
el[0].offset = UINT64_MAX;
el[0].length = UINT64_MAX;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
if (TARGET_SUPPORTS_INVALID_LOCK_RANGE(torture)) {
CHECK_STATUS(status, NT_STATUS_INVALID_LOCK_RANGE);
} else {
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
}
lck.in.lock_sequence = 0x123ab2;
status = smb2_lock(tree, &lck);
if (TARGET_SUPPORTS_INVALID_LOCK_RANGE(torture)) {
CHECK_STATUS(status, NT_STATUS_INVALID_LOCK_RANGE);
} else {
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
}
torture_comment(torture, "Test basic lock stacking.\n");
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x12345678;
lck.in.file.handle = h;
el[0].offset = UINT32_MAX;
el[0].length = UINT32_MAX;
el[0].reserved = 0x87654321;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
el[0].flags = SMB2_LOCK_FLAG_SHARED;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x87654321;
lck.in.file.handle = h;
el[0].offset = 0x00000000FFFFFFFF;
el[0].length = 0x00000000FFFFFFFF;
el[0].reserved = 0x1234567;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x1234567;
lck.in.file.handle = h;
el[0].offset = 0x00000000FFFFFFFF;
el[0].length = 0x00000000FFFFFFFF;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Test flags field permutations.\n");
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0;
lck.in.file.handle = h;
el[0].offset = 1;
el[0].length = 1;
el[0].reserved = 0x00000000;
el[0].flags = ~SMB2_LOCK_FLAG_ALL_MASK;
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_OK);
torture_warning(torture, "Target has bug validating lock flags "
"parameter.\n");
} else {
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
}
if (TARGET_IS_W2K8(torture)) {
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
}
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK |
SMB2_LOCK_FLAG_EXCLUSIVE;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK |
SMB2_LOCK_FLAG_SHARED;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_warning(torture, "Target has bug validating lock flags "
"parameter.\n");
} else {
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
}
torture_comment(torture, "Test return error when 2 locks are "
"requested\n");
lck.in.lock_count = 2;
lck.in.lock_sequence = 0;
lck.in.file.handle = h;
el[0].offset = 9999;
el[0].length = 1;
el[0].reserved = 0x00000000;
el[1].offset = 9999;
el[1].length = 1;
el[1].reserved = 0x00000000;
lck.in.lock_count = 2;
el[0].flags = 0;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
lck.in.lock_count = 2;
el[0].flags = SMB2_LOCK_FLAG_SHARED|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[1].flags = SMB2_LOCK_FLAG_SHARED;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
lck.in.lock_count = 2;
el[0].flags = 0;
el[1].flags = 0;
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_OK);
torture_warning(torture, "Target has bug validating lock flags "
"parameter.\n");
} else {
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
}
lck.in.lock_count = 2;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = 0;
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_OK);
torture_warning(torture, "Target has bug validating lock flags "
"parameter.\n");
} else {
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
}
lck.in.lock_count = 1;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
lck.in.lock_count = 1;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
lck.in.lock_count = 1;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
lck.in.lock_count = 1;
el[0].flags = SMB2_LOCK_FLAG_SHARED;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.lock_count = 2;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.lock_count = 1;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
done:
return ret;
}
struct test_lock_read_write_state {
const char *fname;
uint32_t lock_flags;
NTSTATUS write_h1_status;
NTSTATUS read_h1_status;
NTSTATUS write_h2_status;
NTSTATUS read_h2_status;
};
static bool test_lock_read_write(struct torture_context *torture,
struct smb2_tree *tree,
struct test_lock_read_write_state *s)
{
bool ret = true;
NTSTATUS status;
struct smb2_handle h1, h2;
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_create cr;
struct smb2_write wr;
struct smb2_read rd;
struct smb2_lock_element el[1];
lck.in.locks = el;
ZERO_STRUCT(buf);
status = torture_smb2_testfile(tree, s->fname, &h1);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_util_write(tree, h1, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h1;
el[0].offset = 0;
el[0].length = ARRAY_SIZE(buf)/2;
el[0].reserved = 0x00000000;
el[0].flags = s->lock_flags;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h1;
el[0].offset = ARRAY_SIZE(buf)/2;
el[0].length = ARRAY_SIZE(buf)/2;
el[0].reserved = 0x00000000;
el[0].flags = s->lock_flags;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
ZERO_STRUCT(cr);
cr.in.oplock_level = 0;
cr.in.desired_access = SEC_RIGHTS_FILE_ALL;
cr.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
cr.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
cr.in.share_access =
NTCREATEX_SHARE_ACCESS_DELETE|
NTCREATEX_SHARE_ACCESS_READ|
NTCREATEX_SHARE_ACCESS_WRITE;
cr.in.create_options = 0;
cr.in.fname = s->fname;
status = smb2_create(tree, tree, &cr);
CHECK_STATUS(status, NT_STATUS_OK);
h2 = cr.out.file.handle;
ZERO_STRUCT(wr);
wr.in.file.handle = h1;
wr.in.offset = ARRAY_SIZE(buf)/2;
wr.in.data = data_blob_const(buf, ARRAY_SIZE(buf)/2);
status = smb2_write(tree, &wr);
CHECK_STATUS(status, s->write_h1_status);
ZERO_STRUCT(rd);
rd.in.file.handle = h1;
rd.in.offset = ARRAY_SIZE(buf)/2;
rd.in.length = ARRAY_SIZE(buf)/2;
status = smb2_read(tree, tree, &rd);
CHECK_STATUS(status, s->read_h1_status);
ZERO_STRUCT(wr);
wr.in.file.handle = h2;
wr.in.offset = ARRAY_SIZE(buf)/2;
wr.in.data = data_blob_const(buf, ARRAY_SIZE(buf)/2);
status = smb2_write(tree, &wr);
CHECK_STATUS(status, s->write_h2_status);
ZERO_STRUCT(rd);
rd.in.file.handle = h2;
rd.in.offset = ARRAY_SIZE(buf)/2;
rd.in.length = ARRAY_SIZE(buf)/2;
status = smb2_read(tree, tree, &rd);
CHECK_STATUS(status, s->read_h2_status);
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h1;
el[0].offset = ARRAY_SIZE(buf)/2;
el[0].length = ARRAY_SIZE(buf)/2;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
ZERO_STRUCT(wr);
wr.in.file.handle = h2;
wr.in.offset = ARRAY_SIZE(buf)/2;
wr.in.data = data_blob_const(buf, ARRAY_SIZE(buf)/2);
status = smb2_write(tree, &wr);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(rd);
rd.in.file.handle = h2;
rd.in.offset = ARRAY_SIZE(buf)/2;
rd.in.length = ARRAY_SIZE(buf)/2;
status = smb2_read(tree, tree, &rd);
CHECK_STATUS(status, NT_STATUS_OK);
done:
return ret;
}
static bool test_lock_rw_none(struct torture_context *torture,
struct smb2_tree *tree)
{
struct test_lock_read_write_state s = {
.fname = "lock_rw_none.dat",
.lock_flags = SMB2_LOCK_FLAG_NONE,
.write_h1_status = NT_STATUS_FILE_LOCK_CONFLICT,
.read_h1_status = NT_STATUS_OK,
.write_h2_status = NT_STATUS_FILE_LOCK_CONFLICT,
.read_h2_status = NT_STATUS_OK,
};
if (!TARGET_IS_W2K8(torture)) {
torture_skip(torture, "RW-NONE tests the behavior of a "
"NONE-type lock, which is the same as a SHARED "
"lock but is granted due to a bug in W2K8. If "
"target is not W2K8 we skip this test.\n");
}
return test_lock_read_write(torture, tree, &s);
}
static bool test_lock_rw_shared(struct torture_context *torture,
struct smb2_tree *tree)
{
struct test_lock_read_write_state s = {
.fname = "lock_rw_shared.dat",
.lock_flags = SMB2_LOCK_FLAG_SHARED,
.write_h1_status = NT_STATUS_FILE_LOCK_CONFLICT,
.read_h1_status = NT_STATUS_OK,
.write_h2_status = NT_STATUS_FILE_LOCK_CONFLICT,
.read_h2_status = NT_STATUS_OK,
};
return test_lock_read_write(torture, tree, &s);
}
static bool test_lock_rw_exclusive(struct torture_context *torture,
struct smb2_tree *tree)
{
struct test_lock_read_write_state s = {
.fname = "lock_rw_exclusive.dat",
.lock_flags = SMB2_LOCK_FLAG_EXCLUSIVE,
.write_h1_status = NT_STATUS_OK,
.read_h1_status = NT_STATUS_OK,
.write_h2_status = NT_STATUS_FILE_LOCK_CONFLICT,
.read_h2_status = NT_STATUS_FILE_LOCK_CONFLICT,
};
return test_lock_read_write(torture, tree, &s);
}
static bool test_lock_auto_unlock(struct torture_context *torture,
struct smb2_tree *tree)
{
bool ret = true;
NTSTATUS status;
struct smb2_handle h;
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[1];
ZERO_STRUCT(buf);
status = torture_smb2_testfile(tree, "autounlock.txt", &h);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(lck);
ZERO_STRUCT(el[0]);
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 1;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_OK);
torture_warning(torture, "Target has \"pretty please\" bug. "
"A contending lock request on the same handle "
"unlocks the lock.\n");
} else {
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
}
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
done:
return ret;
}
/*
test different lock ranges and see if different handles conflict
*/
static bool test_lock(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[2];
const char *fname = BASEDIR "\\async.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
torture_comment(torture, "Trying 0/0 lock\n");
el[0].offset = 0x0000000000000000;
el[0].length = 0x0000000000000000;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Trying 0/1 lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = 0x0000000000000000;
el[0].length = 0x0000000000000001;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Trying 0xEEFFFFF lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = 0xEEFFFFFF;
el[0].length = 4000;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Trying 0xEF00000 lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = 0xEF000000;
el[0].length = 4000;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Trying (2^63 - 1)/1\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = 1;
el[0].offset <<= 63;
el[0].offset--;
el[0].length = 1;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Trying 2^63/1\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = 1;
el[0].offset <<= 63;
el[0].length = 1;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Trying max/0 lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = ~0;
el[0].length = 0;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Trying max/1 lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = ~0;
el[0].length = 1;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Trying max/2 lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = ~0;
el[0].length = 2;
status = smb2_lock(tree, &lck);
if (TARGET_SUPPORTS_INVALID_LOCK_RANGE(torture)) {
CHECK_STATUS(status, NT_STATUS_INVALID_LOCK_RANGE);
} else {
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
}
torture_comment(torture, "Trying wrong handle unlock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[0].offset = 10001;
el[0].length = 40002;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
lck.in.file.handle = h;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/*
test SMB2 LOCK async operation
*/
static bool test_async(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[2];
struct smb2_request *req = NULL;
const char *fname = BASEDIR "\\async.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 100;
el[0].length = 50;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
torture_comment(torture, " Acquire first lock\n");
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Second lock should pend on first\n");
lck.in.file.handle = h2;
req = smb2_lock_send(tree, &lck);
WAIT_FOR_ASYNC_RESPONSE(req);
torture_comment(torture, " Unlock first lock\n");
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Second lock should now succeed\n");
lck.in.file.handle = h2;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
status = smb2_lock_recv(req, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/*
test SMB2 LOCK Cancel operation
*/
static bool test_cancel(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[2];
struct smb2_request *req = NULL;
const char *fname = BASEDIR "\\cancel.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 100;
el[0].length = 10;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
torture_comment(torture, "Testing basic cancel\n");
torture_comment(torture, " Acquire first lock\n");
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Second lock should pend on first\n");
lck.in.file.handle = h2;
req = smb2_lock_send(tree, &lck);
WAIT_FOR_ASYNC_RESPONSE(req);
torture_comment(torture, " Cancel the second lock\n");
smb2_cancel(req);
lck.in.file.handle = h2;
status = smb2_lock_recv(req, &lck);
CHECK_STATUS(status, NT_STATUS_CANCELLED);
torture_comment(torture, " Unlock first lock\n");
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing cancel by unlock\n");
torture_comment(torture, " Acquire first lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Second lock should pend on first\n");
lck.in.file.handle = h2;
req = smb2_lock_send(tree, &lck);
WAIT_FOR_ASYNC_RESPONSE(req);
torture_comment(torture, " Attempt to unlock pending second lock\n");
lck.in.file.handle = h2;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, " Now cancel the second lock\n");
smb2_cancel(req);
lck.in.file.handle = h2;
status = smb2_lock_recv(req, &lck);
CHECK_STATUS(status, NT_STATUS_CANCELLED);
torture_comment(torture, " Unlock first lock\n");
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing cancel by close\n");
torture_comment(torture, " Acquire first lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Second lock should pend on first\n");
lck.in.file.handle = h2;
req = smb2_lock_send(tree, &lck);
WAIT_FOR_ASYNC_RESPONSE(req);
torture_comment(torture, " Close the second lock handle\n");
smb2_util_close(tree, h2);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Check pending lock reply\n");
status = smb2_lock_recv(req, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, " Unlock first lock\n");
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/*
test SMB2 LOCK Cancel by tree disconnect
*/
static bool test_cancel_tdis(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[2];
struct smb2_request *req = NULL;
const char *fname = BASEDIR "\\cancel_tdis.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 100;
el[0].length = 10;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
torture_comment(torture, "Testing cancel by tree disconnect\n");
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Acquire first lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Second lock should pend on first\n");
lck.in.file.handle = h2;
req = smb2_lock_send(tree, &lck);
WAIT_FOR_ASYNC_RESPONSE(req);
torture_comment(torture, " Disconnect the tree\n");
smb2_tdis(tree);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Check pending lock reply\n");
status = smb2_lock_recv(req, &lck);
if (!NT_STATUS_EQUAL(status, NT_STATUS_RANGE_NOT_LOCKED)) {
/*
* The status depends on the server internals
* the order in which the files are closed
* by smb2_tdis().
*/
CHECK_STATUS(status, NT_STATUS_OK);
}
torture_comment(torture, " Attempt to unlock first lock\n");
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
/*
* Most Windows versions have a strange order to
* verify the session id, tree id and file id.
* (They should be checked in that order, but windows
* seems to check the file id before the others).
*/
if (!NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_NAME_DELETED)) {
CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
}
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/*
test SMB2 LOCK Cancel by user logoff
*/
static bool test_cancel_logoff(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[2];
struct smb2_request *req = NULL;
const char *fname = BASEDIR "\\cancel_logoff.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 100;
el[0].length = 10;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
torture_comment(torture, "Testing cancel by ulogoff\n");
torture_comment(torture, " Acquire first lock\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " Second lock should pend on first\n");
lck.in.file.handle = h2;
req = smb2_lock_send(tree, &lck);
WAIT_FOR_ASYNC_RESPONSE(req);
torture_comment(torture, " Logoff user\n");
smb2_logoff(tree->session);
torture_comment(torture, " Check pending lock reply\n");
status = smb2_lock_recv(req, &lck);
if (!NT_STATUS_EQUAL(status, NT_STATUS_RANGE_NOT_LOCKED)) {
/*
* The status depends on the server internals
* the order in which the files are closed
* by smb2_logoff().
*/
CHECK_STATUS(status, NT_STATUS_OK);
}
torture_comment(torture, " Attempt to unlock first lock\n");
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
/*
* Most Windows versions have a strange order to
* verify the session id, tree id and file id.
* (They should be checked in that order, but windows
* seems to check the file id before the others).
*/
if (!NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
}
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/*
* Test NT_STATUS_LOCK_NOT_GRANTED vs. NT_STATUS_FILE_LOCK_CONFLICT
*
* The SMBv1 protocol returns a different error code on lock acquisition
* failure depending on a number of parameters, including what error code
* was returned to the previous failure.
*
* SMBv2 has cleaned up these semantics and should always return
* NT_STATUS_LOCK_NOT_GRANTED to failed lock requests, and
* NT_STATUS_FILE_LOCK_CONFLICT to failed read/write requests due to a lock
* being held on that range.
*/
static bool test_errorcode(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[2];
const char *fname = BASEDIR "\\errorcode.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 100;
el[0].length = 10;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
torture_comment(torture, "Testing LOCK_NOT_GRANTED vs. "
"FILE_LOCK_CONFLICT\n");
if (TARGET_IS_W2K8(torture)) {
torture_result(torture, TORTURE_SKIP,
"Target has \"pretty please\" bug. A contending lock "
"request on the same handle unlocks the lock.");
goto done;
}
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Demonstrate that the first conflicting lock on each handle gives
* LOCK_NOT_GRANTED. */
lck.in.file.handle = h;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* Demonstrate that each following conflict also gives
* LOCK_NOT_GRANTED */
lck.in.file.handle = h;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* Demonstrate that the smbpid doesn't matter */
lck.in.file.handle = h;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* Demonstrate that a 0-byte lock inside the locked range still
* gives the same error. */
el[0].offset = 102;
el[0].length = 0;
lck.in.file.handle = h;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* Demonstrate that a lock inside the locked range still gives the
* same error. */
el[0].offset = 102;
el[0].length = 5;
lck.in.file.handle = h;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.file.handle = h2;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/**
* Tests zero byte locks.
*/
struct double_lock_test {
struct smb2_lock_element lock1;
struct smb2_lock_element lock2;
NTSTATUS status;
};
static struct double_lock_test zero_byte_tests[] = {
/* {offset, count, reserved, flags},
* {offset, count, reserved, flags},
* status */
/** First, takes a zero byte lock at offset 10. Then:
* - Taking 0 byte lock at 10 should succeed.
* - Taking 1 byte locks at 9,10,11 should succeed.
* - Taking 2 byte lock at 9 should fail.
* - Taking 2 byte lock at 10 should succeed.
* - Taking 3 byte lock at 9 should fail.
*/
{{10, 0, 0, 0}, {10, 0, 0, 0}, NT_STATUS_OK},
{{10, 0, 0, 0}, {9, 1, 0, 0}, NT_STATUS_OK},
{{10, 0, 0, 0}, {10, 1, 0, 0}, NT_STATUS_OK},
{{10, 0, 0, 0}, {11, 1, 0, 0}, NT_STATUS_OK},
{{10, 0, 0, 0}, {9, 2, 0, 0}, NT_STATUS_LOCK_NOT_GRANTED},
{{10, 0, 0, 0}, {10, 2, 0, 0}, NT_STATUS_OK},
{{10, 0, 0, 0}, {9, 3, 0, 0}, NT_STATUS_LOCK_NOT_GRANTED},
/** Same, but opposite order. */
{{10, 0, 0, 0}, {10, 0, 0, 0}, NT_STATUS_OK},
{{9, 1, 0, 0}, {10, 0, 0, 0}, NT_STATUS_OK},
{{10, 1, 0, 0}, {10, 0, 0, 0}, NT_STATUS_OK},
{{11, 1, 0, 0}, {10, 0, 0, 0}, NT_STATUS_OK},
{{9, 2, 0, 0}, {10, 0, 0, 0}, NT_STATUS_LOCK_NOT_GRANTED},
{{10, 2, 0, 0}, {10, 0, 0, 0}, NT_STATUS_OK},
{{9, 3, 0, 0}, {10, 0, 0, 0}, NT_STATUS_LOCK_NOT_GRANTED},
/** Zero zero case. */
{{0, 0, 0, 0}, {0, 0, 0, 0}, NT_STATUS_OK},
};
static bool test_zerobytelength(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
int i;
const char *fname = BASEDIR "\\zero.txt";
torture_comment(torture, "Testing zero length byte range locks:\n");
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
/* Setup initial parameters */
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
/* Try every combination of locks in zero_byte_tests, using the same
* handle for both locks. The first lock is assumed to succeed. The
* second lock may contend, depending on the expected status. */
for (i = 0; i < ARRAY_SIZE(zero_byte_tests); i++) {
torture_comment(torture,
" ... {%llu, %llu} + {%llu, %llu} = %s\n",
(unsigned long long) zero_byte_tests[i].lock1.offset,
(unsigned long long) zero_byte_tests[i].lock1.length,
(unsigned long long) zero_byte_tests[i].lock2.offset,
(unsigned long long) zero_byte_tests[i].lock2.length,
nt_errstr(zero_byte_tests[i].status));
/* Lock both locks. */
lck.in.locks = &zero_byte_tests[i].lock1;
lck.in.locks[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.locks = &zero_byte_tests[i].lock2;
lck.in.locks[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CONT(status, zero_byte_tests[i].status);
/* Unlock both locks in reverse order. */
lck.in.locks[0].flags = SMB2_LOCK_FLAG_UNLOCK;
if (NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
}
lck.in.locks = &zero_byte_tests[i].lock1;
lck.in.locks[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
}
/* Try every combination of locks in zero_byte_tests, using two
* different handles. */
for (i = 0; i < ARRAY_SIZE(zero_byte_tests); i++) {
torture_comment(torture,
" ... {%llu, %llu} + {%llu, %llu} = %s\n",
(unsigned long long) zero_byte_tests[i].lock1.offset,
(unsigned long long) zero_byte_tests[i].lock1.length,
(unsigned long long) zero_byte_tests[i].lock2.offset,
(unsigned long long) zero_byte_tests[i].lock2.length,
nt_errstr(zero_byte_tests[i].status));
/* Lock both locks. */
lck.in.file.handle = h;
lck.in.locks = &zero_byte_tests[i].lock1;
lck.in.locks[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
lck.in.locks = &zero_byte_tests[i].lock2;
lck.in.locks[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CONT(status, zero_byte_tests[i].status);
/* Unlock both locks in reverse order. */
lck.in.file.handle = h2;
lck.in.locks[0].flags = SMB2_LOCK_FLAG_UNLOCK;
if (NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
}
lck.in.file.handle = h;
lck.in.locks = &zero_byte_tests[i].lock1;
lck.in.locks[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
}
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
static bool test_zerobyteread(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[1];
struct smb2_read rd;
const char *fname = BASEDIR "\\zerobyteread.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
/* Setup initial parameters */
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
ZERO_STRUCT(rd);
rd.in.file.handle = h2;
torture_comment(torture, "Testing zero byte read on lock range:\n");
/* Take an exclusive lock */
torture_comment(torture, " taking exclusive lock.\n");
el[0].offset = 0;
el[0].length = 10;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
/* Try a zero byte read */
torture_comment(torture, " reading 0 bytes.\n");
rd.in.offset = 5;
rd.in.length = 0;
status = smb2_read(tree, tree, &rd);
torture_assert_int_equal_goto(torture, rd.out.data.length, 0, ret, done,
"zero byte read did not return 0 bytes");
CHECK_STATUS(status, NT_STATUS_OK);
/* Unlock lock */
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
torture_comment(torture, "Testing zero byte read on zero byte lock "
"range:\n");
/* Take an exclusive lock */
torture_comment(torture, " taking exclusive 0-byte lock.\n");
el[0].offset = 5;
el[0].length = 0;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
/* Try a zero byte read before the lock */
torture_comment(torture, " reading 0 bytes before the lock.\n");
rd.in.offset = 4;
rd.in.length = 0;
status = smb2_read(tree, tree, &rd);
torture_assert_int_equal_goto(torture, rd.out.data.length, 0, ret, done,
"zero byte read did not return 0 bytes");
CHECK_STATUS(status, NT_STATUS_OK);
/* Try a zero byte read on the lock */
torture_comment(torture, " reading 0 bytes on the lock.\n");
rd.in.offset = 5;
rd.in.length = 0;
status = smb2_read(tree, tree, &rd);
torture_assert_int_equal_goto(torture, rd.out.data.length, 0, ret, done,
"zero byte read did not return 0 bytes");
CHECK_STATUS(status, NT_STATUS_OK);
/* Try a zero byte read after the lock */
torture_comment(torture, " reading 0 bytes after the lock.\n");
rd.in.offset = 6;
rd.in.length = 0;
status = smb2_read(tree, tree, &rd);
torture_assert_int_equal_goto(torture, rd.out.data.length, 0, ret, done,
"zero byte read did not return 0 bytes");
CHECK_STATUS(status, NT_STATUS_OK);
/* Unlock lock */
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(lck.out.reserved, 0);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
static bool test_unlock(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el1[1];
struct smb2_lock_element el2[1];
const char *fname = BASEDIR "\\unlock.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
/* Setup initial parameters */
lck.in.locks = el1;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
el1[0].offset = 0;
el1[0].length = 10;
el1[0].reserved = 0x00000000;
/* Take exclusive lock, then unlock it with a shared-unlock call. */
torture_comment(torture, "Testing unlock exclusive with shared\n");
torture_comment(torture, " taking exclusive lock.\n");
lck.in.file.handle = h;
el1[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " try to unlock the exclusive with a shared "
"unlock call.\n");
el1[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
torture_comment(torture, " try shared lock on h2, to test the "
"unlock.\n");
lck.in.file.handle = h2;
el1[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
torture_comment(torture, " unlock the exclusive lock\n");
lck.in.file.handle = h;
el1[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Unlock a shared lock with an exclusive-unlock call. */
torture_comment(torture, "Testing unlock shared with exclusive\n");
torture_comment(torture, " taking shared lock.\n");
lck.in.file.handle = h;
el1[0].flags = SMB2_LOCK_FLAG_SHARED;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, " try to unlock the shared with an exclusive "
"unlock call.\n");
el1[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
torture_comment(torture, " try exclusive lock on h2, to test the "
"unlock.\n");
lck.in.file.handle = h2;
el1[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
torture_comment(torture, " unlock the exclusive lock\n");
lck.in.file.handle = h;
el1[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Test unlocking of stacked 0-byte locks. SMB2 0-byte lock behavior
* should be the same as >0-byte behavior. Exclusive locks should be
* unlocked before shared. */
torture_comment(torture, "Test unlocking stacked 0-byte locks\n");
lck.in.locks = el1;
lck.in.file.handle = h;
el1[0].offset = 10;
el1[0].length = 0;
el1[0].reserved = 0x00000000;
el2[0].offset = 5;
el2[0].length = 10;
el2[0].reserved = 0x00000000;
/* lock 0-byte exclusive */
el1[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* lock 0-byte shared */
el1[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* test contention */
lck.in.locks = el2;
lck.in.file.handle = h2;
el2[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.locks = el2;
lck.in.file.handle = h2;
el2[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* unlock */
lck.in.locks = el1;
lck.in.file.handle = h;
el1[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* test - can we take a shared lock? */
lck.in.locks = el2;
lck.in.file.handle = h2;
el2[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el2[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* cleanup */
lck.in.locks = el1;
lck.in.file.handle = h;
el1[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Test unlocking of stacked exclusive, shared locks. Exclusive
* should be unlocked before any shared. */
torture_comment(torture, "Test unlocking stacked exclusive/shared "
"locks\n");
lck.in.locks = el1;
lck.in.file.handle = h;
el1[0].offset = 10;
el1[0].length = 10;
el1[0].reserved = 0x00000000;
el2[0].offset = 5;
el2[0].length = 10;
el2[0].reserved = 0x00000000;
/* lock exclusive */
el1[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* lock shared */
el1[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* test contention */
lck.in.locks = el2;
lck.in.file.handle = h2;
el2[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
lck.in.locks = el2;
lck.in.file.handle = h2;
el2[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* unlock */
lck.in.locks = el1;
lck.in.file.handle = h;
el1[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* test - can we take a shared lock? */
lck.in.locks = el2;
lck.in.file.handle = h2;
el2[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el2[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* cleanup */
lck.in.locks = el1;
lck.in.file.handle = h;
el1[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
static bool test_multiple_unlock(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h;
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[2];
const char *fname = BASEDIR "\\unlock_multiple.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing multiple unlocks:\n");
/* Setup initial parameters */
lck.in.lock_count = 0x0002;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 10;
el[0].reserved = 0x00000000;
el[1].offset = 10;
el[1].length = 10;
el[1].reserved = 0x00000000;
/* Test1: Acquire second lock, but not first. */
torture_comment(torture, " unlock 2 locks, first one not locked. "
"Expect no locks unlocked. \n");
lck.in.lock_count = 0x0001;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[1];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Try to unlock both locks */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
/* Second lock should not be unlocked. */
lck.in.lock_count = 0x0001;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[1];
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_OK);
torture_warning(torture, "Target has \"pretty please\" bug. "
"A contending lock request on the same handle "
"unlocks the lock.\n");
} else {
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
}
/* cleanup */
lck.in.lock_count = 0x0001;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = &el[1];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Test2: Acquire first lock, but not second. */
torture_comment(torture, " unlock 2 locks, second one not locked. "
"Expect first lock unlocked.\n");
lck.in.lock_count = 0x0001;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Try to unlock both locks */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
/* First lock should be unlocked. */
lck.in.lock_count = 0x0001;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* cleanup */
lck.in.lock_count = 0x0001;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Test3: Request 2 locks, second will contend. What happens to the
* first? */
torture_comment(torture, " request 2 locks, second one will contend. "
"Expect both to fail.\n");
/* Lock the second range */
lck.in.lock_count = 0x0001;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[1];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Request both locks */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* First lock should be unlocked. */
lck.in.lock_count = 0x0001;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* cleanup */
if (TARGET_IS_W2K8(torture)) {
lck.in.lock_count = 0x0001;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_warning(torture, "Target has \"pretty please\" bug. "
"A contending lock request on the same handle "
"unlocks the lock.\n");
} else {
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
}
/* Test4: Request unlock and lock. The lock contends, is the unlock
* then relocked? SMB2 doesn't like the lock and unlock requests in the
* same packet. The unlock will succeed, but the lock will return
* INVALID_PARAMETER. This behavior is described in MS-SMB2
* 3.3.5.14.1 */
torture_comment(torture, " request unlock and lock, second one will "
"error. Expect the unlock to succeed.\n");
/* Lock both ranges */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Attempt to unlock the first range and lock the second. The lock
* request will error. */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
/* The first lock should've been unlocked */
lck.in.lock_count = 0x0001;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* cleanup */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Test10: SMB2 only test. Request unlock and lock in same packet.
* Neither contend. SMB2 doesn't like lock and unlock requests in the
* same packet. The unlock will succeed, but the lock will return
* INVALID_PARAMETER. */
torture_comment(torture, " request unlock and lock. Unlock will "
"succeed, but lock will fail.\n");
/* Lock first range */
lck.in.lock_count = 0x0001;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Attempt to unlock the first range and lock the second */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
/* Neither lock should still be locked */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* cleanup */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Test11: SMB2 only test. Request lock and unlock in same packet.
* Neither contend. SMB2 doesn't like lock and unlock requests in the
* same packet. The lock will succeed, the unlock will fail with
* INVALID_PARAMETER, and the lock will be unlocked before return. */
torture_comment(torture, " request lock and unlock. Both will "
"fail.\n");
/* Lock second range */
lck.in.lock_count = 0x0001;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[1];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Attempt to lock the first range and unlock the second */
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
/* First range should be unlocked, second locked. */
lck.in.lock_count = 0x0001;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.lock_count = 0x0001;
el[1].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
lck.in.locks = &el[1];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* cleanup */
if (TARGET_IS_W2K8(torture)) {
lck.in.lock_count = 0x0001;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = &el[0];
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
torture_warning(torture, "Target has \"pretty please\" bug. "
"A contending lock request on the same handle "
"unlocks the lock.\n");
} else {
lck.in.lock_count = 0x0002;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
el[1].flags = SMB2_LOCK_FLAG_UNLOCK;
lck.in.locks = el;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
}
done:
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/**
* Test lock stacking
* - some tests ported from BASE-LOCK-LOCK5
*/
static bool test_stacking(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[1];
const char *fname = BASEDIR "\\stacking.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing lock stacking:\n");
/* Setup initial parameters */
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 10;
el[0].reserved = 0x00000000;
/* Try to take a shared lock, then a shared lock on same handle */
torture_comment(torture, " stacking a shared on top of a shared"
"lock succeeds.\n");
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* cleanup */
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Try to take an exclusive lock, then a shared lock on same handle */
torture_comment(torture, " stacking a shared on top of an exclusive "
"lock succeeds.\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* stacking a shared from a different handle should fail */
lck.in.file.handle = h2;
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* cleanup */
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* ensure the 4th unlock fails */
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
/* ensure a second handle can now take an exclusive lock */
lck.in.file.handle = h2;
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Try to take an exclusive lock, then a shared lock on a
* different handle */
torture_comment(torture, " stacking a shared on top of an exclusive "
"lock with different handles fails.\n");
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* cleanup */
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* Try to take a shared lock, then stack an exclusive with same
* handle. */
torture_comment(torture, " stacking an exclusive on top of a shared "
"lock fails.\n");
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* cleanup */
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_warning(torture, "Target has \"pretty please\" bug. "
"A contending lock request on the same handle "
"unlocks the lock.\n");
} else {
CHECK_STATUS(status, NT_STATUS_OK);
}
/* Prove that two exclusive locks do not stack on the same handle. */
torture_comment(torture, " two exclusive locks do not stack.\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* cleanup */
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
if (TARGET_IS_W2K8(torture)) {
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_warning(torture, "Target has \"pretty please\" bug. "
"A contending lock request on the same handle "
"unlocks the lock.\n");
} else {
CHECK_STATUS(status, NT_STATUS_OK);
}
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/**
* Test lock contention
* - shared lock should contend with exclusive lock on different handle
*/
static bool test_contend(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[1];
const char *fname = BASEDIR "\\contend.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing lock contention:\n");
/* Setup initial parameters */
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 10;
el[0].reserved = 0x00000000;
/* Take an exclusive lock, then a shared lock on different handle */
torture_comment(torture, " shared should contend on exclusive on "
"different handle.\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.file.handle = h2;
el[0].flags = SMB2_LOCK_FLAG_SHARED |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/* cleanup */
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/**
* Test locker context
* - test that pid does not affect the locker context
*/
static bool test_context(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[1];
const char *fname = BASEDIR "\\context.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing locker context:\n");
/* Setup initial parameters */
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 10;
el[0].reserved = 0x00000000;
/* Take an exclusive lock, then try to unlock with a different pid,
* same handle. This shows that the pid doesn't affect the locker
* context in SMB2. */
torture_comment(torture, " pid shouldn't affect locker context\n");
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/**
* Test as much of the potential lock range as possible
* - test ported from BASE-LOCK-LOCK3
*/
static bool test_range(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[1];
uint64_t offset, i;
extern int torture_numops;
const char *fname = BASEDIR "\\range.txt";
#define NEXT_OFFSET offset += (~(uint64_t)0) / torture_numops
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing locks spread across the 64-bit "
"offset range\n");
if (TARGET_IS_W2K8(torture)) {
torture_result(torture, TORTURE_SKIP,
"Target has \"pretty please\" bug. A contending lock "
"request on the same handle unlocks the lock.");
goto done;
}
/* Setup initial parameters */
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 1;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
torture_comment(torture, " establishing %d locks\n", torture_numops);
for (offset=i=0; i<torture_numops; i++) {
NEXT_OFFSET;
lck.in.file.handle = h;
el[0].offset = offset - 1;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CMT(status, NT_STATUS_OK,
talloc_asprintf(torture,
"lock h failed at offset %#llx ",
(unsigned long long) el[0].offset));
lck.in.file.handle = h2;
el[0].offset = offset - 2;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CMT(status, NT_STATUS_OK,
talloc_asprintf(torture,
"lock h2 failed at offset %#llx ",
(unsigned long long) el[0].offset));
}
torture_comment(torture, " testing %d locks\n", torture_numops);
for (offset=i=0; i<torture_numops; i++) {
NEXT_OFFSET;
lck.in.file.handle = h;
el[0].offset = offset - 1;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CMT(status, NT_STATUS_LOCK_NOT_GRANTED,
talloc_asprintf(torture,
"lock h at offset %#llx should not have "
"succeeded ",
(unsigned long long) el[0].offset));
lck.in.file.handle = h;
el[0].offset = offset - 2;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CMT(status, NT_STATUS_LOCK_NOT_GRANTED,
talloc_asprintf(torture,
"lock h2 at offset %#llx should not have "
"succeeded ",
(unsigned long long) el[0].offset));
lck.in.file.handle = h2;
el[0].offset = offset - 1;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CMT(status, NT_STATUS_LOCK_NOT_GRANTED,
talloc_asprintf(torture,
"lock h at offset %#llx should not have "
"succeeded ",
(unsigned long long) el[0].offset));
lck.in.file.handle = h2;
el[0].offset = offset - 2;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CMT(status, NT_STATUS_LOCK_NOT_GRANTED,
talloc_asprintf(torture,
"lock h2 at offset %#llx should not have "
"succeeded ",
(unsigned long long) el[0].offset));
}
torture_comment(torture, " removing %d locks\n", torture_numops);
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
for (offset=i=0; i<torture_numops; i++) {
NEXT_OFFSET;
lck.in.file.handle = h;
el[0].offset = offset - 1;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CMT(status, NT_STATUS_OK,
talloc_asprintf(torture,
"unlock from h failed at offset %#llx ",
(unsigned long long) el[0].offset));
lck.in.file.handle = h2;
el[0].offset = offset - 2;
status = smb2_lock(tree, &lck);
CHECK_STATUS_CMT(status, NT_STATUS_OK,
talloc_asprintf(torture,
"unlock from h2 failed at offset %#llx ",
(unsigned long long) el[0].offset));
}
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
static NTSTATUS test_smb2_lock(struct smb2_tree *tree, struct smb2_handle h,
uint64_t offset, uint64_t length, bool exclusive)
{
struct smb2_lock lck;
struct smb2_lock_element el[1];
NTSTATUS status;
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = offset;
el[0].length = length;
el[0].reserved = 0x00000000;
el[0].flags = (exclusive ?
SMB2_LOCK_FLAG_EXCLUSIVE :
SMB2_LOCK_FLAG_SHARED) |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
return status;
}
static NTSTATUS test_smb2_unlock(struct smb2_tree *tree, struct smb2_handle h,
uint64_t offset, uint64_t length)
{
struct smb2_lock lck;
struct smb2_lock_element el[1];
NTSTATUS status;
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = offset;
el[0].length = length;
el[0].reserved = 0x00000000;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
return status;
}
#define EXPECTED(ret, v) if ((ret) != (v)) { \
torture_result(torture, TORTURE_FAIL, __location__": subtest failed");\
torture_comment(torture, "** "); correct = false; \
}
/**
* Test overlapping lock ranges from various lockers
* - some tests ported from BASE-LOCK-LOCK4
*/
static bool test_overlap(struct torture_context *torture,
struct smb2_tree *tree,
struct smb2_tree *tree2)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
struct smb2_handle h3 = {{0}};
uint8_t buf[200];
bool correct = true;
const char *fname = BASEDIR "\\overlap.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree2, fname, &h3);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing overlapping locks:\n");
ret = NT_STATUS_IS_OK(test_smb2_lock(tree, h, 0, 4, true)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree, h, 2, 4, true));
EXPECTED(ret, false);
torture_comment(torture, "the same session/handle %s set overlapping "
"exclusive locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(test_smb2_lock(tree, h, 10, 4, false)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree, h, 12, 4, false));
EXPECTED(ret, true);
torture_comment(torture, "the same session/handle %s set overlapping "
"shared locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(test_smb2_lock(tree, h, 20, 4, true)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree2, h3, 22, 4, true));
EXPECTED(ret, false);
torture_comment(torture, "a different session %s set overlapping "
"exclusive locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(test_smb2_lock(tree, h, 30, 4, false)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree2, h3, 32, 4, false));
EXPECTED(ret, true);
torture_comment(torture, "a different session %s set overlapping "
"shared locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(test_smb2_lock(tree, h, 40, 4, true)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree, h2, 42, 4, true));
EXPECTED(ret, false);
torture_comment(torture, "a different handle %s set overlapping "
"exclusive locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(test_smb2_lock(tree, h, 50, 4, false)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree, h2, 52, 4, false));
EXPECTED(ret, true);
torture_comment(torture, "a different handle %s set overlapping "
"shared locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(test_smb2_lock(tree, h, 110, 4, false)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree, h, 112, 4, false)) &&
NT_STATUS_IS_OK(test_smb2_unlock(tree, h, 110, 6));
EXPECTED(ret, false);
torture_comment(torture, "the same handle %s coalesce read locks\n",
ret?"can":"cannot");
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
status = torture_smb2_testfile(tree, fname, &h2);
CHECK_STATUS(status, NT_STATUS_OK);
ret = NT_STATUS_IS_OK(test_smb2_lock(tree, h, 0, 8, false)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree, h2, 0, 1, false)) &&
NT_STATUS_IS_OK(smb2_util_close(tree, h)) &&
NT_STATUS_IS_OK(torture_smb2_testfile(tree, fname, &h)) &&
NT_STATUS_IS_OK(test_smb2_lock(tree, h, 7, 1, true));
EXPECTED(ret, true);
torture_comment(torture, "the server %s have the NT byte range lock "
"bug\n", !ret?"does":"doesn't");
done:
smb2_util_close(tree2, h3);
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return correct;
}
/**
* Test truncation of locked file
* - some tests ported from BASE-LOCK-LOCK7
*/
static bool test_truncate(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h = {{0}};
struct smb2_handle h2 = {{0}};
uint8_t buf[200];
struct smb2_lock lck;
struct smb2_lock_element el[1];
struct smb2_create io;
const char *fname = BASEDIR "\\truncate.txt";
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
ZERO_STRUCT(buf);
status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing truncation of locked file:\n");
/* Setup initial parameters */
lck.in.locks = el;
lck.in.lock_count = 0x0001;
lck.in.lock_sequence = 0x00000000;
lck.in.file.handle = h;
el[0].offset = 0;
el[0].length = 10;
el[0].reserved = 0x00000000;
ZERO_STRUCT(io);
io.in.oplock_level = 0;
io.in.desired_access = SEC_RIGHTS_FILE_ALL;
io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
io.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
io.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE |
NTCREATEX_SHARE_ACCESS_READ |
NTCREATEX_SHARE_ACCESS_WRITE;
io.in.create_options = 0;
io.in.fname = fname;
/* Take an exclusive lock */
el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/* On second handle open the file with OVERWRITE disposition */
torture_comment(torture, " overwrite disposition is allowed on a "
"locked file.\n");
io.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
status = smb2_create(tree, tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h2 = io.out.file.handle;
smb2_util_close(tree, h2);
/* On second handle open the file with SUPERSEDE disposition */
torture_comment(torture, " supersede disposition is allowed on a "
"locked file.\n");
io.in.create_disposition = NTCREATEX_DISP_SUPERSEDE;
status = smb2_create(tree, tree, &io);
CHECK_STATUS(status, NT_STATUS_OK);
h2 = io.out.file.handle;
smb2_util_close(tree, h2);
/* cleanup */
lck.in.file.handle = h;
el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
done:
smb2_util_close(tree, h2);
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/**
* Test lock replay detection
*/
static bool test_replay(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle h;
struct smb2_ioctl ioctl;
struct smb2_lock lck;
struct smb2_lock_element el;
uint8_t res_req[8];
const char *fname = BASEDIR "\\replay.txt";
struct smb2_transport *transport = tree->session->transport;
if (smbXcli_conn_protocol(transport->conn) < PROTOCOL_SMB2_10) {
torture_skip(torture, "SMB 2.100 Dialect family or above \
required for Lock Replay tests\n");
}
status = torture_smb2_testdir(tree, BASEDIR, &h);
CHECK_STATUS(status, NT_STATUS_OK);
smb2_util_close(tree, h);
torture_comment(torture, "Testing Open File:\n");
status = torture_smb2_testfile(tree, fname, &h);
CHECK_STATUS(status, NT_STATUS_OK);
/*
* Setup initial parameters
*/
el = (struct smb2_lock_element) {
.length = 100,
.offset = 100,
};
lck = (struct smb2_lock) {
.in.locks = &el,
.in.lock_count = 0x0001,
.in.file.handle = h
};
torture_comment(torture, "Testing Lock (ignored) Replay detection:\n");
lck.in.lock_sequence = 0x010 + 0x1;
el.flags = SMB2_LOCK_FLAG_EXCLUSIVE | SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
el.flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Testing Set Resiliency:\n");
SIVAL(res_req, 0, 1000); /* timeout */
SIVAL(res_req, 4, 0); /* reserved */
ioctl = (struct smb2_ioctl) {
.level = RAW_IOCTL_SMB2,
.in.file.handle = h,
.in.function = FSCTL_LMR_REQ_RESILIENCY,
.in.max_response_size = 0,
.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL,
.in.out.data = res_req,
.in.out.length = sizeof(res_req)
};
status = smb2_ioctl(tree, torture, &ioctl);
CHECK_STATUS(status, NT_STATUS_OK);
torture_comment(torture, "Testing Lock (ignored) Replay detection "
"(Bucket No: 0):\n");
lck.in.lock_sequence = 0x000 + 0x1;
el.flags = SMB2_LOCK_FLAG_EXCLUSIVE | SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
el.flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Testing Lock Replay detection "
"(Bucket No: 1):\n");
/*
* Obtain Exclusive Lock of length 100 bytes using Bucket Num 1
* and Bucket Seq 1.
*/
lck.in.lock_sequence = 0x010 + 0x1;
el.flags = SMB2_LOCK_FLAG_EXCLUSIVE | SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/*
* Server detects Replay of Byte Range locks using the Lock Sequence
* Numbers. And ignores the requests completely.
*/
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el.flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el.flags = SMB2_LOCK_FLAG_EXCLUSIVE | SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el.flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
/*
* Server will not grant same Byte Range using a different Bucket Seq
*/
lck.in.lock_sequence = 0x010 + 0x2;
el.flags = SMB2_LOCK_FLAG_EXCLUSIVE | SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
torture_comment(torture, "Testing Lock Replay detection "
"(Bucket No: 64):\n");
/*
* Server will not grant same Byte Range using a different Bucket Num
*/
lck.in.lock_sequence = 0x410 + 0x1;
el.flags = SMB2_LOCK_FLAG_EXCLUSIVE | SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
/*
* Test Unlock replay detection
*/
lck.in.lock_sequence = 0x410 + 0x2;
el.flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
el.flags = SMB2_LOCK_FLAG_EXCLUSIVE | SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
lck.in.lock_sequence = 0x410 + 0x3;
el.flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
torture_comment(torture, "Testing Lock (ignored) Replay detection "
"(Bucket No: 65):\n");
lck.in.lock_sequence = 0x420 + 0x1;
el.flags = SMB2_LOCK_FLAG_EXCLUSIVE | SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_LOCK_NOT_GRANTED);
el.flags = SMB2_LOCK_FLAG_UNLOCK;
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_OK);
status = smb2_lock(tree, &lck);
CHECK_STATUS(status, NT_STATUS_RANGE_NOT_LOCKED);
done:
smb2_util_close(tree, h);
smb2_deltree(tree, BASEDIR);
return ret;
}
/**
* Test lock interaction between smbd and ctdb with tombstone records.
*
* Re-locking an unlocked record could lead to a deadlock between
* smbd and ctdb. Make sure we don't regress.
*
* https://bugzilla.samba.org/show_bug.cgi?id=12005
* https://bugzilla.samba.org/show_bug.cgi?id=10008
*/
static bool test_deadlock(struct torture_context *torture,
struct smb2_tree *tree)
{
NTSTATUS status;
bool ret = true;
struct smb2_handle _h;
struct smb2_handle *h = NULL;
uint8_t buf[200];
const char *fname = BASEDIR "\\deadlock.txt";
if (!lpcfg_clustering(torture->lp_ctx)) {
torture_skip(torture, "Test must be run on a ctdb cluster\n");
return true;
}
status = torture_smb2_testdir(tree, BASEDIR, &_h);
torture_assert_ntstatus_ok(torture, status,
"torture_smb2_testdir failed");
smb2_util_close(tree, _h);
status = torture_smb2_testfile(tree, fname, &_h);
torture_assert_ntstatus_ok_goto(torture, status, ret, done,
"torture_smb2_testfile failed");
h = &_h;
ZERO_STRUCT(buf);
status = smb2_util_write(tree, *h, buf, 0, ARRAY_SIZE(buf));
torture_assert_ntstatus_ok_goto(torture, status, ret, done,
"smb2_util_write failed");
status = test_smb2_lock(tree, *h, 0, 1, true);
torture_assert_ntstatus_ok_goto(torture, status, ret, done,
"test_smb2_lock failed");
status = test_smb2_unlock(tree, *h, 0, 1);
torture_assert_ntstatus_ok_goto(torture, status, ret, done,
"test_smb2_unlock failed");
status = test_smb2_lock(tree, *h, 0, 1, true);
torture_assert_ntstatus_ok_goto(torture, status, ret, done,
"test_smb2_lock failed");
status = test_smb2_unlock(tree, *h, 0, 1);
torture_assert_ntstatus_ok_goto(torture, status, ret, done,
"test_smb2_unlock failed");
done:
if (h != NULL) {
smb2_util_close(tree, *h);
}
smb2_deltree(tree, BASEDIR);
return ret;
}
/* basic testing of SMB2 locking
*/
struct torture_suite *torture_smb2_lock_init(void)
{
struct torture_suite *suite =
torture_suite_create(talloc_autofree_context(), "lock");
torture_suite_add_1smb2_test(suite, "valid-request",
test_valid_request);
torture_suite_add_1smb2_test(suite, "rw-none", test_lock_rw_none);
torture_suite_add_1smb2_test(suite, "rw-shared", test_lock_rw_shared);
torture_suite_add_1smb2_test(suite, "rw-exclusive",
test_lock_rw_exclusive);
torture_suite_add_1smb2_test(suite, "auto-unlock",
test_lock_auto_unlock);
torture_suite_add_1smb2_test(suite, "lock", test_lock);
torture_suite_add_1smb2_test(suite, "async", test_async);
torture_suite_add_1smb2_test(suite, "cancel", test_cancel);
torture_suite_add_1smb2_test(suite, "cancel-tdis", test_cancel_tdis);
torture_suite_add_1smb2_test(suite, "cancel-logoff",
test_cancel_logoff);
torture_suite_add_1smb2_test(suite, "errorcode", test_errorcode);
torture_suite_add_1smb2_test(suite, "zerobytelength",
test_zerobytelength);
torture_suite_add_1smb2_test(suite, "zerobyteread",
test_zerobyteread);
torture_suite_add_1smb2_test(suite, "unlock", test_unlock);
torture_suite_add_1smb2_test(suite, "multiple-unlock",
test_multiple_unlock);
torture_suite_add_1smb2_test(suite, "stacking", test_stacking);
torture_suite_add_1smb2_test(suite, "contend", test_contend);
torture_suite_add_1smb2_test(suite, "context", test_context);
torture_suite_add_1smb2_test(suite, "range", test_range);
torture_suite_add_2smb2_test(suite, "overlap", test_overlap);
torture_suite_add_1smb2_test(suite, "truncate", test_truncate);
torture_suite_add_1smb2_test(suite, "replay", test_replay);
torture_suite_add_1smb2_test(suite, "ctdb-delrec-deadlock", test_deadlock);
suite->description = talloc_strdup(suite, "SMB2-LOCK tests");
return suite;
}
View Git Blame Copy Permalink