samba-mirror/delaywrite.c at 3904c26ac860038518d4ffae781ddbbf23746715

mirror of https://github.com/samba-team/samba.git synced 2024-12-25 23:21:54 +03:00

Herb Lewis 7dec1e1eb1 delete duplicate test

Signed-off-by: Herb Lewis <herb@samba.org>
Reviewed-by: Richard Sharpe <realrichardsharpe@gmail.com>

Autobuild-User(master): Herb Lewis <herb@samba.org>
Autobuild-Date(master): Sat Jul  8 05:57:55 CEST 2017 on sn-devel-144

2017-07-08 05:57:55 +02:00

3095 lines

94 KiB

C

Raw Blame History

 /*
    Unix SMB/CIFS implementation.
    test suite for delayed write update
    Copyright (C) Volker Lendecke 2004
    Copyright (C) Andrew Tridgell 2004
    Copyright (C) Jeremy Allison 2004
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 #include "includes.h"
 #include "torture/torture.h"
 #include "libcli/raw/libcliraw.h"
 #include "libcli/raw/raw_proto.h"
 #include "system/time.h"
 #include "system/filesys.h"
 #include "libcli/libcli.h"
 #include "torture/util.h"
 #include "torture/basic/proto.h"
 #define BASEDIR "\\delaywrite"
 static bool test_delayed_write_update(struct torture_context *tctx, struct smbcli_state *cli)
 {
 	union smb_fileinfo finfo1, finfo2;
 	const char *fname = BASEDIR "\\torture_file.txt";
 	NTSTATUS status;
 	int fnum1 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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);
 	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_assert_int_equal(tctx, written, 1,
 				 "unexpected number of bytes written");
 	start = timeval_current();
 	end = timeval_add(&start, (120 * sec), 0);
 	while (!timeval_expired(&end)) {
 		status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
 		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);
 			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);
 	}
 	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);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 static bool test_delayed_write_update1(struct torture_context *tctx, struct smbcli_state *cli)
 {
 	union smb_fileinfo finfo1, finfo2, finfo3, pinfo4;
 	const char *fname = BASEDIR "\\torture_file1.txt";
 	NTSTATUS status;
 	int fnum1 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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);
 	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);
 	/* 3 second delay to ensure we get past any 2 second time
 	   granularity (older systems may have that) */
 	smb_msleep(3 * msec);
 	finfo1.all_info.level = RAW_FILEINFO_ALL_INFO;
 	finfo1.all_info.in.file.fnum = fnum1;
 	finfo2 = finfo1;
 	finfo3 = finfo1;
 	pinfo4.all_info.level = RAW_FILEINFO_ALL_INFO;
 	pinfo4.all_info.in.file.path = fname;
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
 	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));
 	/* 3 second delay to ensure we get past any 2 second time
 	   granularity (older systems may have that) */
 	smb_msleep(3 * msec);
 	/* Do a zero length SMBwrite call to truncate. */
 	written = smbcli_smbwrite(cli->tree, fnum1, "x", 1024, 0);
 	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);
 		torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 		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)
 		{
 			updated = true;
 			break;
 		}
 		fflush(stdout);
 		smb_msleep(1 * msec);
 		first = 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");
 	start = timeval_current();
 	end = timeval_add(&start, (10*sec), 0);
 	while (!timeval_expired(&end)) {
 		status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
 		torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 		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));
 		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)));
 		fflush(stdout);
 		smb_msleep(1 * msec);
 	}
 	torture_comment(tctx, "Server did not update write time within 10 "
 			"seconds. Good!\n");
 	fflush(stdout);
 	smb_msleep(2 * msec);
 	/* the close should trigger an write time update */
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
 	torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
 	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);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /* Updating with a SMBwrite of zero length
  * changes the write time immediately - even on expand. */
 static bool test_delayed_write_update1a(struct torture_context *tctx, struct smbcli_state *cli)
 {
 	union smb_fileinfo finfo1, finfo2, finfo3, pinfo4;
 	const char *fname = BASEDIR "\\torture_file1a.txt";
 	NTSTATUS status;
 	int fnum1 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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);
 	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);
 	/* 3 second delay to ensure we get past any 2 second time
 	   granularity (older systems may have that) */
 	smb_msleep(3 * msec);
 	finfo1.all_info.level = RAW_FILEINFO_ALL_INFO;
 	finfo1.all_info.in.file.fnum = fnum1;
 	finfo2 = finfo1;
 	finfo3 = finfo1;
 	pinfo4.all_info.level = RAW_FILEINFO_ALL_INFO;
 	pinfo4.all_info.in.file.path = fname;
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
 	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));
 	/* Do a zero length SMBwrite call to truncate. */
 	written = smbcli_smbwrite(cli->tree, fnum1, "x", 10240, 0);
 	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);
 		torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 		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)
 		{
 			updated = true;
 			break;
 		}
 		fflush(stdout);
 		smb_msleep(1 * msec);
 		first = 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");
 	start = timeval_current();
 	end = timeval_add(&start, (10*sec), 0);
 	while (!timeval_expired(&end)) {
 		status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
 		torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 		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));
 		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)));
 		fflush(stdout);
 		smb_msleep(1 * msec);
 	}
 	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);
 	fnum1 = -1;
 	status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
 	torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
 	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);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /* Updating with a SET_FILE_END_OF_FILE_INFO
  * changes the write time immediately - even on expand. */
 static bool test_delayed_write_update1b(struct torture_context *tctx, struct smbcli_state *cli)
 {
 	union smb_fileinfo finfo1, finfo2, finfo3, pinfo4;
 	const char *fname = BASEDIR "\\torture_file1b.txt";
 	NTSTATUS status;
 	int fnum1 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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);
 	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);
 	/* 3 second delay to ensure we get past any 2 second time
 	   granularity (older systems may have that) */
 	smb_msleep(3 * msec);
 	finfo1.all_info.level = RAW_FILEINFO_ALL_INFO;
 	finfo1.all_info.in.file.fnum = fnum1;
 	finfo2 = finfo1;
 	finfo3 = finfo1;
 	pinfo4.all_info.level = RAW_FILEINFO_ALL_INFO;
 	pinfo4.all_info.in.file.path = fname;
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
 	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));
 	/* Do a SET_END_OF_FILE_INFO call to truncate. */
 	status = smbcli_ftruncate(cli->tree, fnum1, (uint64_t)10240);
 	torture_assert_ntstatus_ok(tctx, status, "SET_END_OF_FILE 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);
 		torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 		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)
 		{
 			updated = true;
 			break;
 		}
 		fflush(stdout);
 		smb_msleep(1 * msec);
 		first = 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");
 	start = timeval_current();
 	end = timeval_add(&start, (10*sec), 0);
 	while (!timeval_expired(&end)) {
 		status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
 		torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 		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));
 		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)));
 		fflush(stdout);
 		smb_msleep(1 * msec);
 	}
 	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);
 	fnum1 = -1;
 	status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
 	torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
 	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);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /* Updating with a SET_ALLOCATION_INFO (truncate) does so immediately. */
 static bool test_delayed_write_update1c(struct torture_context *tctx, struct smbcli_state *cli)
 {
         union smb_setfileinfo parms;
 	union smb_fileinfo finfo1, finfo2, finfo3, pinfo4;
 	const char *fname = BASEDIR "\\torture_file1c.txt";
 	NTSTATUS status;
 	int fnum1 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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);
 	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);
 	/* 3 second delay to ensure we get past any 2 second time
 	   granularity (older systems may have that) */
 	smb_msleep(3 * msec);
 	finfo1.all_info.level = RAW_FILEINFO_ALL_INFO;
 	finfo1.all_info.in.file.fnum = fnum1;
 	finfo2 = finfo1;
 	finfo3 = finfo1;
 	pinfo4.all_info.level = RAW_FILEINFO_ALL_INFO;
 	pinfo4.all_info.in.file.path = fname;
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
 	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));
 	/* Do a SET_ALLOCATION_SIZE call to truncate. */
 	parms.allocation_info.level = RAW_SFILEINFO_ALLOCATION_INFO;
 	parms.allocation_info.in.file.fnum = fnum1;
 	parms.allocation_info.in.alloc_size = 0;
 	status = smb_raw_setfileinfo(cli->tree, &parms);
 	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);
 		torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 		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)
 		{
 			updated = true;
 			break;
 		}
 		fflush(stdout);
 		smb_msleep(1 * msec);
 		first = 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");
 	start = timeval_current();
 	end = timeval_add(&start, (10*sec), 0);
 	while (!timeval_expired(&end)) {
 		status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
 		torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 		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));
 		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)));
 		fflush(stdout);
 		smb_msleep(1 * msec);
 	}
 	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);
 	fnum1 = -1;
 	status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
 	torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
 	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);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /*
  * Do as above, but using 2 connections.
  */
 static bool test_delayed_write_update2(struct torture_context *tctx, struct smbcli_state *cli,
 									   struct smbcli_state *cli2)
 {
 	union smb_fileinfo finfo1, finfo2;
 	const char *fname = BASEDIR "\\torture_file.txt";
 	NTSTATUS status;
 	int fnum1 = -1;
 	int fnum2 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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;
 	union smb_flush flsh;
 	torture_comment(tctx, "\nRunning test_delayed_write_update2\n");
 	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_comment(tctx, "Failed to open %s\n", fname);
 		return false;
 	}
 	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));
 	/* 3 second delay to ensure we get past any 2 second time
 	   granularity (older systems may have that) */
 	smb_msleep(3 * msec);
 	{
 		/* Try using setfileinfo instead of write to update write time. */
 		union smb_setfileinfo sfinfo;
 		time_t t_set = time(NULL);
 		sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO;
 		sfinfo.basic_info.in.file.fnum = fnum1;
 		sfinfo.basic_info.in.create_time = finfo1.basic_info.out.create_time;
 		sfinfo.basic_info.in.access_time = finfo1.basic_info.out.access_time;
 		/* I tried this with both + and - ve to see if it makes a different.
 		   It doesn't - once the filetime is set via setfileinfo it stays that way. */
 #if 1
 		unix_to_nt_time(&sfinfo.basic_info.in.write_time, t_set - 30000);
 #else
 		unix_to_nt_time(&sfinfo.basic_info.in.write_time, t_set + 30000);
 #endif
 		sfinfo.basic_info.in.change_time = finfo1.basic_info.out.change_time;
 		sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib;
 		status = smb_raw_setfileinfo(cli->tree, &sfinfo);
 		torture_assert_ntstatus_ok(tctx, status, "sfileinfo failed");
 	}
 	finfo2.basic_info.in.file.path = fname;
 	status = smb_raw_pathinfo(cli2->tree, tctx, &finfo2);
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
 		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 (correct)\n");
 	} else {
 		torture_result(tctx, TORTURE_FAIL, "Server did not update write time (wrong!)\n");
 		ret = false;
 	}
 	/* Now try a write to see if the write time gets reset. */
 	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);
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
 		return false;
 	}
 	torture_comment(tctx, "Modified write time %s\n",
 	       nt_time_string(tctx, finfo1.basic_info.out.write_time));
 	torture_comment(tctx, "Doing a 10 byte write to extend the file and see if this changes the last write time.\n");
 	written =  smbcli_write(cli->tree, fnum1, 0, "0123456789", 1, 10);
 	if (written != 10) {
 		torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)\n",
 		       (int)written, __location__);
 		return false;
 	}
 	/* Just to prove to tridge that the an smbflush has no effect on
 	   the write time :-). The setfileinfo IS STICKY. JRA. */
 	torture_comment(tctx, "Doing flush after write\n");
 	flsh.flush.level	= RAW_FLUSH_FLUSH;
 	flsh.flush.in.file.fnum = fnum1;
 	status = smb_raw_flush(cli->tree, &flsh);
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("smbflush failed: %s\n", nt_errstr(status)));
 		return false;
 	}
 	/* Once the time was set using setfileinfo then it stays set - writes
 	   don't have any effect. But make sure. */
 	start = timeval_current();
 	end = timeval_add(&start, (15*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) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds"
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		fflush(stdout);
 		smb_msleep(1 * msec);
 	}
 	if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write time (correct)\n");
 	}
 	fflush(stdout);
 	smb_msleep(2 * msec);
 	fnum2 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
 	if (fnum2 == -1) {
 		torture_result(tctx, TORTURE_FAIL, "Failed to open %s\n", fname);
 		return false;
 	}
 	torture_comment(tctx, "Doing a 10 byte write to extend the file via second fd and see if this changes the last write time.\n");
 	written =  smbcli_write(cli->tree, fnum2, 0, "0123456789", 11, 10);
 	if (written != 10) {
 		torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)\n",
 		       (int)written, __location__);
 		return false;
 	}
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
 		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_result(tctx, TORTURE_FAIL, "Server updated write_time (wrong!)\n");
 		ret = false;
 	}
 	torture_comment(tctx, "Closing the first fd to see if write time updated.\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	torture_comment(tctx, "Doing a 10 byte write to extend the file via second fd and see if this changes the last write time.\n");
 	written =  smbcli_write(cli->tree, fnum2, 0, "0123456789", 21, 10);
 	if (written != 10) {
 		torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)\n",
 		       (int)written, __location__);
 		return false;
 	}
 	finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo1.basic_info.in.file.fnum = fnum2;
 	finfo2 = finfo1;
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
 		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_result(tctx, TORTURE_FAIL, "Server updated write_time (wrong!)\n");
 		ret = false;
 	}
 	/* Once the time was set using setfileinfo then it stays set - writes
 	   don't have any effect. But make sure. */
 	start = timeval_current();
 	end = timeval_add(&start, (15*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) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		fflush(stdout);
 		smb_msleep(1 * msec);
 	}
 	if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write time (correct)\n");
 	}
 	torture_comment(tctx, "Closing second fd to see if write time updated.\n");
 	smbcli_close(cli->tree, fnum2);
 	fnum2 = -1;
 	fnum1 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
 	if (fnum1 == -1) {
 		torture_comment(tctx, "Failed to open %s\n", fname);
 		return false;
 	}
 	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);
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
 		return false;
 	}
 	torture_comment(tctx, "Second open initial write time %s\n",
 	       nt_time_string(tctx, finfo1.basic_info.out.write_time));
 	smb_msleep(10 * msec);
 	torture_comment(tctx, "Doing a 10 byte write to extend the file to see if this changes the last write time.\n");
 	written =  smbcli_write(cli->tree, fnum1, 0, "0123456789", 31, 10);
 	if (written != 10) {
 		torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)\n",
 		       (int)written, __location__);
 		return false;
 	}
 	finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo1.basic_info.in.file.fnum = fnum1;
 	finfo2 = finfo1;
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
 	if (!NT_STATUS_IS_OK(status)) {
 		DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
 		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_result(tctx, TORTURE_FAIL, "Server updated write_time (wrong!)\n");
 		ret = false;
 	}
 	/* Now the write time should be updated again */
 	start = timeval_current();
 	end = timeval_add(&start, (15*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) {
 			double diff = timeval_elapsed(&start);
 			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"
 					"(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!)\n");
 		ret = false;
 	}
 	/* One more test to do. We should read the filetime via findfirst on the
 	   second connection to ensure it's the same. This is very easy for a Windows
 	   server but a bastard to get right on a POSIX server. JRA. */
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /* Windows does obviously not update the stat info during a write call. I
  * *think* this is the problem causing a spurious Excel 2003 on XP error
  * message when saving a file. Excel does a setfileinfo, writes, and then does
  * a getpath(!)info. Or so... For Samba sometimes it displays an error message
  * that the file might have been changed in between. What i've been able to
  * trace down is that this happens if the getpathinfo after the write shows a
  * different last write time than the setfileinfo showed. This is really
  * nasty....
  */
 static bool test_finfo_after_write(struct torture_context *tctx, struct smbcli_state *cli,
 								   struct smbcli_state *cli2)
 {
 	union smb_fileinfo finfo1, finfo2;
 	const char *fname = BASEDIR "\\torture_file.txt";
 	NTSTATUS status;
 	int fnum1 = -1;
 	int fnum2;
 	bool ret = true;
 	ssize_t written;
 	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");
 	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;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo1.basic_info.in.file.fnum = fnum1;
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
 	if (!NT_STATUS_IS_OK(status)) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", nt_errstr(status));
 		goto done;
 	}
 	smb_msleep(1 * msec);
 	written =  smbcli_write(cli->tree, fnum1, 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;
 	}
 	fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
 	if (fnum2 == -1) {
 		torture_result(tctx, TORTURE_FAIL, __location__": failed to open 2nd time - %s",
 		       smbcli_errstr(cli2->tree));
 		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"
 					   "write time conn 1 = %s, conn 2 = %s",
 		       nt_time_string(tctx, finfo1.basic_info.out.write_time),
 		       nt_time_string(tctx, finfo2.basic_info.out.write_time));
 		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;
 	/* This call is only for the people looking at ethereal :-) */
 	finfo2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo2.basic_info.in.file.path = fname;
 	status = smb_raw_pathinfo(cli->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;
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 #define COMPARE_WRITE_TIME_CMP(given, correct, cmp) do { \
 	uint64_t r = 10*1000*1000; \
 	NTTIME g = (given).basic_info.out.write_time; \
 	NTTIME gr = (g / r) * r; \
 	NTTIME c = (correct).basic_info.out.write_time; \
 	NTTIME cr = (c / r) * r; \
 	bool strict = torture_setting_bool(tctx, "strict mode", false); \
 	bool err = false; \
 	if (strict && (g cmp c)) { \
 		err = true; \
 	} else if ((g cmp c) && (gr cmp cr)) { \
 		/* handle filesystem without high resolution timestamps */ \
 		err = true; \
 	} \
 	if (err) { \
 		torture_result(tctx, TORTURE_FAIL, __location__": wrong write_time (%s)%s(%llu) %s (%s)%s(%llu)", \
 				#given, nt_time_string(tctx, g), (unsigned long long)g, \
 				#cmp, #correct, nt_time_string(tctx, c), (unsigned long long)c); \
 		ret = false; \
 		goto done; \
 	} \
 } while (0)
 #define COMPARE_WRITE_TIME_EQUAL(given,correct) \
 	COMPARE_WRITE_TIME_CMP(given,correct,!=)
 #define COMPARE_WRITE_TIME_GREATER(given,correct) \
 	COMPARE_WRITE_TIME_CMP(given,correct,<=)
 #define COMPARE_WRITE_TIME_LESS(given,correct) \
 	COMPARE_WRITE_TIME_CMP(given,correct,>=)
 #define COMPARE_ACCESS_TIME_CMP(given, correct, cmp) do { \
 	NTTIME g = (given).basic_info.out.access_time; \
 	NTTIME c = (correct).basic_info.out.access_time; \
 	if (g cmp c) { \
 		torture_result(tctx, TORTURE_FAIL, __location__": wrong access_time (%s)%s %s (%s)%s", \
 				#given, nt_time_string(tctx, g), \
 				#cmp, #correct, nt_time_string(tctx, c)); \
 		ret = false; \
 		goto done; \
 	} \
 } while (0)
 #define COMPARE_ACCESS_TIME_EQUAL(given,correct) \
 	COMPARE_ACCESS_TIME_CMP(given,correct,!=)
 #define COMPARE_BOTH_TIMES_EQUAL(given,correct) do { \
 	COMPARE_ACCESS_TIME_EQUAL(given,correct); \
 	COMPARE_WRITE_TIME_EQUAL(given,correct); \
 } while (0)
 #define GET_INFO_FILE(finfo) do { \
 	NTSTATUS _status; \
 	_status = smb_raw_fileinfo(cli->tree, tctx, &finfo); \
 	if (!NT_STATUS_IS_OK(_status)) { \
 		ret = false; \
 		torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", \
 			       nt_errstr(_status)); \
 		goto done; \
 	} \
 	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)); \
 } while (0)
 #define GET_INFO_FILE2(finfo) do { \
 	NTSTATUS _status; \
 	_status = smb_raw_fileinfo(cli2->tree, tctx, &finfo); \
 	if (!NT_STATUS_IS_OK(_status)) { \
 		ret = false; \
 		torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", \
 			       nt_errstr(_status)); \
 		goto done; \
 	} \
 	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)); \
 } while (0)
 #define GET_INFO_PATH(pinfo) do { \
 	NTSTATUS _status; \
 	_status = smb_raw_pathinfo(cli2->tree, tctx, &pinfo); \
 	if (!NT_STATUS_IS_OK(_status)) { \
 		torture_result(tctx, TORTURE_FAIL, __location__": pathinfo failed: %s", \
 			       nt_errstr(_status)); \
 		ret = false; \
 		goto done; \
 	} \
 	torture_comment(tctx, "pathinfo: Access(%s) Write(%s)\n", \
 			nt_time_string(tctx, pinfo.basic_info.out.access_time), \
 			nt_time_string(tctx, pinfo.basic_info.out.write_time)); \
 } while (0)
 #define GET_INFO_BOTH(finfo,pinfo) do { \
 	GET_INFO_FILE(finfo); \
 	GET_INFO_PATH(pinfo); \
 	COMPARE_BOTH_TIMES_EQUAL(finfo,pinfo); \
 } while (0)
 #define SET_INFO_FILE_EX(finfo, wrtime, tree, tfnum) do { \
 	NTSTATUS _status; \
 	union smb_setfileinfo sfinfo; \
 	sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO; \
 	sfinfo.basic_info.in.file.fnum = tfnum; \
 	sfinfo.basic_info.in.create_time = 0; \
 	sfinfo.basic_info.in.access_time = 0; \
 	unix_to_nt_time(&sfinfo.basic_info.in.write_time, (wrtime)); \
 	sfinfo.basic_info.in.change_time = 0; \
 	sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib; \
 	_status = smb_raw_setfileinfo(tree, &sfinfo); \
 	if (!NT_STATUS_IS_OK(_status)) { \
 		torture_result(tctx, TORTURE_FAIL, __location__": setfileinfo failed: %s", \
 			       nt_errstr(_status)); \
 		ret = false; \
 		goto done; \
 	} \
 } while (0)
 #define SET_INFO_FILE(finfo, wrtime) \
 	SET_INFO_FILE_EX(finfo, wrtime, cli->tree, fnum1)
 #define SET_INFO_FILE_NS(finfo, wrtime, ns, tree, tfnum) do { \
 	NTSTATUS _status; \
 	union smb_setfileinfo sfinfo; \
 	sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO; \
 	sfinfo.basic_info.in.file.fnum = tfnum; \
 	sfinfo.basic_info.in.create_time = 0; \
 	sfinfo.basic_info.in.access_time = 0; \
 	unix_to_nt_time(&sfinfo.basic_info.in.write_time, (wrtime)); \
 	sfinfo.basic_info.in.write_time += (ns); \
 	sfinfo.basic_info.in.change_time = 0; \
 	sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib; \
 	_status = smb_raw_setfileinfo(tree, &sfinfo); \
 	if (!NT_STATUS_IS_OK(_status)) { \
 		torture_result(tctx, TORTURE_FAIL, __location__": setfileinfo failed: %s", \
 			       nt_errstr(_status)); \
 		ret = false; \
 		goto done; \
 	} \
 } while (0)
 static bool test_delayed_write_update3(struct torture_context *tctx,
 				       struct smbcli_state *cli,
 				       struct smbcli_state *cli2)
 {
 	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;
 	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_update3\n");
 	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 (fnum1 == -1) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo0.basic_info.in.file.fnum = fnum1;
 	finfo1 = finfo0;
 	finfo2 = finfo0;
 	finfo3 = finfo0;
 	pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	pinfo0.basic_info.in.file.path = fname;
 	pinfo1 = pinfo0;
 	pinfo2 = pinfo0;
 	pinfo3 = pinfo0;
 	pinfo4 = pinfo0;
 	/* get the initial times */
 	GET_INFO_BOTH(finfo0,pinfo0);
 	/*
 	 * make sure the write time is updated 2 seconds later
 	 * calcuated from the first write
 	 * (but expect upto 5 seconds extra time for a busy server)
 	 */
 	start = timeval_current();
 	end = timeval_add(&start, 7 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_FILE(finfo1);
 		if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			if (diff < (used_delay / (double)1000000)) {
 				torture_result(tctx, TORTURE_FAIL, "Server 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 "
 					"(correct)\n",
 					diff);
 			break;
 		}
 		smb_msleep(0.5 * msec);
 	}
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
 	/* sure any further write doesn't update the write time */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
 	if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	GET_INFO_BOTH(finfo3,pinfo3);
 	COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 	/*
 	 * the close updates the write time to the time of the close
 	 * and not to the time of the last write!
 	 */
 	torture_comment(tctx, "Close the file handle\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	GET_INFO_PATH(pinfo4);
 	COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
 	if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
 		torture_comment(tctx, "Server updated the write_time on close (correct)\n");
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /*
  * Show that a truncate write always updates the write time even
  * if an initial write has already updated the write time.
  */
 static bool test_delayed_write_update3a(struct torture_context *tctx,
 				        struct smbcli_state *cli,
 				        struct smbcli_state *cli2)
 {
 	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;
 	ssize_t written;
 	int i;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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 (fnum1 == -1) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo0.basic_info.in.file.fnum = fnum1;
 	finfo1 = finfo0;
 	finfo2 = finfo0;
 	finfo3 = finfo0;
 	pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	pinfo0.basic_info.in.file.path = fname;
 	pinfo1 = pinfo0;
 	pinfo2 = pinfo0;
 	pinfo3 = pinfo0;
 	pinfo4 = pinfo0;
 	/* get the initial times */
 	GET_INFO_BOTH(finfo0,pinfo0);
 	/*
 	 * sleep some time, to demonstrate the handling of write times
 	 * doesn't depend on the time since the open
 	 */
 	smb_msleep(5 * msec);
 	/* get the initial times */
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
 	/*
 	 * make sure the write time is updated 2 seconds later
 	 * calcuated from the first write
 	 * (but expect upto 5 seconds extra time for a busy server)
 	 */
 	start = timeval_current();
 	end = timeval_add(&start, 7 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_FILE(finfo1);
 		if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			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;
 				break;
 			}
 			torture_comment(tctx, "Server updated write_time after %.2f seconds "
 					"(correct)\n",
 					diff);
 			break;
 		}
 		smb_msleep(0.5 * msec);
 	}
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
 	smb_msleep(3 * msec);
 	/*
 	 * demonstrate that a truncate write always
 	 * updates the write time immediately
 	 */
 	for (i=0; i < 3; i++) {
 		smb_msleep(2 * msec);
 		/* do a write */
 		torture_comment(tctx, "Do a truncate SMBwrite [%d] on the file handle\n", i);
 		written = smbcli_smbwrite(cli->tree, fnum1, "x", 10240, 0);
 		if (written != 0) {
 			torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 0", (int)written);
 			ret = false;
 			goto done;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
 		finfo1 = finfo2;
 	}
 	smb_msleep(3 * msec);
 	/* sure any further write doesn't update the write time */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
 	if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(3 * msec);
 	/* get the initial times */
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1, finfo2);
 	/*
 	 * demonstrate that a truncate write always
 	 * updates the write time immediately
 	 */
 	for (i=0; i < 3; i++) {
 		smb_msleep(2 * msec);
 		/* do a write */
 		torture_comment(tctx, "Do a truncate SMBwrite [%d] on the file handle\n", i);
 		written = smbcli_smbwrite(cli->tree, fnum1, "x", 512, 0);
 		if (written != 0) {
 			torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 0", (int)written);
 			ret = false;
 			goto done;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
 		finfo1 = finfo2;
 	}
 	/* sleep */
 	smb_msleep(3 * msec);
 	GET_INFO_BOTH(finfo3,pinfo3);
 	COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 	/*
 	 * the close doesn't update the write time
 	 */
 	torture_comment(tctx, "Close the file handle\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	GET_INFO_PATH(pinfo4);
 	COMPARE_WRITE_TIME_EQUAL(pinfo4, pinfo3);
 	if (pinfo4.basic_info.out.write_time == pinfo3.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /*
  * Show a close after write updates the write timestamp to
  * the close time, not the last write time.
  */
 static bool test_delayed_write_update3b(struct torture_context *tctx,
 				        struct smbcli_state *cli,
 				        struct smbcli_state *cli2)
 {
 	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;
 	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");
 	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 (fnum1 == -1) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo0.basic_info.in.file.fnum = fnum1;
 	finfo1 = finfo0;
 	finfo2 = finfo0;
 	finfo3 = finfo0;
 	pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	pinfo0.basic_info.in.file.path = fname;
 	pinfo1 = pinfo0;
 	pinfo2 = pinfo0;
 	pinfo3 = pinfo0;
 	pinfo4 = pinfo0;
 	/* get the initial times */
 	GET_INFO_BOTH(finfo0,pinfo0);
 	/*
 	 * sleep some time, to demonstrate the handling of write times
 	 * doesn't depend on the time since the open
 	 */
 	smb_msleep(5 * msec);
 	/* get the initial times */
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
 	/*
 	 * make sure the write time is updated 2 seconds later
 	 * calcuated from the first write
 	 * (but expect upto 5 seconds extra time for a busy server)
 	 */
 	start = timeval_current();
 	end = timeval_add(&start, 7 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_FILE(finfo1);
 		if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			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 "
 					"(write time update delay == %.2f) (correct)\n",
 					diff, used_delay / (double)1000000);
 			break;
 		}
 		smb_msleep(0.5 * msec);
 	}
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
 	/* sure any further write doesn't update the write time */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
 	if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	GET_INFO_BOTH(finfo3,pinfo3);
 	COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 	/*
 	 * the close updates the write time to the time of the close
 	 * and not to the time of the last write!
 	 */
 	torture_comment(tctx, "Close the file handle\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	GET_INFO_PATH(pinfo4);
 	COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
 	if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
 		torture_comment(tctx, "Server updated the write_time on close (correct)\n");
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /*
  * Check that a write after a truncate write doesn't update
  * the timestamp, but a truncate write after a write does.
  * Also prove that a close after a truncate write updates the
  * timestamp to current, not the time of last write.
  */
 static bool test_delayed_write_update3c(struct torture_context *tctx,
 				        struct smbcli_state *cli,
 				        struct smbcli_state *cli2)
 {
 	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;
 	ssize_t written;
 	int i;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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 (fnum1 == -1) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo0.basic_info.in.file.fnum = fnum1;
 	finfo1 = finfo0;
 	finfo2 = finfo0;
 	finfo3 = finfo0;
 	pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	pinfo0.basic_info.in.file.path = fname;
 	pinfo1 = pinfo0;
 	pinfo2 = pinfo0;
 	pinfo3 = pinfo0;
 	pinfo4 = pinfo0;
 	/* get the initial times */
 	GET_INFO_BOTH(finfo0,pinfo0);
 	/*
 	 * sleep some time, to demonstrate the handling of write times
 	 * doesn't depend on the time since the open
 	 */
 	smb_msleep(5 * msec);
 	/* get the initial times */
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
 	/*
 	 * demonstrate that a truncate write always
 	 * updates the write time immediately
 	 */
 	for (i=0; i < 3; i++) {
 		smb_msleep(2 * msec);
 		/* do a write */
 		torture_comment(tctx, "Do a truncate SMBwrite [%d] on the file handle\n", i);
 		written = smbcli_smbwrite(cli->tree, fnum1, "x", 512, 0);
 		if (written != 0) {
 			torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 0", (int)written);
 			ret = false;
 			goto done;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
 		finfo1 = finfo2;
 	}
 	start = timeval_current();
 	end = timeval_add(&start, 7 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_FILE(finfo2);
 		if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
 	if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	/* get the initial times */
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1, finfo2);
 	/*
 	 * demonstrate that a truncate write always
 	 * updates the write time immediately
 	 */
 	for (i=0; i < 3; i++) {
 		smb_msleep(2 * msec);
 		/* do a write */
 		torture_comment(tctx, "Do a truncate write [%d] on the file handle\n", i);
 		written = smbcli_smbwrite(cli->tree, fnum1, "x", 512, 0);
 		if (written != 0) {
 			torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 0", (int)written);
 			ret = false;
 			goto done;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
 		finfo1 = finfo2;
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
 	/* sure any further write doesn't update the write time */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
 	if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	GET_INFO_BOTH(finfo3,pinfo3);
 	COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 	/*
 	 * the close updates the write time to the time of the close
 	 * and not to the time of the last write!
 	 */
 	torture_comment(tctx, "Close the file handle\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	GET_INFO_PATH(pinfo4);
 	COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
 	if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
 		torture_comment(tctx, "Server updated the write_time on close (correct)\n");
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /*
  * Show only the first write updates the timestamp, and a close
  * after writes updates to current (I think this is the same
  * as test 3b. JRA).
  */
 static bool test_delayed_write_update4(struct torture_context *tctx,
 				       struct smbcli_state *cli,
 				       struct smbcli_state *cli2)
 {
 	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;
 	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");
 	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 (fnum1 == -1) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo0.basic_info.in.file.fnum = fnum1;
 	finfo1 = finfo0;
 	finfo2 = finfo0;
 	finfo3 = finfo0;
 	pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	pinfo0.basic_info.in.file.path = fname;
 	pinfo1 = pinfo0;
 	pinfo2 = pinfo0;
 	pinfo3 = pinfo0;
 	pinfo4 = pinfo0;
 	/* get the initial times */
 	GET_INFO_BOTH(finfo0,pinfo0);
 	/* sleep a bit */
 	smb_msleep(5 * msec);
 	/* do a write */
 	torture_comment(tctx, "Do a write on the file handle\n");
 	written = smbcli_write(cli->tree, fnum1, 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;
 	}
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1,finfo0);
 	/*
 	 * make sure the write time is updated 2 seconds later
 	 * calcuated from the first write
 	 * (but expect upto 3 seconds extra time for a busy server)
 	 */
 	start = timeval_current();
 	end = timeval_add(&start, 5 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* get the times after the first write */
 		GET_INFO_FILE(finfo1);
 		if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			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 "
 					"(write time update delay == %.2f) (correct)\n",
 					diff, used_delay / (double)1000000);
 			break;
 		}
 		smb_msleep(0.5 * msec);
 	}
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
 	/* sure any further write doesn't update the write time */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo2,pinfo2);
 		if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
 	if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not updatewrite_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	GET_INFO_BOTH(finfo3,pinfo3);
 	COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 	/*
 	 * the close updates the write time to the time of the close
 	 * and not to the time of the last write!
 	 */
 	torture_comment(tctx, "Close the file handle\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	GET_INFO_PATH(pinfo4);
 	COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
 	if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
 		torture_comment(tctx, "Server updated the write_time on close (correct)\n");
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /*
  * Show writes and closes have no effect on updating times once a SETWRITETIME is done.
  */
 static bool test_delayed_write_update5(struct torture_context *tctx,
 				       struct smbcli_state *cli,
 				       struct smbcli_state *cli2)
 {
 	union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
 	union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6;
 	const char *fname = BASEDIR "\\torture_file5.txt";
 	int fnum1 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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 (fnum1 == -1) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo0.basic_info.in.file.fnum = fnum1;
 	finfo1 = finfo0;
 	finfo2 = finfo0;
 	finfo3 = finfo0;
 	finfo4 = finfo0;
 	finfo5 = 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;
 	pinfo6 = pinfo0;
 	/* get the initial times */
 	GET_INFO_BOTH(finfo0,pinfo0);
 	/* do a write */
 	torture_comment(tctx, "Do a write on the file handle\n");
 	written = smbcli_write(cli->tree, fnum1, 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;
 	}
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
 	torture_comment(tctx, "Set write time in the future on the file handle\n");
 	SET_INFO_FILE(finfo0, time(NULL) + 86400);
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
 	torture_comment(tctx, "Set write time in the past on the file handle\n");
 	SET_INFO_FILE(finfo0, time(NULL) - 86400);
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
 	/* make sure the 2 second delay from the first write are canceled */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* get the times after the first write */
 		GET_INFO_BOTH(finfo3,pinfo3);
 		if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo3,pinfo3);
 	COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 	if (finfo3.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sure any further write doesn't update the write time */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo4,pinfo4);
 		if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo4,pinfo4);
 	COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
 	if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	GET_INFO_BOTH(finfo5,pinfo5);
 	COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
 	/*
 	 * the close doesn't update the write time
 	 */
 	torture_comment(tctx, "Close the file handle\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	GET_INFO_PATH(pinfo6);
 	COMPARE_WRITE_TIME_EQUAL(pinfo6, pinfo5);
 	if (pinfo6.basic_info.out.write_time == pinfo5.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /*
  * Show truncate writes and closes have no effect on updating times once a SETWRITETIME is done.
  */
 static bool test_delayed_write_update5b(struct torture_context *tctx,
 				        struct smbcli_state *cli,
 				        struct smbcli_state *cli2)
 {
 	union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
 	union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6;
 	const char *fname = BASEDIR "\\torture_fileb.txt";
 	int fnum1 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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");
 	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 (fnum1 == -1) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo0.basic_info.in.file.fnum = fnum1;
 	finfo1 = finfo0;
 	finfo2 = finfo0;
 	finfo3 = finfo0;
 	finfo4 = finfo0;
 	finfo5 = 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;
 	pinfo6 = pinfo0;
 	/* get the initial times */
 	GET_INFO_BOTH(finfo0,pinfo0);
 	/* do a write */
 	torture_comment(tctx, "Do a write on the file handle\n");
 	written = smbcli_write(cli->tree, fnum1, 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;
 	}
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
 	torture_comment(tctx, "Set write time in the future on the file handle\n");
 	SET_INFO_FILE(finfo0, time(NULL) + 86400);
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
 	torture_comment(tctx, "Set write time in the past on the file handle\n");
 	SET_INFO_FILE(finfo0, time(NULL) - 86400);
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
 	/* make sure the 2 second delay from the first write are canceled */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* get the times after the first write */
 		GET_INFO_BOTH(finfo3,pinfo3);
 		if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo3,pinfo3);
 	COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 	if (finfo3.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* Do any further write (truncates) update the write time ? */
 	start = timeval_current();
 	end = timeval_add(&start, 15 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a truncate write on the file handle\n");
 		written = smbcli_smbwrite(cli->tree, fnum1, "x", 1024, 0);
 		if (written != 0) {
 			torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
 			ret = false;
 			goto done;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo4,pinfo4);
 		if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo4,pinfo4);
 	COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
 	if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	GET_INFO_BOTH(finfo5,pinfo5);
 	COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
 	/*
 	 * the close doesn't update the write time
 	 */
 	torture_comment(tctx, "Close the file handle\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	GET_INFO_PATH(pinfo6);
 	COMPARE_WRITE_TIME_EQUAL(pinfo6, pinfo5);
 	if (pinfo6.basic_info.out.write_time == pinfo5.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 /*
  * Open 2 handles on a file. Write one one and then set the
  * WRITE TIME explicitly on the other. Ensure the write time
  * update is cancelled. Ensure the write time is updated to
  * the close time when the non-explicit set handle is closed.
  *
  */
 static bool test_delayed_write_update6(struct torture_context *tctx,
 				       struct smbcli_state *cli,
 				       struct smbcli_state *cli2)
 {
 	union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
 	union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6, pinfo7;
 	const char *fname = BASEDIR "\\torture_file6.txt";
 	int fnum1 = -1;
 	int fnum2 = -1;
 	bool ret = true;
 	ssize_t written;
 	struct timeval start;
 	struct timeval end;
 	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;
 	bool first = true;
 	torture_comment(tctx, "\nRunning test_delayed_write_update6\n");
 	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 (fnum1 == -1) {
 		ret = false;
 		torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 		goto done;
 	}
 	if (fnum2 == -1) {
 		torture_comment(tctx, "Open the 2nd file handle on 2nd connection\n");
 		fnum2 = smbcli_open(cli2->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
 		if (fnum2 == -1) {
 			ret = false;
 			torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 			goto done;
 		}
 	}
 	finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo0.basic_info.in.file.fnum = fnum1;
 	finfo1 = finfo0;
 	finfo2 = finfo0;
 	finfo3 = finfo0;
 	finfo4 = finfo0;
 	finfo5 = 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;
 	pinfo6 = pinfo0;
 	pinfo7 = pinfo0;
 	/* get the initial times */
 	GET_INFO_BOTH(finfo0,pinfo0);
 	/* do a write */
 	torture_comment(tctx, "Do a write on the file handle\n");
 	written = smbcli_write(cli->tree, fnum1, 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;
 	}
 	GET_INFO_BOTH(finfo1,pinfo1);
 	COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
 	torture_comment(tctx, "Set write time in the future on the 2nd file handle\n");
 	SET_INFO_FILE_EX(finfo0, time(NULL) + 86400, cli2->tree, fnum2);
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
 	torture_comment(tctx, "Set write time in the past on the 2nd file handle\n");
 	SET_INFO_FILE_EX(finfo0, time(NULL) - 86400, cli2->tree, fnum2);
 	GET_INFO_BOTH(finfo2,pinfo2);
 	COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
 	/* make sure the 2 second delay from the first write are canceled */
 	start = timeval_current();
 	end = timeval_add(&start, 10 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* get the times after the first write */
 		GET_INFO_BOTH(finfo3,pinfo3);
 		if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo3,pinfo3);
 	COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 	if (finfo3.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sure any further write doesn't update the write time */
 	start = timeval_current();
 	end = timeval_add(&start, 10 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the file handle\n");
 		written = smbcli_write(cli->tree, fnum1, 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;
 		}
 		/* get the times after the write */
 		GET_INFO_BOTH(finfo4,pinfo4);
 		if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	GET_INFO_BOTH(finfo4,pinfo4);
 	COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
 	if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update write_time (correct)\n");
 	}
 	/* sleep */
 	smb_msleep(5 * msec);
 	GET_INFO_BOTH(finfo5,pinfo5);
 	COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
 	/*
 	 * the close updates the write time to the time of the close
 	 * as the write time was set on the 2nd handle
 	 */
 	torture_comment(tctx, "Close the file handle\n");
 	smbcli_close(cli->tree, fnum1);
 	fnum1 = -1;
 	GET_INFO_PATH(pinfo6);
 	COMPARE_WRITE_TIME_GREATER(pinfo6, pinfo5);
 	if (pinfo6.basic_info.out.write_time > pinfo5.basic_info.out.write_time) {
 		torture_comment(tctx, "Server updated the write_time on close (correct)\n");
 	}
 	/* See what the second write handle thinks the time is ? */
 	finfo5.basic_info.in.file.fnum = fnum2;
 	GET_INFO_FILE2(finfo5);
 	COMPARE_WRITE_TIME_EQUAL(finfo5, pinfo6);
 	/* See if we have lost the sticky write time on handle2 */
 	smb_msleep(3 * msec);
 	torture_comment(tctx, "Have we lost the sticky write time ?\n");
 	/* Make sure any further normal write doesn't update the write time */
 	start = timeval_current();
 	end = timeval_add(&start, 10 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a write on the second file handle\n");
 		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;
 		}
 		/* get the times after the write */
 		GET_INFO_FILE2(finfo5);
 		GET_INFO_PATH(pinfo6);
 		if (finfo5.basic_info.out.write_time > pinfo6.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	/* What about a truncate write ? */
 	start = timeval_current();
 	end = timeval_add(&start, 10 * sec, 0);
 	while (!timeval_expired(&end)) {
 		/* do a write */
 		torture_comment(tctx, "Do a truncate write on the second file handle\n");
 		written = smbcli_write(cli2->tree, fnum2, 0, "x", 0, 0);
 		if (written != 0) {
 			torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
 			ret = false;
 			goto done;
 		}
 		/* get the times after the write */
 		GET_INFO_FILE2(finfo5);
 		GET_INFO_PATH(pinfo6);
 		if (finfo5.basic_info.out.write_time > pinfo6.basic_info.out.write_time) {
 			double diff = timeval_elapsed(&start);
 			torture_result(tctx, TORTURE_FAIL, "Server updated write_time after %.2f seconds "
 					"(wrong!)\n",
 					diff);
 			ret = false;
 			break;
 		}
 		smb_msleep(1 * msec);
 	}
 	/* keep the 2nd handle open and rerun tests */
 	if (first) {
 		first = false;
 		goto again;
 	}
 	/*
 	 * closing the 2nd handle will cause no write time update
 	 * as the write time was explicit set on this handle
 	 */
 	torture_comment(tctx, "Close the 2nd file handle\n");
 	smbcli_close(cli2->tree, fnum2);
 	fnum2 = -1;
 	GET_INFO_PATH(pinfo7);
 	COMPARE_WRITE_TIME_EQUAL(pinfo7, pinfo6);
 	if (pinfo7.basic_info.out.write_time == pinfo6.basic_info.out.write_time) {
 		torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
 	}
  done:
 	if (fnum1 != -1)
 		smbcli_close(cli->tree, fnum1);
 	if (fnum2 != -1)
 		smbcli_close(cli2->tree, fnum2);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	return ret;
 }
 static bool test_delayed_write_update7(struct torture_context *tctx, struct smbcli_state *cli)
 {
 	union smb_open open_parms;
 	union smb_fileinfo finfo1, finfo2, finfo3;
 	const char *fname = BASEDIR "\\torture_file7.txt";
 	NTSTATUS status;
 	int fnum1 = -1;
 	bool ret = true;
 	TALLOC_CTX *mem_ctx;
 	torture_comment(tctx, "\nRunning test_delayed_write_update7 (timestamp resolution test)\n");
         mem_ctx = talloc_init("test_delayed_write_update7");
         if (!mem_ctx) return false;
 	ZERO_STRUCT(finfo1);
 	ZERO_STRUCT(finfo2);
 	ZERO_STRUCT(finfo3);
 	ZERO_STRUCT(open_parms);
 	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 (fnum1 == -1) {
 		torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
 		return false;
 	}
 	finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 	finfo1.basic_info.in.file.fnum = fnum1;
 	finfo2 = finfo1;
 	finfo3 = finfo1;
 	/* Get the initial timestamps. */
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
 	torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 	/* Set the pending write time to a value with ns. */
 	SET_INFO_FILE_NS(finfo, time(NULL) + 86400, 103, cli->tree, fnum1);
 	/* Get the current pending write time by fnum. */
 	status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
 	torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
 	/* Ensure the time is actually different. */
 	if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
 		torture_result(tctx, TORTURE_FAIL,
 			"setfileinfo time matches original fileinfo time");
 		ret = false;
 	}
 	/* Get the current pending write time by path. */
 	finfo3.basic_info.in.file.path = fname;
 	status = smb_raw_pathinfo(cli->tree, tctx, &finfo3);
 	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");
 		ret = false;
 	}
 	/* Now close the file. Re-open and check that the write
 	   time is identical to the one we wrote. */
 	smbcli_close(cli->tree, fnum1);
 	open_parms.ntcreatex.level = RAW_OPEN_NTCREATEX;
 	open_parms.ntcreatex.in.flags = 0;
 	open_parms.ntcreatex.in.access_mask = SEC_GENERIC_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 = 0;
 	open_parms.ntcreatex.in.fname = fname;
 	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,
 			"setfileinfo time matches original fileinfo time");
 		ret = false;
 	}
 	fnum1 = open_parms.ntcreatex.out.file.fnum;
 	/* Check the returned time matches. */
         if (open_parms.ntcreatex.out.write_time != finfo2.basic_info.out.write_time) {
 		torture_result(tctx, TORTURE_FAIL,
 			"final open time does not match set time");
 		ret = false;
 	}
  done:
 	smbcli_close(cli->tree, fnum1);
 	smbcli_unlink(cli->tree, fname);
 	smbcli_deltree(cli->tree, BASEDIR);
 	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(TALLOC_CTX *ctx)
 {
 	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_1smb_test(suite, "update of write time and SMBwrite truncate", test_delayed_write_update1);
 	torture_suite_add_1smb_test(suite, "update of write time and SMBwrite truncate expand", test_delayed_write_update1a);
 	torture_suite_add_1smb_test(suite, "update of write time using SET_END_OF_FILE", test_delayed_write_update1b);
 	torture_suite_add_1smb_test(suite, "update of write time using SET_ALLOCATION_SIZE", test_delayed_write_update1c);
 	torture_suite_add_2smb_test(suite, "delayed update of write time using 2 connections", test_delayed_write_update2);
 	torture_suite_add_2smb_test(suite, "delayed update of write time 3", test_delayed_write_update3);
 	torture_suite_add_2smb_test(suite, "delayed update of write time 3a", test_delayed_write_update3a);
 	torture_suite_add_2smb_test(suite, "delayed update of write time 3b", test_delayed_write_update3b);
 	torture_suite_add_2smb_test(suite, "delayed update of write time 3c", test_delayed_write_update3c);
 	torture_suite_add_2smb_test(suite, "delayed update of write time 4", test_delayed_write_update4);
 	torture_suite_add_2smb_test(suite, "delayed update of write time 5", test_delayed_write_update5);
 	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, "directory timestamp update test", test_directory_update8);
 	return suite;
 }

3095 lines 94 KiB C Raw Blame History

3095 lines

94 KiB

C

Raw Blame History