#include "includes.h"
#include "libcli/raw/libcliraw.h"
#include "libcli/libcli.h"
+#include "torture/ui.h"
#include "torture/util.h"
#include "torture/torture.h"
#include "system/time.h"
must not use posix semantics)
2) support for lock timeouts
*/
-BOOL torture_locktest1(struct torture_context *torture)
+bool torture_locktest1(struct torture_context *tctx,
+ struct smbcli_state *cli1,
+ struct smbcli_state *cli2)
{
- struct smbcli_state *cli1, *cli2;
const char *fname = BASEDIR "\\lockt1.lck";
int fnum1, fnum2, fnum3;
time_t t1, t2;
uint_t lock_timeout;
- if (!torture_open_connection(&cli1, 0) ||
- !torture_open_connection(&cli2, 1)) {
- return False;
- }
-
- printf("starting locktest1\n");
-
if (!torture_setup_dir(cli1, BASEDIR)) {
return False;
}
fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
- printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert(tctx, fnum1 != -1,
+ talloc_asprintf(tctx,
+ "open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree)));
fnum2 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
- if (fnum2 == -1) {
- printf("(%s) open2 of %s failed (%s)\n",
- __location__, fname, smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx,
+ "open2 of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree)));
fnum3 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
- if (fnum3 == -1) {
- printf("open3 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree));
- return False;
- }
+ torture_assert(tctx, fnum3 != -1, talloc_asprintf(tctx,
+ "open3 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree)));
- if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
- printf("lock1 failed (%s)\n", smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx,
+ smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK),
+ talloc_asprintf(tctx, "lock1 failed (%s)", smbcli_errstr(cli1->tree)));
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+ "lock2 succeeded! This is a locking bug\n");
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
- printf("lock2 succeeded! This is a locking bug\n");
- return False;
- } else {
- if (!check_error(__location__, cli2, ERRDOS, ERRlock,
- NT_STATUS_LOCK_NOT_GRANTED)) return False;
- }
+ if (!check_error(__location__, cli2, ERRDOS, ERRlock,
+ NT_STATUS_LOCK_NOT_GRANTED)) return False;
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
- printf("lock2 succeeded! This is a locking bug\n");
- return False;
- } else {
- if (!check_error(__location__, cli2, ERRDOS, ERRlock,
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+ "lock2 succeeded! This is a locking bug\n");
+
+ if (!check_error(__location__, cli2, ERRDOS, ERRlock,
NT_STATUS_FILE_LOCK_CONFLICT)) return False;
- }
- if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 5, 9, 0, WRITE_LOCK))) {
- printf("lock1 failed (%s)\n", smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx,
+ smbcli_lock(cli1->tree, fnum1, 5, 9, 0, WRITE_LOCK),
+ talloc_asprintf(tctx,
+ "lock1 failed (%s)", smbcli_errstr(cli1->tree)));
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 5, 9, 0, WRITE_LOCK))) {
- printf("lock2 succeeded! This is a locking bug\n");
- return False;
- } else {
- if (!check_error(__location__, cli2, ERRDOS, ERRlock,
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 5, 9, 0, WRITE_LOCK)),
+ "lock2 succeeded! This is a locking bug");
+
+ if (!check_error(__location__, cli2, ERRDOS, ERRlock,
NT_STATUS_LOCK_NOT_GRANTED)) return False;
- }
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
- printf("lock2 succeeded! This is a locking bug\n");
- return False;
- } else {
- if (!check_error(__location__, cli2, ERRDOS, ERRlock,
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+ "lock2 succeeded! This is a locking bug");
+
+ if (!check_error(__location__, cli2, ERRDOS, ERRlock,
NT_STATUS_LOCK_NOT_GRANTED)) return False;
- }
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
- printf("lock2 succeeded! This is a locking bug\n");
- return False;
- } else {
- if (!check_error(__location__, cli2, ERRDOS, ERRlock,
- NT_STATUS_FILE_LOCK_CONFLICT)) return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+ "lock2 succeeded! This is a locking bug");
+
+ if (!check_error(__location__, cli2, ERRDOS, ERRlock,
+ NT_STATUS_FILE_LOCK_CONFLICT)) return False;
lock_timeout = (6 + (random() % 20));
- printf("Testing lock timeout with timeout=%u\n", lock_timeout);
+ torture_comment(tctx, "Testing lock timeout with timeout=%u\n",
+ lock_timeout);
t1 = time(NULL);
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK))) {
- printf("lock3 succeeded! This is a locking bug\n");
- return False;
- } else {
- if (!check_error(__location__, cli2, ERRDOS, ERRlock,
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, lock_timeout * 1000, WRITE_LOCK)),
+ "lock3 succeeded! This is a locking bug\n");
+
+ if (!check_error(__location__, cli2, ERRDOS, ERRlock,
NT_STATUS_FILE_LOCK_CONFLICT)) return False;
- }
t2 = time(NULL);
if (t2 - t1 < 5) {
- printf("error: This server appears not to support timed lock requests\n");
+ torture_fail(tctx,
+ "error: This server appears not to support timed lock requests");
}
- printf("server slept for %u seconds for a %u second timeout\n",
+ torture_comment(tctx, "server slept for %u seconds for a %u second timeout\n",
(uint_t)(t2-t1), lock_timeout);
- if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum2))) {
- printf("close1 failed (%s)\n", smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum2),
+ talloc_asprintf(tctx, "close1 failed (%s)", smbcli_errstr(cli1->tree)));
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
- printf("lock4 succeeded! This is a locking bug\n");
- return False;
- } else {
- if (!check_error(__location__, cli2, ERRDOS, ERRlock,
- NT_STATUS_FILE_LOCK_CONFLICT)) return False;
- }
-
- if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
- printf("close2 failed (%s)\n", smbcli_errstr(cli1->tree));
- return False;
- }
-
- if (NT_STATUS_IS_ERR(smbcli_close(cli2->tree, fnum3))) {
- printf("close3 failed (%s)\n", smbcli_errstr(cli2->tree));
- return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+ "lock4 succeeded! This is a locking bug");
+
+ if (!check_error(__location__, cli2, ERRDOS, ERRlock,
+ NT_STATUS_FILE_LOCK_CONFLICT)) return False;
- if (NT_STATUS_IS_ERR(smbcli_unlink(cli1->tree, fname))) {
- printf("unlink failed (%s)\n", smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
+ talloc_asprintf(tctx, "close2 failed (%s)", smbcli_errstr(cli1->tree)));
+ torture_assert_ntstatus_ok(tctx, smbcli_close(cli2->tree, fnum3),
+ talloc_asprintf(tctx, "close3 failed (%s)", smbcli_errstr(cli2->tree)));
- if (!torture_close_connection(cli1)) {
- return False;
- }
-
- if (!torture_close_connection(cli2)) {
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_unlink(cli1->tree, fname),
+ talloc_asprintf(tctx, "unlink failed (%s)", smbcli_errstr(cli1->tree)));
- printf("Passed locktest1\n");
- return True;
+ return true;
}
3) the server denies unlock requests by an incorrect client PID
*/
-BOOL torture_locktest2(struct torture_context *torture)
+bool torture_locktest2(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
const char *fname = BASEDIR "\\lockt2.lck";
int fnum1, fnum2, fnum3;
- BOOL correct = True;
-
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
- printf("starting locktest2\n");
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
- printf("Testing pid context\n");
+ torture_comment(tctx, "Testing pid context\n");
cli->session->pid = 1;
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
- printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
- return False;
- }
+ torture_assert(tctx, fnum1 != -1,
+ talloc_asprintf(tctx,
+ "open of %s failed (%s)", fname, smbcli_errstr(cli->tree)));
fnum2 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
- if (fnum2 == -1) {
- printf("(%s) open2 of %s failed (%s)\n",
- __location__, fname, smbcli_errstr(cli->tree));
- return False;
- }
+ torture_assert(tctx, fnum2 != -1,
+ talloc_asprintf(tctx, "open2 of %s failed (%s)",
+ fname, smbcli_errstr(cli->tree)));
cli->session->pid = 2;
fnum3 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
- if (fnum3 == -1) {
- printf("open3 of %s failed (%s)\n", fname, smbcli_errstr(cli->tree));
- return False;
- }
+ torture_assert(tctx, fnum3 != -1,
+ talloc_asprintf(tctx,
+ "open3 of %s failed (%s)\n", fname, smbcli_errstr(cli->tree)));
cli->session->pid = 1;
- if (NT_STATUS_IS_ERR(smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
- printf("lock1 failed (%s)\n", smbcli_errstr(cli->tree));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx,
+ smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK),
+ talloc_asprintf(tctx,
+ "lock1 failed (%s)", smbcli_errstr(cli->tree)));
- if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK))) {
- printf("WRITE lock1 succeeded! This is a locking bug\n");
- correct = False;
- } else {
- if (!check_error(__location__, cli, ERRDOS, ERRlock,
- NT_STATUS_LOCK_NOT_GRANTED)) return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum1, 0, 4, 0, WRITE_LOCK)),
+ "WRITE lock1 succeeded! This is a locking bug");
+
+ if (!check_error(__location__, cli, ERRDOS, ERRlock,
+ NT_STATUS_LOCK_NOT_GRANTED)) return False;
- if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, WRITE_LOCK))) {
- printf("WRITE lock2 succeeded! This is a locking bug\n");
- correct = False;
- } else {
- if (!check_error(__location__, cli, ERRDOS, ERRlock,
- NT_STATUS_LOCK_NOT_GRANTED)) return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, WRITE_LOCK)),
+ "WRITE lock2 succeeded! This is a locking bug");
- if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, READ_LOCK))) {
- printf("READ lock2 succeeded! This is a locking bug\n");
- correct = False;
- } else {
- if (!check_error(__location__, cli, ERRDOS, ERRlock,
- NT_STATUS_FILE_LOCK_CONFLICT)) return False;
- }
+ if (!check_error(__location__, cli, ERRDOS, ERRlock,
+ NT_STATUS_LOCK_NOT_GRANTED)) return False;
- if (NT_STATUS_IS_ERR(smbcli_lock(cli->tree, fnum1, 100, 4, 0, WRITE_LOCK))) {
- printf("lock at 100 failed (%s)\n", smbcli_errstr(cli->tree));
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum2, 0, 4, 0, READ_LOCK)),
+ "READ lock2 succeeded! This is a locking bug");
+
+ if (!check_error(__location__, cli, ERRDOS, ERRlock,
+ NT_STATUS_FILE_LOCK_CONFLICT)) return False;
+
+ torture_assert_ntstatus_ok(tctx,
+ smbcli_lock(cli->tree, fnum1, 100, 4, 0, WRITE_LOCK),
+ talloc_asprintf(tctx,
+ "lock at 100 failed (%s)", smbcli_errstr(cli->tree)));
cli->session->pid = 2;
- if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 100, 4))) {
- printf("unlock at 100 succeeded! This is a locking bug\n");
- correct = False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 100, 4)),
+ "unlock at 100 succeeded! This is a locking bug");
- if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 4))) {
- printf("unlock1 succeeded! This is a locking bug\n");
- correct = False;
- } else {
- if (!check_error(__location__, cli,
- ERRDOS, ERRnotlocked,
- NT_STATUS_RANGE_NOT_LOCKED)) return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 4)),
+ "unlock1 succeeded! This is a locking bug");
- if (NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 8))) {
- printf("unlock2 succeeded! This is a locking bug\n");
- correct = False;
- } else {
- if (!check_error(__location__, cli,
+ if (!check_error(__location__, cli,
ERRDOS, ERRnotlocked,
NT_STATUS_RANGE_NOT_LOCKED)) return False;
- }
- if (NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum3, 0, 4, 0, WRITE_LOCK))) {
- printf("lock3 succeeded! This is a locking bug\n");
- correct = False;
- } else {
- if (!check_error(__location__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_unlock(cli->tree, fnum1, 0, 8)),
+ "unlock2 succeeded! This is a locking bug");
- cli->session->pid = 1;
+ if (!check_error(__location__, cli,
+ ERRDOS, ERRnotlocked,
+ NT_STATUS_RANGE_NOT_LOCKED)) return False;
- if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum1))) {
- printf("close1 failed (%s)\n", smbcli_errstr(cli->tree));
- return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli->tree, fnum3, 0, 4, 0, WRITE_LOCK)),
+ "lock3 succeeded! This is a locking bug");
- if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum2))) {
- printf("close2 failed (%s)\n", smbcli_errstr(cli->tree));
- return False;
- }
+ if (!check_error(__location__, cli, ERRDOS, ERRlock, NT_STATUS_LOCK_NOT_GRANTED)) return False;
- if (NT_STATUS_IS_ERR(smbcli_close(cli->tree, fnum3))) {
- printf("close3 failed (%s)\n", smbcli_errstr(cli->tree));
- return False;
- }
+ cli->session->pid = 1;
- if (!torture_close_connection(cli)) {
- correct = False;
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_close(cli->tree, fnum1),
+ talloc_asprintf(tctx, "close1 failed (%s)", smbcli_errstr(cli->tree)));
- printf("locktest2 finished\n");
+ torture_assert_ntstatus_ok(tctx, smbcli_close(cli->tree, fnum2),
+ talloc_asprintf(tctx, "close2 failed (%s)", smbcli_errstr(cli->tree)));
- return correct;
+ torture_assert_ntstatus_ok(tctx, smbcli_close(cli->tree, fnum3),
+ talloc_asprintf(tctx, "close3 failed (%s)", smbcli_errstr(cli->tree)));
+
+ return true;
}
1) the server supports the full offset range in lock requests
*/
-BOOL torture_locktest3(struct torture_context *torture)
+bool torture_locktest3(struct torture_context *tctx,
+ struct smbcli_state *cli1,
+ struct smbcli_state *cli2)
{
- struct smbcli_state *cli1, *cli2;
const char *fname = BASEDIR "\\lockt3.lck";
int fnum1, fnum2, i;
uint32_t offset;
- BOOL correct = True;
extern int torture_numops;
#define NEXT_OFFSET offset += (~(uint32_t)0) / torture_numops
- if (!torture_open_connection(&cli1, 0) ||
- !torture_open_connection(&cli2, 1)) {
- return False;
- }
-
- printf("starting locktest3\n");
-
- printf("Testing 32 bit offset ranges\n");
+ torture_comment(tctx, "Testing 32 bit offset ranges");
if (!torture_setup_dir(cli1, BASEDIR)) {
return False;
}
fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
- if (fnum1 == -1) {
- printf("open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert(tctx, fnum1 != -1,
+ talloc_asprintf(tctx, "open of %s failed (%s)\n", fname, smbcli_errstr(cli1->tree)));
fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
- if (fnum2 == -1) {
- printf("open2 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree));
- return False;
- }
+ torture_assert(tctx, fnum2 != -1,
+ talloc_asprintf(tctx, "open2 of %s failed (%s)\n", fname, smbcli_errstr(cli2->tree)));
- printf("Establishing %d locks\n", torture_numops);
+ torture_comment(tctx, "Establishing %d locks\n", torture_numops);
for (offset=i=0;i<torture_numops;i++) {
NEXT_OFFSET;
- if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK))) {
- printf("lock1 %d failed (%s)\n",
- i,
- smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx,
+ smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK),
+ talloc_asprintf(tctx, "lock1 %d failed (%s)", i, smbcli_errstr(cli1->tree)));
- if (NT_STATUS_IS_ERR(smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK))) {
- printf("lock2 %d failed (%s)\n",
- i,
- smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx,
+ smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK),
+ talloc_asprintf(tctx, "lock2 %d failed (%s)",
+ i, smbcli_errstr(cli1->tree)));
}
- printf("Testing %d locks\n", torture_numops);
+ torture_comment(tctx, "Testing %d locks\n", torture_numops);
for (offset=i=0;i<torture_numops;i++) {
NEXT_OFFSET;
- if (NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-2, 1, 0, WRITE_LOCK))) {
- printf("error: lock1 %d succeeded!\n", i);
- return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-2, 1, 0, WRITE_LOCK)),
+ talloc_asprintf(tctx, "error: lock1 %d succeeded!", i));
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-1, 1, 0, WRITE_LOCK))) {
- printf("error: lock2 %d succeeded!\n", i);
- return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-1, 1, 0, WRITE_LOCK)),
+ talloc_asprintf(tctx, "error: lock2 %d succeeded!", i));
- if (NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK))) {
- printf("error: lock3 %d succeeded!\n", i);
- return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, offset-1, 1, 0, WRITE_LOCK)),
+ talloc_asprintf(tctx, "error: lock3 %d succeeded!", i));
- if (NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK))) {
- printf("error: lock4 %d succeeded!\n", i);
- return False;
- }
+ torture_assert(tctx,
+ !NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, offset-2, 1, 0, WRITE_LOCK)),
+ talloc_asprintf(tctx, "error: lock4 %d succeeded!", i));
}
- printf("Removing %d locks\n", torture_numops);
+ torture_comment(tctx, "Removing %d locks\n", torture_numops);
for (offset=i=0;i<torture_numops;i++) {
NEXT_OFFSET;
- if (NT_STATUS_IS_ERR(smbcli_unlock(cli1->tree, fnum1, offset-1, 1))) {
- printf("unlock1 %d failed (%s)\n",
+ torture_assert_ntstatus_ok(tctx,
+ smbcli_unlock(cli1->tree, fnum1, offset-1, 1),
+ talloc_asprintf(tctx, "unlock1 %d failed (%s)",
i,
- smbcli_errstr(cli1->tree));
- return False;
- }
+ smbcli_errstr(cli1->tree)));
- if (NT_STATUS_IS_ERR(smbcli_unlock(cli2->tree, fnum2, offset-2, 1))) {
- printf("unlock2 %d failed (%s)\n",
+ torture_assert_ntstatus_ok(tctx,
+ smbcli_unlock(cli2->tree, fnum2, offset-2, 1),
+ talloc_asprintf(tctx, "unlock2 %d failed (%s)",
i,
- smbcli_errstr(cli1->tree));
- return False;
- }
- }
-
- if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
- printf("close1 failed (%s)\n", smbcli_errstr(cli1->tree));
- return False;
- }
-
- if (NT_STATUS_IS_ERR(smbcli_close(cli2->tree, fnum2))) {
- printf("close2 failed (%s)\n", smbcli_errstr(cli2->tree));
- return False;
+ smbcli_errstr(cli1->tree)));
}
- if (NT_STATUS_IS_ERR(smbcli_unlink(cli1->tree, fname))) {
- printf("unlink failed (%s)\n", smbcli_errstr(cli1->tree));
- return False;
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
+ talloc_asprintf(tctx, "close1 failed (%s)", smbcli_errstr(cli1->tree)));
- if (!torture_close_connection(cli1)) {
- correct = False;
- }
-
- if (!torture_close_connection(cli2)) {
- correct = False;
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_close(cli2->tree, fnum2),
+ talloc_asprintf(tctx, "close2 failed (%s)", smbcli_errstr(cli2->tree)));
- printf("finished locktest3\n");
+ torture_assert_ntstatus_ok(tctx, smbcli_unlink(cli1->tree, fname),
+ talloc_asprintf(tctx, "unlink failed (%s)", smbcli_errstr(cli1->tree)));
- return correct;
+ return true;
}
#define EXPECTED(ret, v) if ((ret) != (v)) { \
- printf("** "); correct = False; \
+ torture_comment(tctx, "** "); correct = False; \
}
/*
looks at overlapping locks
*/
-BOOL torture_locktest4(struct torture_context *torture)
+BOOL torture_locktest4(struct torture_context *tctx,
+ struct smbcli_state *cli1,
+ struct smbcli_state *cli2)
{
- struct smbcli_state *cli1, *cli2;
const char *fname = BASEDIR "\\lockt4.lck";
int fnum1, fnum2, f;
BOOL ret;
uint8_t buf[1000];
BOOL correct = True;
- if (!torture_open_connection(&cli1, 0) ||
- !torture_open_connection(&cli2, 1)) {
- return False;
- }
-
- printf("starting locktest4\n");
-
if (!torture_setup_dir(cli1, BASEDIR)) {
return False;
}
memset(buf, 0, sizeof(buf));
if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
- printf("Failed to create file\n");
+ torture_comment(tctx, "Failed to create file\n");
correct = False;
goto fail;
}
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 2, 4, 0, WRITE_LOCK));
EXPECTED(ret, False);
- printf("the same process %s set overlapping write locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s set overlapping write locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 10, 4, 0, READ_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 12, 4, 0, READ_LOCK));
EXPECTED(ret, True);
- printf("the same process %s set overlapping read locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s set overlapping read locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 20, 4, 0, WRITE_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 22, 4, 0, WRITE_LOCK));
EXPECTED(ret, False);
- printf("a different connection %s set overlapping write locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "a different connection %s set overlapping write locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 30, 4, 0, READ_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 32, 4, 0, READ_LOCK));
EXPECTED(ret, True);
- printf("a different connection %s set overlapping read locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "a different connection %s set overlapping read locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 40, 4, 0, WRITE_LOCK))) &&
NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 42, 4, 0, WRITE_LOCK)));
EXPECTED(ret, False);
- printf("a different pid %s set overlapping write locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "a different pid %s set overlapping write locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 50, 4, 0, READ_LOCK))) &&
NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 52, 4, 0, READ_LOCK)));
EXPECTED(ret, True);
- printf("a different pid %s set overlapping read locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "a different pid %s set overlapping read locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 60, 4, 0, READ_LOCK));
EXPECTED(ret, True);
- printf("the same process %s set the same read lock twice\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s set the same read lock twice\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 70, 4, 0, WRITE_LOCK));
EXPECTED(ret, False);
- printf("the same process %s set the same write lock twice\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s set the same write lock twice\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 80, 4, 0, READ_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 80, 4, 0, WRITE_LOCK));
EXPECTED(ret, False);
- printf("the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s overlay a read lock with a write lock\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 90, 4, 0, WRITE_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 90, 4, 0, READ_LOCK));
EXPECTED(ret, True);
- printf("the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s overlay a write lock with a read lock\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK((cli1->session->pid = 1, smbcli_lock(cli1->tree, fnum1, 100, 4, 0, WRITE_LOCK))) &&
NT_STATUS_IS_OK((cli1->session->pid = 2, smbcli_lock(cli1->tree, fnum1, 100, 4, 0, READ_LOCK)));
EXPECTED(ret, False);
- printf("a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
+ torture_comment(tctx, "a different pid %s overlay a write lock with a read lock\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 110, 4, 0, READ_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 112, 4, 0, READ_LOCK)) &&
NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 110, 6));
EXPECTED(ret, False);
- printf("the same process %s coalesce read locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s coalesce read locks\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 120, 4, 0, WRITE_LOCK)) &&
(smbcli_read(cli2->tree, fnum2, buf, 120, 4) == 4);
EXPECTED(ret, False);
- printf("this server %s strict write locking\n", ret?"doesn't do":"does");
+ torture_comment(tctx, "this server %s strict write locking\n", ret?"doesn't do":"does");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK)) &&
(smbcli_write(cli2->tree, fnum2, 0, buf, 130, 4) == 4);
EXPECTED(ret, False);
- printf("this server %s strict read locking\n", ret?"doesn't do":"does");
+ torture_comment(tctx, "this server %s strict read locking\n", ret?"doesn't do":"does");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 140, 4, 0, READ_LOCK)) &&
NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 140, 4)) &&
NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 140, 4));
EXPECTED(ret, True);
- printf("this server %s do recursive read locking\n", ret?"does":"doesn't");
+ torture_comment(tctx, "this server %s do recursive read locking\n", ret?"does":"doesn't");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 150, 4, 0, WRITE_LOCK)) &&
!(smbcli_write(cli2->tree, fnum2, 0, buf, 150, 4) == 4) &&
NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 150, 4));
EXPECTED(ret, True);
- printf("this server %s do recursive lock overlays\n", ret?"does":"doesn't");
+ torture_comment(tctx, "this server %s do recursive lock overlays\n", ret?"does":"doesn't");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 160, 4, 0, READ_LOCK)) &&
NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 160, 4)) &&
(smbcli_write(cli2->tree, fnum2, 0, buf, 160, 4) == 4) &&
(smbcli_read(cli2->tree, fnum2, buf, 160, 4) == 4);
EXPECTED(ret, True);
- printf("the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s remove a read lock using write locking\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 170, 4, 0, WRITE_LOCK)) &&
NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 170, 4)) &&
(smbcli_write(cli2->tree, fnum2, 0, buf, 170, 4) == 4) &&
(smbcli_read(cli2->tree, fnum2, buf, 170, 4) == 4);
EXPECTED(ret, True);
- printf("the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s remove a write lock using read locking\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 190, 4, 0, WRITE_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 190, 4, 0, READ_LOCK)) &&
!(smbcli_write(cli2->tree, fnum2, 0, buf, 190, 4) == 4) &&
(smbcli_read(cli2->tree, fnum2, buf, 190, 4) == 4);
EXPECTED(ret, True);
- printf("the same process %s remove the first lock first\n", ret?"does":"doesn't");
+ torture_comment(tctx, "the same process %s remove the first lock first\n", ret?"does":"doesn't");
smbcli_close(cli1->tree, fnum1);
smbcli_close(cli2->tree, fnum2);
smbcli_close(cli1->tree, f);
smbcli_close(cli1->tree, fnum1);
EXPECTED(ret, True);
- printf("the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
+ torture_comment(tctx, "the server %s have the NT byte range lock bug\n", !ret?"does":"doesn't");
fail:
smbcli_close(cli1->tree, fnum1);
smbcli_close(cli2->tree, fnum2);
smbcli_unlink(cli1->tree, fname);
- torture_close_connection(cli1);
- torture_close_connection(cli2);
- printf("finished locktest4\n");
return correct;
}
/*
looks at lock upgrade/downgrade.
*/
-BOOL torture_locktest5(struct torture_context *torture)
+BOOL torture_locktest5(struct torture_context *tctx, struct smbcli_state *cli1,
+ struct smbcli_state *cli2)
{
- struct smbcli_state *cli1, *cli2;
const char *fname = BASEDIR "\\lockt5.lck";
int fnum1, fnum2, fnum3;
BOOL ret;
uint8_t buf[1000];
BOOL correct = True;
- if (!torture_open_connection(&cli1, 0) ||
- !torture_open_connection(&cli2, 1)) {
- return False;
- }
-
- printf("starting locktest5\n");
-
if (!torture_setup_dir(cli1, BASEDIR)) {
return False;
}
memset(buf, 0, sizeof(buf));
- if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
- printf("Failed to create file\n");
- correct = False;
- goto fail;
- }
+ torture_assert(tctx, smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) == sizeof(buf),
+ "Failed to create file");
/* Check for NT bug... */
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 8, 0, READ_LOCK)) &&
fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 7, 1, 0, WRITE_LOCK));
EXPECTED(ret, True);
- printf("this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
+ torture_comment(tctx, "this server %s the NT locking bug\n", ret ? "doesn't have" : "has");
smbcli_close(cli1->tree, fnum1);
fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
smbcli_unlock(cli1->tree, fnum3, 0, 1);
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, WRITE_LOCK)) &&
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 1, 1, 0, READ_LOCK));
EXPECTED(ret, True);
- printf("the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s overlay a write with a read lock\n", ret?"can":"cannot");
ret = NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK));
EXPECTED(ret, False);
- printf("a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
+ torture_comment(tctx, "a different processs %s get a read lock on the first process lock stack\n", ret?"can":"cannot");
/* Unlock the process 2 lock. */
smbcli_unlock(cli2->tree, fnum2, 0, 4);
ret = NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum3, 0, 4, 0, READ_LOCK));
EXPECTED(ret, False);
- printf("the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same processs on a different fnum %s get a read lock\n", ret?"can":"cannot");
/* Unlock the process 1 fnum3 lock. */
smbcli_unlock(cli1->tree, fnum3, 0, 4);
NT_STATUS_IS_OK(smbcli_lock(cli1->tree, fnum1, 0, 4, 0, READ_LOCK));
EXPECTED(ret, True);
- printf("the same process %s stack read locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s stack read locks\n", ret?"can":"cannot");
/* Unlock the first process lock, then check this was the WRITE lock that was
removed. */
NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, READ_LOCK));
EXPECTED(ret, True);
- printf("the first unlock removes the %s lock\n", ret?"WRITE":"READ");
+ torture_comment(tctx, "the first unlock removes the %s lock\n", ret?"WRITE":"READ");
/* Unlock the process 2 lock. */
smbcli_unlock(cli2->tree, fnum2, 0, 4);
NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4));
EXPECTED(ret, True);
- printf("the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s unlock the stack of 4 locks\n", ret?"can":"cannot");
/* Ensure the next unlock fails. */
ret = NT_STATUS_IS_OK(smbcli_unlock(cli1->tree, fnum1, 0, 4));
EXPECTED(ret, False);
- printf("the same process %s count the lock stack\n", !ret?"can":"cannot");
+ torture_comment(tctx, "the same process %s count the lock stack\n", !ret?"can":"cannot");
/* Ensure connection 2 can get a write lock. */
ret = NT_STATUS_IS_OK(smbcli_lock(cli2->tree, fnum2, 0, 4, 0, WRITE_LOCK));
EXPECTED(ret, True);
- printf("a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
+ torture_comment(tctx, "a different processs %s get a write lock on the unlocked stack\n", ret?"can":"cannot");
- fail:
smbcli_close(cli1->tree, fnum1);
smbcli_close(cli2->tree, fnum2);
smbcli_unlink(cli1->tree, fname);
- if (!torture_close_connection(cli1)) {
- correct = False;
- }
- if (!torture_close_connection(cli2)) {
- correct = False;
- }
-
- printf("finished locktest5\n");
return correct;
}
/*
tries the unusual lockingX locktype bits
*/
-BOOL torture_locktest6(struct torture_context *torture)
+BOOL torture_locktest6(struct torture_context *tctx,
+ struct smbcli_state *cli)
{
- struct smbcli_state *cli;
const char *fname[1] = { "\\lock6.txt" };
int i;
int fnum;
NTSTATUS status;
- if (!torture_open_connection(&cli, 0)) {
- return False;
- }
-
if (!torture_setup_dir(cli, BASEDIR)) {
return False;
}
- printf("starting locktest6\n");
-
for (i=0;i<1;i++) {
- printf("Testing %s\n", fname[i]);
+ torture_comment(tctx, "Testing %s\n", fname[i]);
smbcli_unlink(cli->tree, fname[i]);
fnum = smbcli_open(cli->tree, fname[i], O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
status = smbcli_locktype(cli->tree, fnum, 0, 8, 0, LOCKING_ANDX_CHANGE_LOCKTYPE);
smbcli_close(cli->tree, fnum);
- printf("CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
+ torture_comment(tctx, "CHANGE_LOCKTYPE gave %s\n", nt_errstr(status));
fnum = smbcli_open(cli->tree, fname[i], O_RDWR, DENY_NONE);
status = smbcli_locktype(cli->tree, fnum, 0, 8, 0, LOCKING_ANDX_CANCEL_LOCK);
smbcli_close(cli->tree, fnum);
- printf("CANCEL_LOCK gave %s\n", nt_errstr(status));
+ torture_comment(tctx, "CANCEL_LOCK gave %s\n", nt_errstr(status));
smbcli_unlink(cli->tree, fname[i]);
}
- torture_close_connection(cli);
-
- printf("finished locktest6\n");
return True;
}
-BOOL torture_locktest7(struct torture_context *torture)
+BOOL torture_locktest7(struct torture_context *tctx,
+ struct smbcli_state *cli1)
{
- struct smbcli_state *cli1;
const char *fname = BASEDIR "\\lockt7.lck";
int fnum1;
int fnum2 = -1;
uint8_t buf[200];
BOOL correct = False;
- if (!torture_open_connection(&cli1, 0)) {
- return False;
- }
-
- printf("starting locktest7\n");
-
- if (!torture_setup_dir(cli1, BASEDIR)) {
- return False;
- }
+ torture_assert(tctx, torture_setup_dir(cli1, BASEDIR),
+ talloc_asprintf(tctx, "Unable to set up %s", BASEDIR));
fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT|O_EXCL, DENY_NONE);
memset(buf, 0, sizeof(buf));
- if (smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) != sizeof(buf)) {
- printf("Failed to create file (%s)\n", __location__);
- goto fail;
- }
+ torture_assert(tctx, smbcli_write(cli1->tree, fnum1, 0, buf, 0, sizeof(buf)) == sizeof(buf),
+ "Failed to create file");
cli1->session->pid = 1;
- if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK))) {
- printf("Unable to apply read lock on range 130:4, error was %s (%s)\n",
- smbcli_errstr(cli1->tree), __location__);
- goto fail;
- } else {
- printf("pid1 successfully locked range 130:4 for READ\n");
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_lock(cli1->tree, fnum1, 130, 4, 0, READ_LOCK),
+ talloc_asprintf(tctx, "Unable to apply read lock on range 130:4, error was %s",
+ smbcli_errstr(cli1->tree)));
- if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
- printf("pid1 unable to read the range 130:4, error was %s (%s)\n",
- smbcli_errstr(cli1->tree), __location__);
- goto fail;
- } else {
- printf("pid1 successfully read the range 130:4\n");
- }
+ torture_comment(tctx, "pid1 successfully locked range 130:4 for READ\n");
+
+ torture_assert(tctx, smbcli_read(cli1->tree, fnum1, buf, 130, 4) == 4,
+ talloc_asprintf(tctx, "pid1 unable to read the range 130:4, error was %s)",
+ smbcli_errstr(cli1->tree)));
+
+ torture_comment(tctx, "pid1 successfully read the range 130:4\n");
if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
- printf("pid1 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
- if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT)) {
- printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
- __location__);
- goto fail;
- }
+ torture_comment(tctx, "pid1 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
+ torture_assert_ntstatus_equal(tctx, smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT,
+ "Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)");
} else {
- printf("pid1 successfully wrote to the range 130:4 (should be denied) (%s)\n",
- __location__);
- goto fail;
+ torture_fail(tctx, "pid1 successfully wrote to the range 130:4 (should be denied)");
}
cli1->session->pid = 2;
if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
- printf("pid2 unable to read the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
+ torture_comment(tctx, "pid2 unable to read the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
} else {
- printf("pid2 successfully read the range 130:4\n");
+ torture_comment(tctx, "pid2 successfully read the range 130:4\n");
}
if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
- printf("pid2 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
- if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT)) {
- printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
- __location__);
- goto fail;
- }
+ torture_comment(tctx, "pid2 unable to write to the range 130:4, error was %s\n", smbcli_errstr(cli1->tree));
+ torture_assert_ntstatus_equal(tctx, smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT,
+ "Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)");
} else {
- printf("pid2 successfully wrote to the range 130:4 (should be denied) (%s)\n",
- __location__);
- goto fail;
+ torture_fail(tctx, "pid2 successfully wrote to the range 130:4 (should be denied)");
}
cli1->session->pid = 1;
smbcli_unlock(cli1->tree, fnum1, 130, 4);
- if (NT_STATUS_IS_ERR(smbcli_lock(cli1->tree, fnum1, 130, 4, 0, WRITE_LOCK))) {
- printf("Unable to apply write lock on range 130:4, error was %s (%s)\n",
- smbcli_errstr(cli1->tree), __location__);
- goto fail;
- } else {
- printf("pid1 successfully locked range 130:4 for WRITE\n");
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_lock(cli1->tree, fnum1, 130, 4, 0, WRITE_LOCK),
+ talloc_asprintf(tctx, "Unable to apply write lock on range 130:4, error was %s",
+ smbcli_errstr(cli1->tree)));
+ torture_comment(tctx, "pid1 successfully locked range 130:4 for WRITE\n");
- if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
- printf("pid1 unable to read the range 130:4, error was %s (%s)\n",
- smbcli_errstr(cli1->tree), __location__);
- goto fail;
- } else {
- printf("pid1 successfully read the range 130:4\n");
- }
+ torture_assert(tctx, smbcli_read(cli1->tree, fnum1, buf, 130, 4) == 4,
+ talloc_asprintf(tctx, "pid1 unable to read the range 130:4, error was %s",
+ smbcli_errstr(cli1->tree)));
+ torture_comment(tctx, "pid1 successfully read the range 130:4\n");
- if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
- printf("pid1 unable to write to the range 130:4, error was %s (%s)\n",
- smbcli_errstr(cli1->tree), __location__);
- goto fail;
- } else {
- printf("pid1 successfully wrote to the range 130:4\n");
- }
+ torture_assert(tctx, smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) == 4,
+ talloc_asprintf(tctx, "pid1 unable to write to the range 130:4, error was %s",
+ smbcli_errstr(cli1->tree)));
+ torture_comment(tctx, "pid1 successfully wrote to the range 130:4\n");
cli1->session->pid = 2;
if (smbcli_read(cli1->tree, fnum1, buf, 130, 4) != 4) {
- printf("pid2 unable to read the range 130:4, error was %s\n",
+ torture_comment(tctx, "pid2 unable to read the range 130:4, error was %s\n",
smbcli_errstr(cli1->tree));
- if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT)) {
- printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
- __location__);
- goto fail;
- }
+ torture_assert_ntstatus_equal(tctx, smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT,
+ "Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT)");
} else {
- printf("pid2 successfully read the range 130:4 (should be denied) (%s)\n",
- __location__);
- goto fail;
+ torture_fail(tctx, "pid2 successfully read the range 130:4 (should be denied)");
}
if (smbcli_write(cli1->tree, fnum1, 0, buf, 130, 4) != 4) {
- printf("pid2 unable to write to the range 130:4, error was %s\n",
+ torture_comment(tctx, "pid2 unable to write to the range 130:4, error was %s\n",
smbcli_errstr(cli1->tree));
if (!NT_STATUS_EQUAL(smbcli_nt_error(cli1->tree), NT_STATUS_FILE_LOCK_CONFLICT)) {
- printf("Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
+ torture_comment(tctx, "Incorrect error (should be NT_STATUS_FILE_LOCK_CONFLICT) (%s)\n",
__location__);
goto fail;
}
} else {
- printf("pid2 successfully wrote to the range 130:4 (should be denied) (%s)\n",
+ torture_comment(tctx, "pid2 successfully wrote to the range 130:4 (should be denied) (%s)\n",
__location__);
goto fail;
}
- printf("Testing truncate of locked file.\n");
+ torture_comment(tctx, "Testing truncate of locked file.\n");
fnum2 = smbcli_open(cli1->tree, fname, O_RDWR|O_TRUNC, DENY_NONE);
- if (fnum2 == -1) {
- printf("Unable to truncate locked file (%s)\n", __location__);
- correct = False;
- goto fail;
- } else {
- printf("Truncated locked file.\n");
- }
+ torture_assert(tctx, fnum2 != -1, "Unable to truncate locked file");
- if (NT_STATUS_IS_ERR(smbcli_getatr(cli1->tree, fname, NULL, &size, NULL))) {
- printf("getatr failed (%s) (%s)\n", smbcli_errstr(cli1->tree), __location__);
- correct = False;
- goto fail;
- }
+ torture_comment(tctx, "Truncated locked file.\n");
- if (size != 0) {
- printf("Unable to truncate locked file. Size was %u (%s)\n",
- (unsigned)size, __location__);
- correct = False;
- goto fail;
- }
+ torture_assert_ntstatus_ok(tctx, smbcli_getatr(cli1->tree, fname, NULL, &size, NULL),
+ talloc_asprintf(tctx, "getatr failed (%s)", smbcli_errstr(cli1->tree)));
+
+ torture_assert(tctx, size == 0, talloc_asprintf(tctx, "Unable to truncate locked file. Size was %u", (unsigned)size));
cli1->session->pid = 1;
smbcli_close(cli1->tree, fnum1);
smbcli_close(cli1->tree, fnum2);
smbcli_unlink(cli1->tree, fname);
- torture_close_connection(cli1);
- printf("finished locktest7\n");
return correct;
}
+struct torture_suite *torture_base_locktest(void)
+{
+ struct torture_suite *suite = torture_suite_create(talloc_autofree_context(),
+ "LOCK");
+ torture_suite_add_2smb_test(suite, "LOCK1", torture_locktest1);
+ torture_suite_add_1smb_test(suite, "LOCK2", torture_locktest2);
+ torture_suite_add_2smb_test(suite, "LOCK3", torture_locktest3);
+ torture_suite_add_2smb_test(suite, "LOCK4", torture_locktest4);
+ torture_suite_add_2smb_test(suite, "LOCK5", torture_locktest5);
+ torture_suite_add_1smb_test(suite, "LOCK6", torture_locktest6);
+ torture_suite_add_1smb_test(suite, "LOCK7", torture_locktest7);
+
+ return suite;
+}
git.samba.org / metze / samba / wip.git / blobdiff