2 Unix SMB/CIFS implementation.
4 test suite for delayed write update
6 Copyright (C) Volker Lendecke 2004
7 Copyright (C) Andrew Tridgell 2004
8 Copyright (C) Jeremy Allison 2004
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "torture/torture.h"
26 #include "libcli/raw/libcliraw.h"
27 #include "libcli/raw/raw_proto.h"
28 #include "system/time.h"
29 #include "system/filesys.h"
30 #include "libcli/libcli.h"
31 #include "torture/util.h"
33 #define BASEDIR "\\delaywrite"
35 static bool test_delayed_write_update(struct torture_context *tctx, struct smbcli_state *cli)
37 union smb_fileinfo finfo1, finfo2;
38 const char *fname = BASEDIR "\\torture_file.txt";
45 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
46 int normal_delay = 2000000;
47 double sec = ((double)used_delay) / ((double)normal_delay);
48 int msec = 1000 * sec;
50 if (!torture_setup_dir(cli, BASEDIR)) {
54 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
56 torture_comment(tctx, "Failed to open %s\n", fname);
60 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
61 finfo1.basic_info.in.file.fnum = fnum1;
64 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
66 if (!NT_STATUS_IS_OK(status)) {
67 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
71 torture_comment(tctx, "Initial write time %s\n",
72 nt_time_string(tctx, finfo1.basic_info.out.write_time));
74 /* 3 second delay to ensure we get past any 2 second time
75 granularity (older systems may have that) */
78 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
81 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
82 (int)written, __location__);
86 start = timeval_current();
87 end = timeval_add(&start, (120*sec), 0);
88 while (!timeval_expired(&end)) {
89 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
91 if (!NT_STATUS_IS_OK(status)) {
92 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
96 torture_comment(tctx, "write time %s\n",
97 nt_time_string(tctx, finfo2.basic_info.out.write_time));
98 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
99 double diff = timeval_elapsed(&start);
100 if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
101 torture_comment(tctx, "Server updated write_time after %.2f seconds"
102 "(1 sec == %.2f)(wrong!)\n",
108 torture_comment(tctx, "Server updated write_time after %.2f seconds"
109 "(1 sec == %.2f)(correct)\n",
117 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
118 torture_comment(tctx, "Server did not update write time (wrong!)\n");
124 smbcli_close(cli->tree, fnum1);
125 smbcli_unlink(cli->tree, fname);
126 smbcli_deltree(cli->tree, BASEDIR);
132 * Do as above, but using 2 connections.
135 static bool test_delayed_write_update2(struct torture_context *tctx, struct smbcli_state *cli,
136 struct smbcli_state *cli2)
138 union smb_fileinfo finfo1, finfo2;
139 const char *fname = BASEDIR "\\torture_file.txt";
145 struct timeval start;
147 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
148 int normal_delay = 2000000;
149 double sec = ((double)used_delay) / ((double)normal_delay);
150 int msec = 1000 * sec;
151 union smb_flush flsh;
153 if (!torture_setup_dir(cli, BASEDIR)) {
157 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
159 torture_comment(tctx, "Failed to open %s\n", fname);
163 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
164 finfo1.basic_info.in.file.fnum = fnum1;
167 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
169 if (!NT_STATUS_IS_OK(status)) {
170 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
174 torture_comment(tctx, "Initial write time %s\n",
175 nt_time_string(tctx, finfo1.basic_info.out.write_time));
177 /* 3 second delay to ensure we get past any 2 second time
178 granularity (older systems may have that) */
182 /* Try using setfileinfo instead of write to update write time. */
183 union smb_setfileinfo sfinfo;
184 time_t t_set = time(NULL);
185 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO;
186 sfinfo.basic_info.in.file.fnum = fnum1;
187 sfinfo.basic_info.in.create_time = finfo1.basic_info.out.create_time;
188 sfinfo.basic_info.in.access_time = finfo1.basic_info.out.access_time;
190 /* I tried this with both + and - ve to see if it makes a different.
191 It doesn't - once the filetime is set via setfileinfo it stays that way. */
193 unix_to_nt_time(&sfinfo.basic_info.in.write_time, t_set - 30000);
195 unix_to_nt_time(&sfinfo.basic_info.in.write_time, t_set + 30000);
197 sfinfo.basic_info.in.change_time = finfo1.basic_info.out.change_time;
198 sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib;
200 status = smb_raw_setfileinfo(cli->tree, &sfinfo);
202 if (!NT_STATUS_IS_OK(status)) {
203 DEBUG(0, ("sfileinfo failed: %s\n", nt_errstr(status)));
208 finfo2.basic_info.in.file.path = fname;
210 status = smb_raw_pathinfo(cli2->tree, tctx, &finfo2);
212 if (!NT_STATUS_IS_OK(status)) {
213 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
216 torture_comment(tctx, "write time %s\n",
217 nt_time_string(tctx, finfo2.basic_info.out.write_time));
219 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
220 torture_comment(tctx, "Server updated write_time (correct)\n");
222 torture_comment(tctx, "Server did not update write time (wrong!)\n");
226 /* Now try a write to see if the write time gets reset. */
228 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
229 finfo1.basic_info.in.file.fnum = fnum1;
232 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
234 if (!NT_STATUS_IS_OK(status)) {
235 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
239 torture_comment(tctx, "Modified write time %s\n",
240 nt_time_string(tctx, finfo1.basic_info.out.write_time));
243 torture_comment(tctx, "Doing a 10 byte write to extend the file and see if this changes the last write time.\n");
245 written = smbcli_write(cli->tree, fnum1, 0, "0123456789", 1, 10);
248 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
249 (int)written, __location__);
253 /* Just to prove to tridge that the an smbflush has no effect on
254 the write time :-). The setfileinfo IS STICKY. JRA. */
256 torture_comment(tctx, "Doing flush after write\n");
258 flsh.flush.level = RAW_FLUSH_FLUSH;
259 flsh.flush.in.file.fnum = fnum1;
260 status = smb_raw_flush(cli->tree, &flsh);
261 if (!NT_STATUS_IS_OK(status)) {
262 DEBUG(0, ("smbflush failed: %s\n", nt_errstr(status)));
266 /* Once the time was set using setfileinfo then it stays set - writes
267 don't have any effect. But make sure. */
268 start = timeval_current();
269 end = timeval_add(&start, (15*sec), 0);
270 while (!timeval_expired(&end)) {
271 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
273 if (!NT_STATUS_IS_OK(status)) {
274 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
278 torture_comment(tctx, "write time %s\n",
279 nt_time_string(tctx, finfo2.basic_info.out.write_time));
280 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
281 double diff = timeval_elapsed(&start);
282 torture_comment(tctx, "Server updated write_time after %.2f seconds"
283 "(1sec == %.2f) (wrong!)\n",
292 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
293 torture_comment(tctx, "Server did not update write time (correct)\n");
296 fnum2 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
298 torture_comment(tctx, "Failed to open %s\n", fname);
302 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");
304 written = smbcli_write(cli->tree, fnum2, 0, "0123456789", 11, 10);
307 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
308 (int)written, __location__);
312 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
314 if (!NT_STATUS_IS_OK(status)) {
315 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
318 torture_comment(tctx, "write time %s\n",
319 nt_time_string(tctx, finfo2.basic_info.out.write_time));
320 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
321 torture_comment(tctx, "Server updated write_time (wrong!)\n");
325 torture_comment(tctx, "Closing the first fd to see if write time updated.\n");
326 smbcli_close(cli->tree, fnum1);
329 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");
331 written = smbcli_write(cli->tree, fnum2, 0, "0123456789", 21, 10);
334 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
335 (int)written, __location__);
339 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
340 finfo1.basic_info.in.file.fnum = fnum2;
342 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
344 if (!NT_STATUS_IS_OK(status)) {
345 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
348 torture_comment(tctx, "write time %s\n",
349 nt_time_string(tctx, finfo2.basic_info.out.write_time));
350 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
351 torture_comment(tctx, "Server updated write_time (wrong!)\n");
355 /* Once the time was set using setfileinfo then it stays set - writes
356 don't have any effect. But make sure. */
357 start = timeval_current();
358 end = timeval_add(&start, (15*sec), 0);
359 while (!timeval_expired(&end)) {
360 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
362 if (!NT_STATUS_IS_OK(status)) {
363 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
367 torture_comment(tctx, "write time %s\n",
368 nt_time_string(tctx, finfo2.basic_info.out.write_time));
369 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
370 double diff = timeval_elapsed(&start);
371 torture_comment(tctx, "Server updated write_time after %.2f seconds "
372 "(1sec == %.2f) (wrong!)\n",
381 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
382 torture_comment(tctx, "Server did not update write time (correct)\n");
385 torture_comment(tctx, "Closing second fd to see if write time updated.\n");
387 smbcli_close(cli->tree, fnum2);
390 fnum1 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
392 torture_comment(tctx, "Failed to open %s\n", fname);
396 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
397 finfo1.basic_info.in.file.fnum = fnum1;
400 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
402 if (!NT_STATUS_IS_OK(status)) {
403 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
407 torture_comment(tctx, "Second open initial write time %s\n",
408 nt_time_string(tctx, finfo1.basic_info.out.write_time));
411 torture_comment(tctx, "Doing a 10 byte write to extend the file to see if this changes the last write time.\n");
413 written = smbcli_write(cli->tree, fnum1, 0, "0123456789", 31, 10);
416 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
417 (int)written, __location__);
421 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
422 finfo1.basic_info.in.file.fnum = fnum1;
424 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
426 if (!NT_STATUS_IS_OK(status)) {
427 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
430 torture_comment(tctx, "write time %s\n",
431 nt_time_string(tctx, finfo2.basic_info.out.write_time));
432 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
433 torture_comment(tctx, "Server updated write_time (wrong!)\n");
437 /* Now the write time should be updated again */
438 start = timeval_current();
439 end = timeval_add(&start, (15*sec), 0);
440 while (!timeval_expired(&end)) {
441 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
443 if (!NT_STATUS_IS_OK(status)) {
444 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
448 torture_comment(tctx, "write time %s\n",
449 nt_time_string(tctx, finfo2.basic_info.out.write_time));
450 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
451 double diff = timeval_elapsed(&start);
452 if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
453 torture_comment(tctx, "Server updated write_time after %.2f seconds"
454 "(1sec == %.2f) (wrong!)\n",
460 torture_comment(tctx, "Server updated write_time after %.2f seconds"
461 "(1sec == %.2f) (correct)\n",
469 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
470 torture_comment(tctx, "Server did not update write time (wrong!)\n");
475 /* One more test to do. We should read the filetime via findfirst on the
476 second connection to ensure it's the same. This is very easy for a Windows
477 server but a bastard to get right on a POSIX server. JRA. */
480 smbcli_close(cli->tree, fnum1);
481 smbcli_unlink(cli->tree, fname);
482 smbcli_deltree(cli->tree, BASEDIR);
488 /* Windows does obviously not update the stat info during a write call. I
489 * *think* this is the problem causing a spurious Excel 2003 on XP error
490 * message when saving a file. Excel does a setfileinfo, writes, and then does
491 * a getpath(!)info. Or so... For Samba sometimes it displays an error message
492 * that the file might have been changed in between. What i've been able to
493 * trace down is that this happens if the getpathinfo after the write shows a
494 * different last write time than the setfileinfo showed. This is really
498 static bool test_finfo_after_write(struct torture_context *tctx, struct smbcli_state *cli,
499 struct smbcli_state *cli2)
501 union smb_fileinfo finfo1, finfo2;
502 const char *fname = BASEDIR "\\torture_file.txt";
508 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
509 int normal_delay = 2000000;
510 double sec = ((double)used_delay) / ((double)normal_delay);
511 int msec = 1000 * sec;
513 if (!torture_setup_dir(cli, BASEDIR)) {
517 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
520 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
524 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
525 finfo1.basic_info.in.file.fnum = fnum1;
527 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
529 if (!NT_STATUS_IS_OK(status)) {
531 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", nt_errstr(status));
537 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
540 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
545 fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
547 torture_result(tctx, TORTURE_FAIL, __location__": failed to open 2nd time - %s",
548 smbcli_errstr(cli2->tree));
553 written = smbcli_write(cli2->tree, fnum2, 0, "x", 0, 1);
556 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1",
562 finfo2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
563 finfo2.basic_info.in.file.path = fname;
565 status = smb_raw_pathinfo(cli2->tree, tctx, &finfo2);
567 if (!NT_STATUS_IS_OK(status)) {
568 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s",
574 if (finfo1.basic_info.out.create_time !=
575 finfo2.basic_info.out.create_time) {
576 torture_result(tctx, TORTURE_FAIL, __location__": create_time changed");
581 if (finfo1.basic_info.out.access_time !=
582 finfo2.basic_info.out.access_time) {
583 torture_result(tctx, TORTURE_FAIL, __location__": access_time changed");
588 if (finfo1.basic_info.out.write_time !=
589 finfo2.basic_info.out.write_time) {
590 torture_result(tctx, TORTURE_FAIL, __location__": write_time changed:\n"
591 "write time conn 1 = %s, conn 2 = %s",
592 nt_time_string(tctx, finfo1.basic_info.out.write_time),
593 nt_time_string(tctx, finfo2.basic_info.out.write_time));
598 if (finfo1.basic_info.out.change_time !=
599 finfo2.basic_info.out.change_time) {
600 torture_result(tctx, TORTURE_FAIL, __location__": change_time changed");
605 /* One of the two following calls updates the qpathinfo. */
607 /* If you had skipped the smbcli_write on fnum2, it would
608 * *not* have updated the stat on disk */
610 smbcli_close(cli2->tree, fnum2);
613 /* This call is only for the people looking at ethereal :-) */
614 finfo2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
615 finfo2.basic_info.in.file.path = fname;
617 status = smb_raw_pathinfo(cli->tree, tctx, &finfo2);
619 if (!NT_STATUS_IS_OK(status)) {
620 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", nt_errstr(status));
627 smbcli_close(cli->tree, fnum1);
628 smbcli_unlink(cli->tree, fname);
629 smbcli_deltree(cli->tree, BASEDIR);
634 #define COMPARE_WRITE_TIME_CMP(given, correct, cmp) do { \
635 uint64_t r = 10*1000*1000; \
636 NTTIME g = (given).basic_info.out.write_time; \
637 NTTIME gr = (g / r) * r; \
638 NTTIME c = (correct).basic_info.out.write_time; \
639 NTTIME cr = (c / r) * r; \
640 bool strict = torture_setting_bool(tctx, "strict mode", false); \
642 if (strict && (g cmp c)) { \
644 } else if ((g cmp c) && (gr cmp cr)) { \
645 /* handle filesystem without high resolution timestamps */ \
649 torture_result(tctx, TORTURE_FAIL, __location__": wrong write_time (%s)%s(%llu) %s (%s)%s(%llu)", \
650 #given, nt_time_string(tctx, g), (unsigned long long)g, \
651 #cmp, #correct, nt_time_string(tctx, c), (unsigned long long)c); \
656 #define COMPARE_WRITE_TIME_EQUAL(given,correct) \
657 COMPARE_WRITE_TIME_CMP(given,correct,!=)
658 #define COMPARE_WRITE_TIME_GREATER(given,correct) \
659 COMPARE_WRITE_TIME_CMP(given,correct,<=)
660 #define COMPARE_WRITE_TIME_LESS(given,correct) \
661 COMPARE_WRITE_TIME_CMP(given,correct,>=)
663 #define COMPARE_ACCESS_TIME_CMP(given, correct, cmp) do { \
664 NTTIME g = (given).basic_info.out.access_time; \
665 NTTIME c = (correct).basic_info.out.access_time; \
667 torture_result(tctx, TORTURE_FAIL, __location__": wrong access_time (%s)%s %s (%s)%s", \
668 #given, nt_time_string(tctx, g), \
669 #cmp, #correct, nt_time_string(tctx, c)); \
674 #define COMPARE_ACCESS_TIME_EQUAL(given,correct) \
675 COMPARE_ACCESS_TIME_CMP(given,correct,!=)
677 #define COMPARE_BOTH_TIMES_EQUAL(given,correct) do { \
678 COMPARE_ACCESS_TIME_EQUAL(given,correct); \
679 COMPARE_WRITE_TIME_EQUAL(given,correct); \
682 #define GET_INFO_FILE(finfo) do { \
684 _status = smb_raw_fileinfo(cli->tree, tctx, &finfo); \
685 if (!NT_STATUS_IS_OK(_status)) { \
687 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", \
688 nt_errstr(_status)); \
691 torture_comment(tctx, "fileinfo: Access(%s) Write(%s)\n", \
692 nt_time_string(tctx, finfo.basic_info.out.access_time), \
693 nt_time_string(tctx, finfo.basic_info.out.write_time)); \
695 #define GET_INFO_PATH(pinfo) do { \
697 _status = smb_raw_pathinfo(cli2->tree, tctx, &pinfo); \
698 if (!NT_STATUS_IS_OK(_status)) { \
699 torture_result(tctx, TORTURE_FAIL, __location__": pathinfo failed: %s", \
700 nt_errstr(_status)); \
704 torture_comment(tctx, "pathinfo: Access(%s) Write(%s)\n", \
705 nt_time_string(tctx, pinfo.basic_info.out.access_time), \
706 nt_time_string(tctx, pinfo.basic_info.out.write_time)); \
708 #define GET_INFO_BOTH(finfo,pinfo) do { \
709 GET_INFO_FILE(finfo); \
710 GET_INFO_PATH(pinfo); \
711 COMPARE_BOTH_TIMES_EQUAL(finfo,pinfo); \
714 #define SET_INFO_FILE_EX(finfo, wrtime, tree, tfnum) do { \
716 union smb_setfileinfo sfinfo; \
717 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO; \
718 sfinfo.basic_info.in.file.fnum = tfnum; \
719 sfinfo.basic_info.in.create_time = 0; \
720 sfinfo.basic_info.in.access_time = 0; \
721 unix_to_nt_time(&sfinfo.basic_info.in.write_time, (wrtime)); \
722 sfinfo.basic_info.in.change_time = 0; \
723 sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib; \
724 _status = smb_raw_setfileinfo(tree, &sfinfo); \
725 if (!NT_STATUS_IS_OK(_status)) { \
726 torture_result(tctx, TORTURE_FAIL, __location__": setfileinfo failed: %s", \
727 nt_errstr(_status)); \
732 #define SET_INFO_FILE(finfo, wrtime) \
733 SET_INFO_FILE_EX(finfo, wrtime, cli->tree, fnum1)
735 static bool test_delayed_write_update3(struct torture_context *tctx,
736 struct smbcli_state *cli,
737 struct smbcli_state *cli2)
739 union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
740 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
741 const char *fname = BASEDIR "\\torture_file.txt";
745 struct timeval start;
747 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
748 int normal_delay = 2000000;
749 double sec = ((double)used_delay) / ((double)normal_delay);
750 int msec = 1000 * sec;
752 if (!torture_setup_dir(cli, BASEDIR)) {
756 torture_comment(tctx, "Open the file handle\n");
757 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
760 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
764 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
765 finfo0.basic_info.in.file.fnum = fnum1;
770 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
771 pinfo0.basic_info.in.file.path = fname;
778 /* get the initial times */
779 GET_INFO_BOTH(finfo0,pinfo0);
782 * make sure the write time is updated 2 seconds later
783 * calcuated from the first write
784 * (but expect upto 5 seconds extra time for a busy server)
786 start = timeval_current();
787 end = timeval_add(&start, 7 * sec, 0);
788 while (!timeval_expired(&end)) {
790 torture_comment(tctx, "Do a write on the file handle\n");
791 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
793 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
797 /* get the times after the write */
798 GET_INFO_FILE(finfo1);
800 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
801 double diff = timeval_elapsed(&start);
802 if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
803 torture_comment(tctx, "Server updated write_time after %.2f seconds "
804 "(1sec == %.2f) (wrong!)\n",
810 torture_comment(tctx, "Server updated write_time after %.2f seconds "
811 "(1sec == %.2f) (correct)\n",
818 GET_INFO_BOTH(finfo1,pinfo1);
819 COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
821 /* sure any further write doesn't update the write time */
822 start = timeval_current();
823 end = timeval_add(&start, 15 * sec, 0);
824 while (!timeval_expired(&end)) {
826 torture_comment(tctx, "Do a write on the file handle\n");
827 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
829 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
833 /* get the times after the write */
834 GET_INFO_BOTH(finfo2,pinfo2);
836 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
837 double diff = timeval_elapsed(&start);
838 torture_comment(tctx, "Server updated write_time after %.2f seconds "
839 "(1sec == %.2f) (wrong!)\n",
847 GET_INFO_BOTH(finfo2,pinfo2);
848 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
849 if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
850 torture_comment(tctx, "Server did not update write_time (correct)\n");
856 GET_INFO_BOTH(finfo3,pinfo3);
857 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
860 * the close updates the write time to the time of the close
861 * and not to the time of the last write!
863 torture_comment(tctx, "Close the file handle\n");
864 smbcli_close(cli->tree, fnum1);
867 GET_INFO_PATH(pinfo4);
868 COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
870 if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
871 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
876 smbcli_close(cli->tree, fnum1);
877 smbcli_unlink(cli->tree, fname);
878 smbcli_deltree(cli->tree, BASEDIR);
883 static bool test_delayed_write_update4(struct torture_context *tctx,
884 struct smbcli_state *cli,
885 struct smbcli_state *cli2)
887 union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
888 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
889 const char *fname = BASEDIR "\\torture_file.txt";
893 struct timeval start;
895 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
896 int normal_delay = 2000000;
897 double sec = ((double)used_delay) / ((double)normal_delay);
898 int msec = 1000 * sec;
900 if (!torture_setup_dir(cli, BASEDIR)) {
904 torture_comment(tctx, "Open the file handle\n");
905 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
908 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
912 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
913 finfo0.basic_info.in.file.fnum = fnum1;
918 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
919 pinfo0.basic_info.in.file.path = fname;
926 /* get the initial times */
927 GET_INFO_BOTH(finfo0,pinfo0);
933 torture_comment(tctx, "Do a write on the file handle\n");
934 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
936 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
941 GET_INFO_BOTH(finfo1,pinfo1);
942 COMPARE_WRITE_TIME_EQUAL(finfo1,finfo0);
945 * make sure the write time is updated 2 seconds later
946 * calcuated from the first write
947 * (but expect upto 3 seconds extra time for a busy server)
949 start = timeval_current();
950 end = timeval_add(&start, 5 * sec, 0);
951 while (!timeval_expired(&end)) {
952 /* get the times after the first write */
953 GET_INFO_FILE(finfo1);
955 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
956 double diff = timeval_elapsed(&start);
957 if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
958 torture_comment(tctx, "Server updated write_time after %.2f seconds "
959 "(1sec == %.2f) (wrong!)\n",
965 torture_comment(tctx, "Server updated write_time after %.2f seconds "
966 "(1sec == %.2f) (correct)\n",
973 GET_INFO_BOTH(finfo1,pinfo1);
974 COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
976 /* sure any further write doesn't update the write time */
977 start = timeval_current();
978 end = timeval_add(&start, 15 * sec, 0);
979 while (!timeval_expired(&end)) {
981 torture_comment(tctx, "Do a write on the file handle\n");
982 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
984 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
988 /* get the times after the write */
989 GET_INFO_BOTH(finfo2,pinfo2);
991 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
992 double diff = timeval_elapsed(&start);
993 torture_comment(tctx, "Server updated write_time after %.2f seconds "
994 "(1sec == %.2f) (wrong!)\n",
1002 GET_INFO_BOTH(finfo2,pinfo2);
1003 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
1004 if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
1005 torture_comment(tctx, "Server did not updatewrite_time (correct)\n");
1011 GET_INFO_BOTH(finfo3,pinfo3);
1012 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1015 * the close updates the write time to the time of the close
1016 * and not to the time of the last write!
1018 torture_comment(tctx, "Close the file handle\n");
1019 smbcli_close(cli->tree, fnum1);
1022 GET_INFO_PATH(pinfo4);
1023 COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
1025 if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
1026 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
1031 smbcli_close(cli->tree, fnum1);
1032 smbcli_unlink(cli->tree, fname);
1033 smbcli_deltree(cli->tree, BASEDIR);
1038 static bool test_delayed_write_update5(struct torture_context *tctx,
1039 struct smbcli_state *cli,
1040 struct smbcli_state *cli2)
1042 union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
1043 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6;
1044 const char *fname = BASEDIR "\\torture_file.txt";
1048 struct timeval start;
1050 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1051 int normal_delay = 2000000;
1052 double sec = ((double)used_delay) / ((double)normal_delay);
1053 int msec = 1000 * sec;
1055 if (!torture_setup_dir(cli, BASEDIR)) {
1059 torture_comment(tctx, "Open the file handle\n");
1060 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1063 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1067 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1068 finfo0.basic_info.in.file.fnum = fnum1;
1074 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1075 pinfo0.basic_info.in.file.path = fname;
1083 /* get the initial times */
1084 GET_INFO_BOTH(finfo0,pinfo0);
1087 torture_comment(tctx, "Do a write on the file handle\n");
1088 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1090 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1095 GET_INFO_BOTH(finfo1,pinfo1);
1096 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
1098 torture_comment(tctx, "Set write time in the future on the file handle\n");
1099 SET_INFO_FILE(finfo0, time(NULL) + 86400);
1100 GET_INFO_BOTH(finfo2,pinfo2);
1101 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
1103 torture_comment(tctx, "Set write time in the past on the file handle\n");
1104 SET_INFO_FILE(finfo0, time(NULL) - 86400);
1105 GET_INFO_BOTH(finfo2,pinfo2);
1106 COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
1108 /* make sure the 2 second delay from the first write are canceled */
1109 start = timeval_current();
1110 end = timeval_add(&start, 15 * sec, 0);
1111 while (!timeval_expired(&end)) {
1113 /* get the times after the first write */
1114 GET_INFO_BOTH(finfo3,pinfo3);
1116 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
1117 double diff = timeval_elapsed(&start);
1118 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1119 "(1sec == %.2f) (wrong!)\n",
1127 GET_INFO_BOTH(finfo3,pinfo3);
1128 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1129 if (finfo3.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1130 torture_comment(tctx, "Server did not update write_time (correct)\n");
1133 /* sure any further write doesn't update the write time */
1134 start = timeval_current();
1135 end = timeval_add(&start, 15 * sec, 0);
1136 while (!timeval_expired(&end)) {
1138 torture_comment(tctx, "Do a write on the file handle\n");
1139 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1141 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1145 /* get the times after the write */
1146 GET_INFO_BOTH(finfo4,pinfo4);
1148 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
1149 double diff = timeval_elapsed(&start);
1150 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1151 "(1sec == %.2f) (wrong!)\n",
1159 GET_INFO_BOTH(finfo4,pinfo4);
1160 COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
1161 if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1162 torture_comment(tctx, "Server did not update write_time (correct)\n");
1168 GET_INFO_BOTH(finfo5,pinfo5);
1169 COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
1172 * the close doesn't update the write time
1174 torture_comment(tctx, "Close the file handle\n");
1175 smbcli_close(cli->tree, fnum1);
1178 GET_INFO_PATH(pinfo6);
1179 COMPARE_WRITE_TIME_EQUAL(pinfo6, pinfo5);
1181 if (pinfo6.basic_info.out.write_time == pinfo5.basic_info.out.write_time) {
1182 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
1187 smbcli_close(cli->tree, fnum1);
1188 smbcli_unlink(cli->tree, fname);
1189 smbcli_deltree(cli->tree, BASEDIR);
1194 static bool test_delayed_write_update6(struct torture_context *tctx,
1195 struct smbcli_state *cli,
1196 struct smbcli_state *cli2)
1198 union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
1199 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6, pinfo7;
1200 const char *fname = BASEDIR "\\torture_file.txt";
1205 struct timeval start;
1207 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1208 int normal_delay = 2000000;
1209 double sec = ((double)used_delay) / ((double)normal_delay);
1210 int msec = 1000 * sec;
1213 if (!torture_setup_dir(cli, BASEDIR)) {
1217 torture_comment(tctx, "Open the file handle\n");
1218 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1221 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1226 torture_comment(tctx, "Open the 2nd file handle on 2nd connection\n");
1227 fnum2 = smbcli_open(cli2->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1230 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1235 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1236 finfo0.basic_info.in.file.fnum = fnum1;
1242 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1243 pinfo0.basic_info.in.file.path = fname;
1252 /* get the initial times */
1253 GET_INFO_BOTH(finfo0,pinfo0);
1256 torture_comment(tctx, "Do a write on the file handle\n");
1257 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1259 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1264 GET_INFO_BOTH(finfo1,pinfo1);
1265 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
1267 torture_comment(tctx, "Set write time in the future on the 2nd file handle\n");
1268 SET_INFO_FILE_EX(finfo0, time(NULL) + 86400, cli2->tree, fnum2);
1269 GET_INFO_BOTH(finfo2,pinfo2);
1270 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
1272 torture_comment(tctx, "Set write time in the past on the 2nd file handle\n");
1273 SET_INFO_FILE_EX(finfo0, time(NULL) - 86400, cli2->tree, fnum2);
1274 GET_INFO_BOTH(finfo2,pinfo2);
1275 COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
1277 /* make sure the 2 second delay from the first write are canceled */
1278 start = timeval_current();
1279 end = timeval_add(&start, 15 * sec, 0);
1280 while (!timeval_expired(&end)) {
1282 /* get the times after the first write */
1283 GET_INFO_BOTH(finfo3,pinfo3);
1285 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
1286 double diff = timeval_elapsed(&start);
1287 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1288 "(1sec == %.2f) (wrong!)\n",
1296 GET_INFO_BOTH(finfo3,pinfo3);
1297 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1298 if (finfo3.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1299 torture_comment(tctx, "Server did not update write_time (correct)\n");
1302 /* sure any further write doesn't update the write time */
1303 start = timeval_current();
1304 end = timeval_add(&start, 15 * sec, 0);
1305 while (!timeval_expired(&end)) {
1307 torture_comment(tctx, "Do a write on the file handle\n");
1308 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1310 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1314 /* get the times after the write */
1315 GET_INFO_BOTH(finfo4,pinfo4);
1317 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
1318 double diff = timeval_elapsed(&start);
1319 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1320 "(1sec == %.2f) (wrong!)\n",
1328 GET_INFO_BOTH(finfo4,pinfo4);
1329 COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
1330 if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1331 torture_comment(tctx, "Server did not update write_time (correct)\n");
1337 GET_INFO_BOTH(finfo5,pinfo5);
1338 COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
1341 * the close updates the write time to the time of the close
1342 * as the write time was set on the 2nd handle
1344 torture_comment(tctx, "Close the file handle\n");
1345 smbcli_close(cli->tree, fnum1);
1348 GET_INFO_PATH(pinfo6);
1349 COMPARE_WRITE_TIME_GREATER(pinfo6, pinfo5);
1351 if (pinfo6.basic_info.out.write_time > pinfo5.basic_info.out.write_time) {
1352 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
1355 /* keep the 2nd handle open and rerun tests */
1362 * closing the 2nd handle will cause no write time update
1363 * as the write time was explicit set on this handle
1365 torture_comment(tctx, "Close the 2nd file handle\n");
1366 smbcli_close(cli2->tree, fnum2);
1369 GET_INFO_PATH(pinfo7);
1370 COMPARE_WRITE_TIME_EQUAL(pinfo7, pinfo6);
1372 if (pinfo7.basic_info.out.write_time == pinfo6.basic_info.out.write_time) {
1373 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
1378 smbcli_close(cli->tree, fnum1);
1380 smbcli_close(cli2->tree, fnum2);
1381 smbcli_unlink(cli->tree, fname);
1382 smbcli_deltree(cli->tree, BASEDIR);
1389 testing of delayed update of write_time
1391 struct torture_suite *torture_delay_write(void)
1393 struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "DELAYWRITE");
1395 torture_suite_add_2smb_test(suite, "finfo update on close", test_finfo_after_write);
1396 torture_suite_add_1smb_test(suite, "delayed update of write time", test_delayed_write_update);
1397 torture_suite_add_2smb_test(suite, "delayed update of write time using 2 connections", test_delayed_write_update2);
1398 torture_suite_add_2smb_test(suite, "delayed update of write time 3", test_delayed_write_update3);
1399 torture_suite_add_2smb_test(suite, "delayed update of write time 4", test_delayed_write_update4);
1400 torture_suite_add_2smb_test(suite, "delayed update of write time 5", test_delayed_write_update5);
1401 torture_suite_add_2smb_test(suite, "delayed update of write time 6", test_delayed_write_update6);