#include "system/filesys.h"
#include "libcli/libcli.h"
#include "torture/util.h"
-
-#define W2K8R2_TIMEDELAY_SECS 1
-#define W2K3_TIMEDELAY_SECS 2
-#define TIMEDELAY_SECS W2K3_TIMEDELAY_SECS
+#include "torture/basic/proto.h"
+#include "lib/util/time_basic.h"
#define BASEDIR "\\delaywrite"
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
- if (fnum1 == -1) {
- torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
- return false;
- }
+ torture_assert_int_not_equal(tctx, fnum1, -1, talloc_asprintf(tctx,
+ "Failed to open %s", fname));
finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
finfo1.basic_info.in.file.fnum = fnum1;
finfo2 = finfo1;
status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
-
torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
-
- torture_comment(tctx, "Initial write time %s\n",
- nt_time_string(tctx, finfo1.basic_info.out.write_time));
- written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
+ torture_comment(tctx, "Initial write time %s\n",
+ nt_time_string(tctx, finfo1.basic_info.out.write_time));
- if (written != 1) {
- torture_result(tctx, TORTURE_FAIL,
- "write failed - wrote %d bytes (%s)\n",
- (int)written, __location__);
- return false;
- }
+ written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
+ torture_assert_int_equal(tctx, written, 1,
+ "unexpected number of bytes written");
start = timeval_current();
- end = timeval_add(&start, (120*sec), 0);
+ end = timeval_add(&start, (120 * sec), 0);
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
- ret = false;
- break;
- }
- torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo2.basic_info.out.write_time));
- if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
+
+ torture_comment(tctx, "write time %s\n",
+ nt_time_string(tctx, finfo2.basic_info.out.write_time));
+
+ if (finfo1.basic_info.out.write_time !=
+ finfo2.basic_info.out.write_time)
+ {
double diff = timeval_elapsed(&start);
- if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
- torture_comment(tctx, "Server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(wrong!)\n",
- diff, sec);
- ret = false;
- break;
- }
- torture_comment(tctx, "Server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(correct)\n",
- diff, sec);
+ torture_assert(tctx,
+ diff >= (used_delay / (double)1000000),
+ talloc_asprintf(tctx,
+ "Server updated write_time after %.2f "
+ "seconds (expected >= %.2f)\n",
+ diff, used_delay/(double)1000000));
+
+ torture_comment(tctx, "Server updated write_time after %.2f seconds (correct)\n",
+ diff);
break;
}
fflush(stdout);
smb_msleep(1 * msec);
}
-
- if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server did not update write time (wrong!)");
- ret = false;
- }
+ torture_assert_u64_not_equal(tctx,
+ finfo2.basic_info.out.write_time,
+ finfo1.basic_info.out.write_time,
+ "Server did not update write time within "
+ "120 seconds");
if (fnum1 != -1)
smbcli_close(cli->tree, fnum1);
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
char buf[2048];
+ bool first;
+ bool updated;
torture_comment(tctx, "\nRunning test_delayed_write_update1\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
- if (fnum1 == -1) {
- torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
- return false;
- }
+ torture_assert_int_not_equal(tctx, fnum1, -1, talloc_asprintf(tctx,
+ "Failed to open %s", fname));
memset(buf, 'x', 2048);
written = smbcli_write(cli->tree, fnum1, 0, buf, 0, 2048);
torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- torture_comment(tctx, "Initial write time %s\n",
- nt_time_string(tctx, finfo1.all_info.out.write_time));
+ torture_assert_u64_equal(tctx, finfo1.all_info.out.size, 2048,
+ "file size not as expected after write(2048)");
+
+ torture_comment(tctx, "Initial write time %s\n",
+ nt_time_string(tctx, finfo1.all_info.out.write_time));
/* 3 second delay to ensure we get past any 2 second time
granularity (older systems may have that) */
/* Do a zero length SMBwrite call to truncate. */
written = smbcli_smbwrite(cli->tree, fnum1, "x", 1024, 0);
-
- if (written != 0) {
- torture_result(tctx, TORTURE_FAIL,
- "write failed - wrote %d bytes (%s)\n",
- (int)written, __location__);
- return false;
- }
+ torture_assert_int_equal(tctx, written, 0,
+ "unexpected number of bytes written");
start = timeval_current();
- end = timeval_add(&start, (120*sec), 0);
+ end = timeval_add(&start, (120 * sec), 0);
+ first = true;
+ updated = false;
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
- ret = false;
- break;
- }
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- if (finfo2.all_info.out.size != 1024) {
- torture_result(tctx, TORTURE_FAIL,
- "file not truncated, size = %u (should be 1024)",
- (unsigned int)finfo2.all_info.out.size);
- ret = false;
- break;
- }
+ torture_assert_u64_equal(tctx, finfo2.all_info.out.size, 1024,
+ "file not truncated to expected size "
+ "(1024)");
torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo2.all_info.out.write_time));
- if (finfo1.all_info.out.write_time != finfo2.all_info.out.write_time) {
- double diff = timeval_elapsed(&start);
- if (diff > (0.25 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
- torture_comment(tctx, "After SMBwrite truncate "
- "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(wrong!)\n",
- diff, sec);
- ret = false;
- break;
- }
+ nt_time_string(tctx, finfo2.all_info.out.write_time));
- torture_comment(tctx, "After SMBwrite truncate "
- "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(correct)\n",
- diff, sec);
+ if (finfo1.all_info.out.write_time !=
+ finfo2.all_info.out.write_time)
+ {
+ updated = true;
break;
}
+
fflush(stdout);
smb_msleep(1 * msec);
+ first = false;
}
- if (finfo1.all_info.out.write_time == finfo2.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server did not update write time (wrong!)");
- ret = false;
- }
+ torture_assert(tctx, updated,
+ "Server did not update write time within 120 seconds");
+
+ torture_assert(tctx, first, talloc_asprintf(tctx,
+ "Server did not update write time immediately but only "
+ "after %.2f seconds!", timeval_elapsed(&start)));
+
+ torture_comment(tctx, "Server updated write time immediately. Good!\n");
fflush(stdout);
smb_msleep(2 * msec);
/* Do a non-zero length SMBwrite and make sure it doesn't update the write time. */
written = smbcli_smbwrite(cli->tree, fnum1, "x", 0, 1);
-
- if (written != 1) {
- torture_result(tctx, TORTURE_FAIL,
- "write failed - wrote %d bytes (%s)",
- (int)written, __location__);
- return false;
- }
+ torture_assert_int_equal(tctx, written, 1,
+ "unexpected number of bytes written");
start = timeval_current();
end = timeval_add(&start, (10*sec), 0);
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
- ret = false;
- break;
- }
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- if (finfo3.all_info.out.size != 1024) {
- DEBUG(0, ("file not truncated, size = %u (should be 1024)\n",
- (unsigned int)finfo3.all_info.out.size));
- ret = false;
- break;
- }
+ torture_assert_u64_equal(tctx, finfo3.all_info.out.size, 1024,
+ "file not truncated to expected size "
+ "(1024)");
torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo3.all_info.out.write_time));
- if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
- double diff = timeval_elapsed(&start);
+ nt_time_string(tctx, finfo3.all_info.out.write_time));
+
+ torture_assert_u64_equal(tctx,
+ finfo3.all_info.out.write_time,
+ finfo2.all_info.out.write_time,
+ talloc_asprintf(tctx,
+ "Server updated write time "
+ "after %.2f seconds (wrong!)",
+ timeval_elapsed(&start)));
- torture_comment(tctx, "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(wrong)\n",
- diff, sec);
- break;
- }
fflush(stdout);
smb_msleep(1 * msec);
}
- if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server updated write time (wrong!)");
- ret = false;
- }
+ torture_comment(tctx, "Server did not update write time within 10 "
+ "seconds. Good!\n");
fflush(stdout);
smb_msleep(2 * msec);
status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
- if (finfo3.all_info.out.write_time == pinfo4.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server did not update write time on close (wrong!)");
- ret = false;
- } else if (finfo3.all_info.out.write_time < pinfo4.all_info.out.write_time) {
- torture_comment(tctx, "Server updated write time on close (correct)\n");
- }
+ torture_assert_u64_not_equal(tctx,
+ pinfo4.all_info.out.write_time,
+ finfo3.all_info.out.write_time,
+ "Server did not update write time on "
+ "close (wrong!)");
+ torture_assert(tctx,
+ pinfo4.all_info.out.write_time > finfo3.all_info.out.write_time,
+ "Server updated write time on close, but to an earlier point "
+ "in time");
+
+ torture_comment(tctx, "Server updated write time on close (correct)\n");
if (fnum1 != -1)
smbcli_close(cli->tree, fnum1);
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
char buf[2048];
+ bool first;
+ bool updated;
torture_comment(tctx, "\nRunning test_delayed_write_update1a\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
- if (fnum1 == -1) {
- torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
- return false;
- }
+ torture_assert_int_not_equal(tctx, fnum1, -1, talloc_asprintf(tctx,
+ "Failed to open %s", fname));
memset(buf, 'x', 2048);
written = smbcli_write(cli->tree, fnum1, 0, buf, 0, 2048);
torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- torture_comment(tctx, "Initial write time %s\n",
- nt_time_string(tctx, finfo1.all_info.out.write_time));
+ torture_assert_u64_equal(tctx, finfo1.all_info.out.size, 2048,
+ "file size not as expected after write(2048)");
+
+ torture_comment(tctx, "Initial write time %s\n",
+ nt_time_string(tctx, finfo1.all_info.out.write_time));
/* Do a zero length SMBwrite call to truncate. */
written = smbcli_smbwrite(cli->tree, fnum1, "x", 10240, 0);
- if (written != 0) {
- torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)",
- (int)written, __location__);
- return false;
- }
+ torture_assert_int_equal(tctx, written, 0,
+ "unexpected number of bytes written");
start = timeval_current();
end = timeval_add(&start, (120*sec), 0);
+ first = true;
+ updated = false;
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
- if (!NT_STATUS_IS_OK(status)) {
- torture_result(tctx, TORTURE_FAIL, "fileinfo failed: %s",
- nt_errstr(status));
- ret = false;
- break;
- }
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- if (finfo2.all_info.out.size != 10240) {
- torture_result(tctx, TORTURE_FAIL,
- "file not truncated, size = %u (should be 10240)",
- (unsigned int)finfo2.all_info.out.size);
- ret = false;
- break;
- }
+ torture_assert_u64_equal(tctx, finfo2.all_info.out.size, 10240,
+ "file not truncated to expected size "
+ "(10240)");
torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo2.all_info.out.write_time));
- if (finfo1.all_info.out.write_time != finfo2.all_info.out.write_time) {
- double diff = timeval_elapsed(&start);
- if (diff > (0.25 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
- torture_comment(tctx, "After SMBwrite truncate "
- "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(wrong!)\n",
- diff, sec);
- ret = false;
- break;
- }
+ nt_time_string(tctx, finfo2.all_info.out.write_time));
- torture_comment(tctx, "After SMBwrite truncate "
- "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(correct)\n",
- diff, sec);
+ if (finfo1.all_info.out.write_time !=
+ finfo2.all_info.out.write_time)
+ {
+ updated = true;
break;
}
+
fflush(stdout);
smb_msleep(1 * msec);
+ first = false;
}
- if (finfo1.all_info.out.write_time == finfo2.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server did not update write time (wrong!)");
- ret = false;
- }
+ torture_assert(tctx, updated,
+ "Server did not update write time within 120 seconds");
+
+ torture_assert(tctx, first, talloc_asprintf(tctx,
+ "Server did not update write time immediately but only "
+ "after %.2f seconds!", timeval_elapsed(&start)));
+
+ torture_comment(tctx, "Server updated write time immediately. Good!\n");
fflush(stdout);
smb_msleep(2 * msec);
/* Do a non-zero length SMBwrite and make sure it doesn't update the write time. */
written = smbcli_smbwrite(cli->tree, fnum1, "x", 0, 1);
- torture_assert_int_equal(tctx, written, 1,
- "unexpected number of bytes written");
+ torture_assert_int_equal(tctx, written, 1,
+ "unexpected number of bytes written");
start = timeval_current();
end = timeval_add(&start, (10*sec), 0);
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
- if (!NT_STATUS_IS_OK(status)) {
- torture_result(tctx, TORTURE_FAIL, "fileinfo failed: %s\n",
- nt_errstr(status));
- ret = false;
- break;
- }
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- if (finfo3.all_info.out.size != 10240) {
- torture_result(tctx, TORTURE_FAIL,
- "file not truncated, size = %u (should be 10240)",
- (unsigned int)finfo3.all_info.out.size);
- ret = false;
- break;
- }
+ torture_assert_u64_equal(tctx, finfo3.all_info.out.size, 10240,
+ "file not truncated to expected size "
+ "(10240)");
torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo3.all_info.out.write_time));
- if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
- double diff = timeval_elapsed(&start);
+ nt_time_string(tctx, finfo3.all_info.out.write_time));
+
+ torture_assert_u64_equal(tctx,
+ finfo3.all_info.out.write_time,
+ finfo2.all_info.out.write_time,
+ talloc_asprintf(tctx,
+ "Server updated write time "
+ "after %.2f seconds (wrong!)",
+ timeval_elapsed(&start)));
- torture_comment(tctx, "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(correct)\n",
- diff, sec);
- break;
- }
fflush(stdout);
smb_msleep(1 * msec);
}
- if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server updated write time (wrong!)");
- ret = false;
- }
+ torture_comment(tctx, "Server did not update write time within 10 "
+ "seconds. Good!\n");
/* the close should trigger an write time update */
smbcli_close(cli->tree, fnum1);
status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
- if (finfo3.all_info.out.write_time == pinfo4.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server did not update write time on close (wrong!)");
- ret = false;
- } else if (finfo3.all_info.out.write_time < pinfo4.all_info.out.write_time) {
- torture_comment(tctx, "Server updated write time on close (correct)\n");
- }
+ torture_assert_u64_not_equal(tctx,
+ pinfo4.all_info.out.write_time,
+ finfo3.all_info.out.write_time,
+ "Server did not update write time on "
+ "close (wrong!)");
+ torture_assert(tctx,
+ pinfo4.all_info.out.write_time > finfo3.all_info.out.write_time,
+ "Server updated write time on close, but to an earlier point "
+ "in time");
+
+ torture_comment(tctx, "Server updated write time on close (correct)\n");
if (fnum1 != -1)
smbcli_close(cli->tree, fnum1);
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
char buf[2048];
+ bool first;
+ bool updated;
torture_comment(tctx, "\nRunning test_delayed_write_update1b\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
- if (fnum1 == -1) {
- torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
- return false;
- }
+ torture_assert_int_not_equal(tctx, fnum1, -1, talloc_asprintf(tctx,
+ "Failed to open %s", fname));
memset(buf, 'x', 2048);
written = smbcli_write(cli->tree, fnum1, 0, buf, 0, 2048);
torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
+ torture_assert_u64_equal(tctx, finfo1.all_info.out.size, 2048,
+ "file size not as expected after write(2048)");
+
torture_comment(tctx, "Initial write time %s\n",
- nt_time_string(tctx, finfo1.all_info.out.write_time));
+ nt_time_string(tctx, finfo1.all_info.out.write_time));
/* Do a SET_END_OF_FILE_INFO call to truncate. */
status = smbcli_ftruncate(cli->tree, fnum1, (uint64_t)10240);
start = timeval_current();
end = timeval_add(&start, (120*sec), 0);
+ first = true;
+ updated = false;
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
- ret = false;
- break;
- }
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- if (finfo2.all_info.out.size != 10240) {
- torture_result(tctx, TORTURE_FAIL,
- "file not truncated (size = %u, should be 10240)",
- (unsigned int)finfo2.all_info.out.size );
- ret = false;
- break;
- }
+ torture_assert_u64_equal(tctx, finfo2.all_info.out.size, 10240,
+ "file not truncated to expected size "
+ "(10240)");
torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo2.all_info.out.write_time));
- if (finfo1.all_info.out.write_time != finfo2.all_info.out.write_time) {
- double diff = timeval_elapsed(&start);
- if (diff > (0.25 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
- torture_result(tctx, TORTURE_FAIL,
- "After SET_END_OF_FILE truncate "
- "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(wrong!)",
- diff, sec);
- ret = false;
- break;
- }
+ nt_time_string(tctx, finfo2.all_info.out.write_time));
- torture_comment(tctx, "After SET_END_OF_FILE truncate "
- "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(correct)\n",
- diff, sec);
+ if (finfo1.all_info.out.write_time !=
+ finfo2.all_info.out.write_time)
+ {
+ updated = true;
break;
}
+
fflush(stdout);
smb_msleep(1 * msec);
+ first = false;
}
- if (finfo1.all_info.out.write_time == finfo2.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server did not update write time (wrong!)");
- ret = false;
- }
+ torture_assert(tctx, updated,
+ "Server did not update write time within 120 seconds");
+
+ torture_assert(tctx, first, talloc_asprintf(tctx,
+ "Server did not update write time immediately but only "
+ "after %.2f seconds!", timeval_elapsed(&start)));
+
+ torture_comment(tctx, "Server updated write time immediately. Good!\n");
fflush(stdout);
smb_msleep(2 * msec);
/* Do a non-zero length SMBwrite and make sure it doesn't update the write time. */
written = smbcli_smbwrite(cli->tree, fnum1, "x", 0, 1);
- torture_assert_int_equal(tctx, written, 1,
- "unexpected number of bytes written");
+ torture_assert_int_equal(tctx, written, 1,
+ "unexpected number of bytes written");
start = timeval_current();
end = timeval_add(&start, (10*sec), 0);
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
- if (!NT_STATUS_IS_OK(status)) {
- torture_result(tctx, TORTURE_FAIL,
- "fileinfo failed: %s", nt_errstr(status));
- ret = false;
- break;
- }
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- if (finfo3.all_info.out.size != 10240) {
- DEBUG(0, ("file not truncated (size = %u, should be 10240)\n",
- (unsigned int)finfo3.all_info.out.size ));
- ret = false;
- break;
- }
+ torture_assert_u64_equal(tctx, finfo3.all_info.out.size, 10240,
+ "file not truncated to expected size "
+ "(10240)");
torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo3.all_info.out.write_time));
- if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
- double diff = timeval_elapsed(&start);
+ nt_time_string(tctx, finfo3.all_info.out.write_time));
+
+ torture_assert_u64_equal(tctx,
+ finfo3.all_info.out.write_time,
+ finfo2.all_info.out.write_time,
+ talloc_asprintf(tctx,
+ "Server updated write time "
+ "after %.2f seconds (wrong!)",
+ timeval_elapsed(&start)));
- torture_comment(tctx, "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(correct)\n",
- diff, sec);
- break;
- }
fflush(stdout);
smb_msleep(1 * msec);
}
- if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL, "Server updated write time (wrong!)\n");
- ret = false;
- }
+ torture_comment(tctx, "Server did not update write time within 10 "
+ "seconds. Good!\n");
/* the close should trigger an write time update */
smbcli_close(cli->tree, fnum1);
status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
- if (finfo3.all_info.out.write_time == pinfo4.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL, "Server did not update write time on close (wrong!)\n");
- ret = false;
- } else if (finfo3.all_info.out.write_time < pinfo4.all_info.out.write_time) {
- torture_comment(tctx, "Server updated write time on close (correct)\n");
- }
+ torture_assert_u64_not_equal(tctx,
+ pinfo4.all_info.out.write_time,
+ finfo3.all_info.out.write_time,
+ "Server did not update write time on "
+ "close (wrong!)");
+ torture_assert(tctx,
+ pinfo4.all_info.out.write_time > finfo3.all_info.out.write_time,
+ "Server updated write time on close, but to an earlier point "
+ "in time");
+
+ torture_comment(tctx, "Server updated write time on close (correct)\n");
if (fnum1 != -1)
smbcli_close(cli->tree, fnum1);
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
char buf[2048];
+ bool first;
+ bool updated;
torture_comment(tctx, "\nRunning test_delayed_write_update1c\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
- if (fnum1 == -1) {
- torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
- return false;
- }
+ torture_assert_int_not_equal(tctx, fnum1, -1, talloc_asprintf(tctx,
+ "Failed to open %s", fname));
memset(buf, 'x', 2048);
written = smbcli_write(cli->tree, fnum1, 0, buf, 0, 2048);
torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
+ torture_assert_u64_equal(tctx, finfo1.all_info.out.size, 2048,
+ "file size not as expected after write(2048)");
+
torture_comment(tctx, "Initial write time %s\n",
- nt_time_string(tctx, finfo1.all_info.out.write_time));
+ nt_time_string(tctx, finfo1.all_info.out.write_time));
/* Do a SET_ALLOCATION_SIZE call to truncate. */
parms.allocation_info.level = RAW_SFILEINFO_ALLOCATION_INFO;
status = smb_raw_setfileinfo(cli->tree, &parms);
- torture_assert_ntstatus_ok(tctx, status,
- "RAW_SFILEINFO_ALLOCATION_INFO failed");
+ torture_assert_ntstatus_ok(tctx, status,
+ "RAW_SFILEINFO_ALLOCATION_INFO failed");
start = timeval_current();
end = timeval_add(&start, (120*sec), 0);
+ first = true;
+ updated = false;
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
- if (!NT_STATUS_IS_OK(status)) {
- torture_result(tctx, TORTURE_FAIL, "fileinfo failed: %s",
- nt_errstr(status));
- ret = false;
- break;
- }
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- if (finfo2.all_info.out.size != 0) {
- torture_result(tctx, TORTURE_FAIL,
- "file not truncated (size = %u, should be 10240)",
- (unsigned int)finfo2.all_info.out.size);
- ret = false;
- break;
- }
+ torture_assert_u64_equal(tctx, finfo2.all_info.out.size, 0,
+ "file not truncated to expected size "
+ "(0)");
torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo2.all_info.out.write_time));
- if (finfo1.all_info.out.write_time != finfo2.all_info.out.write_time) {
- double diff = timeval_elapsed(&start);
- if (diff > (0.25 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
- torture_comment(tctx, "After SET_ALLOCATION_INFO truncate "
- "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(wrong!)\n",
- diff, sec);
- ret = false;
- break;
- }
+ nt_time_string(tctx, finfo2.all_info.out.write_time));
- torture_comment(tctx, "After SET_ALLOCATION_INFO truncate "
- "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(correct)\n",
- diff, sec);
+ if (finfo1.all_info.out.write_time !=
+ finfo2.all_info.out.write_time)
+ {
+ updated = true;
break;
}
+
fflush(stdout);
smb_msleep(1 * msec);
+ first = false;
}
- if (finfo1.all_info.out.write_time == finfo2.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server did not update write time (wrong!)");
- ret = false;
- }
+ torture_assert(tctx, updated,
+ "Server did not update write time within 120 seconds");
+
+ torture_assert(tctx, first, talloc_asprintf(tctx,
+ "Server did not update write time immediately but only "
+ "after %.2f seconds!", timeval_elapsed(&start)));
+
+ torture_comment(tctx, "Server updated write time immediately. Good!\n");
fflush(stdout);
smb_msleep(2 * msec);
/* Do a non-zero length SMBwrite and make sure it doesn't update the write time. */
written = smbcli_smbwrite(cli->tree, fnum1, "x", 0, 1);
- torture_assert_int_equal(tctx, written, 1,
- "Unexpected number of bytes written");
+ torture_assert_int_equal(tctx, written, 1,
+ "Unexpected number of bytes written");
start = timeval_current();
end = timeval_add(&start, (10*sec), 0);
while (!timeval_expired(&end)) {
status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
- if (!NT_STATUS_IS_OK(status)) {
- torture_result(tctx, TORTURE_FAIL, "fileinfo failed: %s",
- nt_errstr(status));
- ret = false;
- break;
- }
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
- if (finfo3.all_info.out.size != 1) {
- torture_result(tctx, TORTURE_FAIL, "file not expanded");
- ret = false;
- break;
- }
+ torture_assert_u64_equal(tctx, finfo3.all_info.out.size, 1,
+ "file not expaneded");
torture_comment(tctx, "write time %s\n",
- nt_time_string(tctx, finfo3.all_info.out.write_time));
- if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
- double diff = timeval_elapsed(&start);
+ nt_time_string(tctx, finfo3.all_info.out.write_time));
+
+ torture_assert_u64_equal(tctx,
+ finfo3.all_info.out.write_time,
+ finfo2.all_info.out.write_time,
+ talloc_asprintf(tctx,
+ "Server updated write time "
+ "after %.2f seconds (wrong!)",
+ timeval_elapsed(&start)));
- torture_comment(tctx, "server updated write_time after %.2f seconds"
- "(1 sec == %.2f)(correct)\n",
- diff, sec);
- break;
- }
fflush(stdout);
smb_msleep(1 * msec);
}
- if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL,
- "Server updated write time (wrong!)");
- ret = false;
- }
+ torture_comment(tctx, "Server did not update write time within 10 "
+ "seconds. Good!\n");
/* the close should trigger an write time update */
smbcli_close(cli->tree, fnum1);
status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
- if (finfo3.all_info.out.write_time == pinfo4.all_info.out.write_time) {
- torture_result(tctx, TORTURE_FAIL, "Server did not update write time on close (wrong!)\n");
- ret = false;
- } else if (finfo3.all_info.out.write_time < pinfo4.all_info.out.write_time) {
- torture_comment(tctx, "Server updated write time on close (correct)\n");
- }
+ torture_assert_u64_not_equal(tctx,
+ pinfo4.all_info.out.write_time,
+ finfo3.all_info.out.write_time,
+ "Server did not update write time on "
+ "close (wrong!)");
+ torture_assert(tctx,
+ pinfo4.all_info.out.write_time > finfo3.all_info.out.write_time,
+ "Server updated write time on close, but to an earlier point "
+ "in time");
if (fnum1 != -1)
smbcli_close(cli->tree, fnum1);
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update2\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
if (fnum1 == -1) {
written = smbcli_write(cli->tree, fnum1, 0, "0123456789", 1, 10);
if (written != 10) {
- torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
+ torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)\n",
(int)written, __location__);
return false;
}
nt_time_string(tctx, finfo2.basic_info.out.write_time));
if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds"
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds"
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
fnum2 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
if (fnum2 == -1) {
- torture_comment(tctx, "Failed to open %s\n", fname);
+ torture_result(tctx, TORTURE_FAIL, "Failed to open %s\n", fname);
return false;
}
written = smbcli_write(cli->tree, fnum2, 0, "0123456789", 11, 10);
if (written != 10) {
- torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
+ torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)\n",
(int)written, __location__);
return false;
}
torture_comment(tctx, "write time %s\n",
nt_time_string(tctx, finfo2.basic_info.out.write_time));
if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
- torture_comment(tctx, "Server updated write_time (wrong!)\n");
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time (wrong!)\n");
ret = false;
}
written = smbcli_write(cli->tree, fnum2, 0, "0123456789", 21, 10);
if (written != 10) {
- torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
+ torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)\n",
(int)written, __location__);
return false;
}
torture_comment(tctx, "write time %s\n",
nt_time_string(tctx, finfo2.basic_info.out.write_time));
if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
- torture_comment(tctx, "Server updated write_time (wrong!)\n");
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time (wrong!)\n");
ret = false;
}
nt_time_string(tctx, finfo2.basic_info.out.write_time));
if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
written = smbcli_write(cli->tree, fnum1, 0, "0123456789", 31, 10);
if (written != 10) {
- torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
+ torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)\n",
(int)written, __location__);
return false;
}
torture_comment(tctx, "write time %s\n",
nt_time_string(tctx, finfo2.basic_info.out.write_time));
if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
- torture_comment(tctx, "Server updated write_time (wrong!)\n");
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time (wrong!)\n");
ret = false;
}
nt_time_string(tctx, finfo2.basic_info.out.write_time));
if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
- torture_comment(tctx, "Server updated write_time after %.2f seconds"
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ if (diff < (used_delay / (double)1000000)) {
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds"
+ "(expected > %.2f) (wrong!)\n",
+ diff, used_delay / (double)1000000);
ret = false;
break;
}
torture_comment(tctx, "Server updated write_time after %.2f seconds"
- "(1sec == %.2f) (correct)\n",
- diff, sec);
+ "(correct)\n",
+ diff);
break;
}
fflush(stdout);
int fnum2;
bool ret = true;
ssize_t written;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_finfo_after_write\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
if (fnum1 == -1) {
ret = false;
goto done;
}
-
+
written = smbcli_write(cli2->tree, fnum2, 0, "x", 0, 1);
-
+
if (written != 1) {
torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1",
(int)written);
ret = false;
goto done;
}
-
+
finfo2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
finfo2.basic_info.in.file.path = fname;
-
+
status = smb_raw_pathinfo(cli2->tree, tctx, &finfo2);
-
+
if (!NT_STATUS_IS_OK(status)) {
torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s",
nt_errstr(status));
ret = false;
goto done;
}
-
+
if (finfo1.basic_info.out.create_time !=
finfo2.basic_info.out.create_time) {
torture_result(tctx, TORTURE_FAIL, __location__": create_time changed");
ret = false;
goto done;
}
-
+
if (finfo1.basic_info.out.access_time !=
finfo2.basic_info.out.access_time) {
torture_result(tctx, TORTURE_FAIL, __location__": access_time changed");
ret = false;
goto done;
}
-
+
if (finfo1.basic_info.out.write_time !=
finfo2.basic_info.out.write_time) {
torture_result(tctx, TORTURE_FAIL, __location__": write_time changed:\n"
ret = false;
goto done;
}
-
+
if (finfo1.basic_info.out.change_time !=
finfo2.basic_info.out.change_time) {
torture_result(tctx, TORTURE_FAIL, __location__": change_time changed");
ret = false;
goto done;
}
-
+
/* One of the two following calls updates the qpathinfo. */
-
+
/* If you had skipped the smbcli_write on fnum2, it would
* *not* have updated the stat on disk */
-
+
smbcli_close(cli2->tree, fnum2);
cli2 = NULL;
} while (0)
#define GET_INFO_FILE(finfo) do { \
+ struct timeval atv; \
+ struct timeval wtv; \
+ struct timeval_buf atvb; \
+ struct timeval_buf wtvb; \
NTSTATUS _status; \
_status = smb_raw_fileinfo(cli->tree, tctx, &finfo); \
if (!NT_STATUS_IS_OK(_status)) { \
nt_errstr(_status)); \
goto done; \
} \
+ nttime_to_timeval(&atv, finfo.basic_info.out.access_time); \
+ nttime_to_timeval(&wtv, finfo.basic_info.out.write_time); \
torture_comment(tctx, "fileinfo: Access(%s) Write(%s)\n", \
- nt_time_string(tctx, finfo.basic_info.out.access_time), \
- nt_time_string(tctx, finfo.basic_info.out.write_time)); \
+ timeval_str_buf(&atv, false, true, &atvb), \
+ timeval_str_buf(&wtv, false, true, &wtvb)); \
} while (0)
#define GET_INFO_FILE2(finfo) do { \
NTSTATUS _status; \
struct smbcli_state *cli,
struct smbcli_state *cli2)
{
- union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
- union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
+ union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
+ union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
const char *fname = BASEDIR "\\torture_file3.txt";
int fnum1 = -1;
bool ret = true;
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ //double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 1000000);
+ //int normal_delay = 1000000;
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update3\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
torture_comment(tctx, "Open the file handle\n");
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
finfo1 = finfo0;
finfo2 = finfo0;
finfo3 = finfo0;
- finfo4 = finfo0;
pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
pinfo0.basic_info.in.file.path = fname;
pinfo1 = pinfo0;
pinfo2 = pinfo0;
pinfo3 = pinfo0;
pinfo4 = pinfo0;
- pinfo5 = pinfo0;
/* get the initial times */
GET_INFO_BOTH(finfo0,pinfo0);
if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ if (diff < (used_delay / (double)1000000)) {
+ torture_result(tctx, TORTURE_FAIL, "111Server updated write_time after %.2f seconds "
+ "(write time update delay == %.2f) (wrong!)\n",
+ diff, used_delay / (double)1000000);
ret = false;
break;
}
torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (correct)\n",
- diff, sec);
+ "(correct)\n",
+ diff);
break;
}
smb_msleep(0.5 * msec);
if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
struct smbcli_state *cli,
struct smbcli_state *cli2)
{
- union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
- union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
+ union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
+ union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
const char *fname = BASEDIR "\\torture_file3a.txt";
int fnum1 = -1;
bool ret = true;
int i;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update3a\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
torture_comment(tctx, "Open the file handle\n");
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
finfo1 = finfo0;
finfo2 = finfo0;
finfo3 = finfo0;
- finfo4 = finfo0;
pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
pinfo0.basic_info.in.file.path = fname;
pinfo1 = pinfo0;
pinfo2 = pinfo0;
pinfo3 = pinfo0;
pinfo4 = pinfo0;
- pinfo5 = pinfo0;
/* get the initial times */
GET_INFO_BOTH(finfo0,pinfo0);
if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
+ if (diff < (used_delay / (double)1000000)) {
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
"(1sec == %.2f) (wrong!)\n",
diff, sec);
ret = false;
}
torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (correct)\n",
- diff, sec);
+ "(correct)\n",
+ diff);
break;
}
smb_msleep(0.5 * msec);
if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
struct smbcli_state *cli,
struct smbcli_state *cli2)
{
- union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
- union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
+ union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
+ union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
const char *fname = BASEDIR "\\torture_file3b.txt";
int fnum1 = -1;
bool ret = true;
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update3b\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
torture_comment(tctx, "Open the file handle\n");
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
finfo1 = finfo0;
finfo2 = finfo0;
finfo3 = finfo0;
- finfo4 = finfo0;
pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
pinfo0.basic_info.in.file.path = fname;
pinfo1 = pinfo0;
pinfo2 = pinfo0;
pinfo3 = pinfo0;
pinfo4 = pinfo0;
- pinfo5 = pinfo0;
/* get the initial times */
GET_INFO_BOTH(finfo0,pinfo0);
if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ if (diff < (used_delay / (double)1000000)) {
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds"
+ "(expected > %.2f) (wrong!)\n",
+ diff, used_delay / (double)1000000);
ret = false;
break;
}
torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (correct)\n",
- diff, sec);
+ "(write time update delay == %.2f) (correct)\n",
+ diff, used_delay / (double)1000000);
break;
}
smb_msleep(0.5 * msec);
if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
struct smbcli_state *cli,
struct smbcli_state *cli2)
{
- union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
- union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
+ union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
+ union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
const char *fname = BASEDIR "\\torture_file3c.txt";
int fnum1 = -1;
bool ret = true;
int i;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update3c\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
torture_comment(tctx, "Open the file handle\n");
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
finfo1 = finfo0;
finfo2 = finfo0;
finfo3 = finfo0;
- finfo4 = finfo0;
pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
pinfo0.basic_info.in.file.path = fname;
pinfo1 = pinfo0;
pinfo2 = pinfo0;
pinfo3 = pinfo0;
pinfo4 = pinfo0;
- pinfo5 = pinfo0;
/* get the initial times */
GET_INFO_BOTH(finfo0,pinfo0);
if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
struct smbcli_state *cli,
struct smbcli_state *cli2)
{
- union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
- union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
+ union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
+ union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
const char *fname = BASEDIR "\\torture_file4.txt";
int fnum1 = -1;
bool ret = true;
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update4\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
torture_comment(tctx, "Open the file handle\n");
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
finfo1 = finfo0;
finfo2 = finfo0;
finfo3 = finfo0;
- finfo4 = finfo0;
pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
pinfo0.basic_info.in.file.path = fname;
pinfo1 = pinfo0;
pinfo2 = pinfo0;
pinfo3 = pinfo0;
pinfo4 = pinfo0;
- pinfo5 = pinfo0;
/* get the initial times */
GET_INFO_BOTH(finfo0,pinfo0);
if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ if (diff < (used_delay / (double)1000000)) {
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds"
+ "(expected > %.2f) (wrong!)\n",
+ diff, used_delay / (double)1000000);
ret = false;
break;
}
torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (correct)\n",
- diff, sec);
+ "(write time update delay == %.2f) (correct)\n",
+ diff, used_delay / (double)1000000);
break;
}
smb_msleep(0.5 * msec);
if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update5\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
torture_comment(tctx, "Open the file handle\n");
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update5b\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
torture_comment(tctx, "Open the file handle\n");
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
ssize_t written;
struct timeval start;
struct timeval end;
- int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
int normal_delay = 2000000;
double sec = ((double)used_delay) / ((double)normal_delay);
int msec = 1000 * sec;
torture_comment(tctx, "\nRunning test_delayed_write_update6\n");
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
again:
torture_comment(tctx, "Open the file handle\n");
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
if (finfo5.basic_info.out.write_time > pinfo6.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
if (finfo5.basic_info.out.write_time > pinfo6.basic_info.out.write_time) {
double diff = timeval_elapsed(&start);
- torture_comment(tctx, "Server updated write_time after %.2f seconds "
- "(1sec == %.2f) (wrong!)\n",
- diff, sec);
+ torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
+ "(wrong!)\n",
+ diff);
ret = false;
break;
}
ZERO_STRUCT(finfo3);
ZERO_STRUCT(open_parms);
- if (!torture_setup_dir(cli, BASEDIR)) {
- return false;
- }
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
/* Create the file. */
fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
if (finfo2.basic_info.out.write_time != finfo3.basic_info.out.write_time) {
torture_result(tctx, TORTURE_FAIL,
- "qpathinfo time doens't match fileinfo time");
+ "qpathinfo time doesn't match fileinfo time");
ret = false;
}
return ret;
}
+/*
+ Test if creating a file in a directory with an open handle updates the
+ write timestamp (it should).
+*/
+static bool test_directory_update8(struct torture_context *tctx, struct smbcli_state *cli)
+{
+ union smb_fileinfo dir_info1, dir_info2;
+ union smb_open open_parms;
+ const char *fname = BASEDIR "\\torture_file.txt";
+ NTSTATUS status;
+ int fnum1 = -1;
+ int fnum2 = -1;
+ bool ret = true;
+ double used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
+ int normal_delay = 2000000;
+ double sec = ((double)used_delay) / ((double)normal_delay);
+ int msec = 1000 * sec;
+ TALLOC_CTX *mem_ctx = talloc_init("test_delayed_write_update8");
+
+ if (!mem_ctx) return false;
+
+ torture_comment(tctx, "\nRunning test directory write update\n");
+
+ torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
+
+ /* Open a handle on the directory - and leave it open. */
+ ZERO_STRUCT(open_parms);
+ open_parms.ntcreatex.level = RAW_OPEN_NTCREATEX;
+ open_parms.ntcreatex.in.flags = 0;
+ open_parms.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ;
+ open_parms.ntcreatex.in.file_attr = 0;
+ open_parms.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE|
+ NTCREATEX_SHARE_ACCESS_READ|
+ NTCREATEX_SHARE_ACCESS_WRITE;
+ open_parms.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
+ open_parms.ntcreatex.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
+ open_parms.ntcreatex.in.fname = BASEDIR;
+
+ status = smb_raw_open(cli->tree, mem_ctx, &open_parms);
+ talloc_free(mem_ctx);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ torture_result(tctx, TORTURE_FAIL,
+ "failed to open directory handle");
+ ret = false;
+ goto done;
+ }
+
+ fnum1 = open_parms.ntcreatex.out.file.fnum;
+
+ /* Store the returned write time. */
+ ZERO_STRUCT(dir_info1);
+ dir_info1.basic_info.out.write_time = open_parms.ntcreatex.out.write_time;
+
+ torture_comment(tctx, "Initial write time %s\n",
+ nt_time_string(tctx, dir_info1.basic_info.out.write_time));
+
+ /* sleep */
+ smb_msleep(3 * msec);
+
+ /* Now create a file within the directory. */
+ fnum2 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
+ if (fnum2 == -1) {
+ torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
+ ret = false;
+ goto done;
+ }
+ smbcli_close(cli->tree, fnum2);
+
+ /* Read the directory write time again. */
+ ZERO_STRUCT(dir_info2);
+ dir_info2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
+ dir_info2.basic_info.in.file.fnum = fnum1;
+
+ status = smb_raw_fileinfo(cli->tree, tctx, &dir_info2);
+
+ torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
+
+ /* Ensure it's been incremented. */
+ COMPARE_WRITE_TIME_GREATER(dir_info2, dir_info1);
+
+ torture_comment(tctx, "Updated write time %s\n",
+ nt_time_string(tctx, dir_info2.basic_info.out.write_time));
+
+ done:
+
+ if (fnum1 != -1)
+ smbcli_close(cli->tree, fnum1);
+ smbcli_unlink(cli->tree, fname);
+ smbcli_deltree(cli->tree, BASEDIR);
+
+ return ret;
+}
+
/*
testing of delayed update of write_time
*/
-struct torture_suite *torture_delay_write(void)
+struct torture_suite *torture_delay_write(TALLOC_CTX *ctx)
{
- struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "delaywrite");
+ struct torture_suite *suite = torture_suite_create(ctx, "delaywrite");
torture_suite_add_2smb_test(suite, "finfo update on close", test_finfo_after_write);
torture_suite_add_1smb_test(suite, "delayed update of write time", test_delayed_write_update);
torture_suite_add_2smb_test(suite, "delayed update of write time 5b", test_delayed_write_update5b);
torture_suite_add_2smb_test(suite, "delayed update of write time 6", test_delayed_write_update6);
torture_suite_add_1smb_test(suite, "timestamp resolution test", test_delayed_write_update7);
- torture_suite_add_1smb_test(suite, "timestamp resolution test", test_delayed_write_update7);
+ torture_suite_add_1smb_test(suite, "directory timestamp update test", test_directory_update8);
return suite;
}