?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: don't replace the error message if already defined
[Samba/gebeck_regimport.git] / source4 / torture / basic / delaywrite.c
blob939827ec3ca20f20aabffb2ab3b7618eee99a2b2
1 /*
2 Unix SMB/CIFS implementation.
3
4 test suite for delayed write update
5
6 Copyright (C) Volker Lendecke 2004
7 Copyright (C) Andrew Tridgell 2004
8 Copyright (C) Jeremy Allison 2004
9
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.
14
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.
19
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/>.
22 */
23
24 #include "includes.h"
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"
32 #include "torture/basic/proto.h"
33
34 #define W2K8R2_TIMEDELAY_SECS 1
35 #define W2K3_TIMEDELAY_SECS 2
36 #define TIMEDELAY_SECS W2K3_TIMEDELAY_SECS
37
38 #define BASEDIR "\\delaywrite"
39
40 static bool test_delayed_write_update(struct torture_context *tctx, struct smbcli_state *cli)
41 {
42 union smb_fileinfo finfo1, finfo2;
43 const char *fname = BASEDIR "\\torture_file.txt";
44 NTSTATUS status;
45 int fnum1 = -1;
46 bool ret = true;
47 ssize_t written;
48 struct timeval start;
49 struct timeval end;
50 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
51 int normal_delay = 2000000;
52 double sec = ((double)used_delay) / ((double)normal_delay);
53 int msec = 1000 * sec;
54
55 torture_comment(tctx, "\nRunning test_delayed_write_update\n");
56
57 if (!torture_setup_dir(cli, BASEDIR)) {
58 return false;
59 }
60
61 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
62 if (fnum1 == -1) {
63 torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
64 return false;
65 }
66
67 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
68 finfo1.basic_info.in.file.fnum = fnum1;
69 finfo2 = finfo1;
70
71 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
72
73 torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
74
75 torture_comment(tctx, "Initial write time %s\n",
76 nt_time_string(tctx, finfo1.basic_info.out.write_time));
77
78 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
79
80 if (written != 1) {
81 torture_result(tctx, TORTURE_FAIL,
82 "write failed - wrote %d bytes (%s)\n",
83 (int)written, __location__);
84 return false;
85 }
86
87 start = timeval_current();
88 end = timeval_add(&start, (120*sec), 0);
89 while (!timeval_expired(&end)) {
90 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
91
92 if (!NT_STATUS_IS_OK(status)) {
93 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
94 ret = false;
95 break;
96 }
97 torture_comment(tctx, "write time %s\n",
98 nt_time_string(tctx, finfo2.basic_info.out.write_time));
99 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
100 double diff = timeval_elapsed(&start);
101 if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
102 torture_comment(tctx, "Server updated write_time after %.2f seconds"
103 "(1 sec == %.2f)(wrong!)\n",
104 diff, sec);
105 ret = false;
106 break;
107 }
108
109 torture_comment(tctx, "Server updated write_time after %.2f seconds"
110 "(1 sec == %.2f)(correct)\n",
111 diff, sec);
112 break;
113 }
114 fflush(stdout);
115 smb_msleep(1 * msec);
116 }
117
118 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
119 torture_result(tctx, TORTURE_FAIL,
120 "Server did not update write time (wrong!)");
121 ret = false;
122 }
123
124
125 if (fnum1 != -1)
126 smbcli_close(cli->tree, fnum1);
127 smbcli_unlink(cli->tree, fname);
128 smbcli_deltree(cli->tree, BASEDIR);
129
130 return ret;
131 }
132
133 static bool test_delayed_write_update1(struct torture_context *tctx, struct smbcli_state *cli)
134 {
135 union smb_fileinfo finfo1, finfo2, finfo3, pinfo4;
136 const char *fname = BASEDIR "\\torture_file1.txt";
137 NTSTATUS status;
138 int fnum1 = -1;
139 bool ret = true;
140 ssize_t written;
141 struct timeval start;
142 struct timeval end;
143 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
144 int normal_delay = 2000000;
145 double sec = ((double)used_delay) / ((double)normal_delay);
146 int msec = 1000 * sec;
147 char buf[2048];
148
149 torture_comment(tctx, "\nRunning test_delayed_write_update1\n");
150
151 if (!torture_setup_dir(cli, BASEDIR)) {
152 return false;
153 }
154
155 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
156 if (fnum1 == -1) {
157 torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
158 return false;
159 }
160
161 memset(buf, 'x', 2048);
162 written = smbcli_write(cli->tree, fnum1, 0, buf, 0, 2048);
163
164 /* 3 second delay to ensure we get past any 2 second time
165 granularity (older systems may have that) */
166 smb_msleep(3 * msec);
167
168 finfo1.all_info.level = RAW_FILEINFO_ALL_INFO;
169 finfo1.all_info.in.file.fnum = fnum1;
170 finfo2 = finfo1;
171 finfo3 = finfo1;
172 pinfo4.all_info.level = RAW_FILEINFO_ALL_INFO;
173 pinfo4.all_info.in.file.path = fname;
174
175 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
176
177 torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
178
179 torture_comment(tctx, "Initial write time %s\n",
180 nt_time_string(tctx, finfo1.all_info.out.write_time));
181
182 /* 3 second delay to ensure we get past any 2 second time
183 granularity (older systems may have that) */
184 smb_msleep(3 * msec);
185
186 /* Do a zero length SMBwrite call to truncate. */
187 written = smbcli_smbwrite(cli->tree, fnum1, "x", 1024, 0);
188
189 if (written != 0) {
190 torture_result(tctx, TORTURE_FAIL,
191 "write failed - wrote %d bytes (%s)\n",
192 (int)written, __location__);
193 return false;
194 }
195
196 start = timeval_current();
197 end = timeval_add(&start, (120*sec), 0);
198 while (!timeval_expired(&end)) {
199 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
200
201 if (!NT_STATUS_IS_OK(status)) {
202 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
203 ret = false;
204 break;
205 }
206
207 if (finfo2.all_info.out.size != 1024) {
208 torture_result(tctx, TORTURE_FAIL,
209 "file not truncated, size = %u (should be 1024)",
210 (unsigned int)finfo2.all_info.out.size);
211 ret = false;
212 break;
213 }
214
215 torture_comment(tctx, "write time %s\n",
216 nt_time_string(tctx, finfo2.all_info.out.write_time));
217 if (finfo1.all_info.out.write_time != finfo2.all_info.out.write_time) {
218 double diff = timeval_elapsed(&start);
219 if (diff > (0.25 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
220 torture_comment(tctx, "After SMBwrite truncate "
221 "server updated write_time after %.2f seconds"
222 "(1 sec == %.2f)(wrong!)\n",
223 diff, sec);
224 ret = false;
225 break;
226 }
227
228 torture_comment(tctx, "After SMBwrite truncate "
229 "server updated write_time after %.2f seconds"
230 "(1 sec == %.2f)(correct)\n",
231 diff, sec);
232 break;
233 }
234 fflush(stdout);
235 smb_msleep(1 * msec);
236 }
237
238 if (finfo1.all_info.out.write_time == finfo2.all_info.out.write_time) {
239 torture_result(tctx, TORTURE_FAIL,
240 "Server did not update write time (wrong!)");
241 ret = false;
242 }
243
244 fflush(stdout);
245 smb_msleep(2 * msec);
246
247 /* Do a non-zero length SMBwrite and make sure it doesn't update the write time. */
248 written = smbcli_smbwrite(cli->tree, fnum1, "x", 0, 1);
249
250 if (written != 1) {
251 torture_result(tctx, TORTURE_FAIL,
252 "write failed - wrote %d bytes (%s)",
253 (int)written, __location__);
254 return false;
255 }
256
257 start = timeval_current();
258 end = timeval_add(&start, (10*sec), 0);
259 while (!timeval_expired(&end)) {
260 status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
261
262 if (!NT_STATUS_IS_OK(status)) {
263 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
264 ret = false;
265 break;
266 }
267
268 if (finfo3.all_info.out.size != 1024) {
269 DEBUG(0, ("file not truncated, size = %u (should be 1024)\n",
270 (unsigned int)finfo3.all_info.out.size));
271 ret = false;
272 break;
273 }
274
275 torture_comment(tctx, "write time %s\n",
276 nt_time_string(tctx, finfo3.all_info.out.write_time));
277 if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
278 double diff = timeval_elapsed(&start);
279
280 torture_comment(tctx, "server updated write_time after %.2f seconds"
281 "(1 sec == %.2f)(wrong)\n",
282 diff, sec);
283 break;
284 }
285 fflush(stdout);
286 smb_msleep(1 * msec);
287 }
288
289 if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
290 torture_result(tctx, TORTURE_FAIL,
291 "Server updated write time (wrong!)");
292 ret = false;
293 }
294
295 fflush(stdout);
296 smb_msleep(2 * msec);
297
298 /* the close should trigger an write time update */
299 smbcli_close(cli->tree, fnum1);
300 fnum1 = -1;
301
302 status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
303 torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
304
305 if (finfo3.all_info.out.write_time == pinfo4.all_info.out.write_time) {
306 torture_result(tctx, TORTURE_FAIL,
307 "Server did not update write time on close (wrong!)");
308 ret = false;
309 } else if (finfo3.all_info.out.write_time < pinfo4.all_info.out.write_time) {
310 torture_comment(tctx, "Server updated write time on close (correct)\n");
311 }
312
313 if (fnum1 != -1)
314 smbcli_close(cli->tree, fnum1);
315 smbcli_unlink(cli->tree, fname);
316 smbcli_deltree(cli->tree, BASEDIR);
317
318 return ret;
319 }
320
321 /* Updating with a SMBwrite of zero length
322 * changes the write time immediately - even on expand. */
323
324 static bool test_delayed_write_update1a(struct torture_context *tctx, struct smbcli_state *cli)
325 {
326 union smb_fileinfo finfo1, finfo2, finfo3, pinfo4;
327 const char *fname = BASEDIR "\\torture_file1a.txt";
328 NTSTATUS status;
329 int fnum1 = -1;
330 bool ret = true;
331 ssize_t written;
332 struct timeval start;
333 struct timeval end;
334 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
335 int normal_delay = 2000000;
336 double sec = ((double)used_delay) / ((double)normal_delay);
337 int msec = 1000 * sec;
338 char buf[2048];
339
340 torture_comment(tctx, "\nRunning test_delayed_write_update1a\n");
341
342 if (!torture_setup_dir(cli, BASEDIR)) {
343 return false;
344 }
345
346 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
347 if (fnum1 == -1) {
348 torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
349 return false;
350 }
351
352 memset(buf, 'x', 2048);
353 written = smbcli_write(cli->tree, fnum1, 0, buf, 0, 2048);
354
355 /* 3 second delay to ensure we get past any 2 second time
356 granularity (older systems may have that) */
357 smb_msleep(3 * msec);
358
359 finfo1.all_info.level = RAW_FILEINFO_ALL_INFO;
360 finfo1.all_info.in.file.fnum = fnum1;
361 finfo2 = finfo1;
362 finfo3 = finfo1;
363 pinfo4.all_info.level = RAW_FILEINFO_ALL_INFO;
364 pinfo4.all_info.in.file.path = fname;
365
366 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
367
368 torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
369
370 torture_comment(tctx, "Initial write time %s\n",
371 nt_time_string(tctx, finfo1.all_info.out.write_time));
372
373 /* Do a zero length SMBwrite call to truncate. */
374 written = smbcli_smbwrite(cli->tree, fnum1, "x", 10240, 0);
375
376 if (written != 0) {
377 torture_result(tctx, TORTURE_FAIL, "write failed - wrote %d bytes (%s)",
378 (int)written, __location__);
379 return false;
380 }
381
382 start = timeval_current();
383 end = timeval_add(&start, (120*sec), 0);
384 while (!timeval_expired(&end)) {
385 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
386
387 if (!NT_STATUS_IS_OK(status)) {
388 torture_result(tctx, TORTURE_FAIL, "fileinfo failed: %s",
389 nt_errstr(status));
390 ret = false;
391 break;
392 }
393
394 if (finfo2.all_info.out.size != 10240) {
395 torture_result(tctx, TORTURE_FAIL,
396 "file not truncated, size = %u (should be 10240)",
397 (unsigned int)finfo2.all_info.out.size);
398 ret = false;
399 break;
400 }
401
402 torture_comment(tctx, "write time %s\n",
403 nt_time_string(tctx, finfo2.all_info.out.write_time));
404 if (finfo1.all_info.out.write_time != finfo2.all_info.out.write_time) {
405 double diff = timeval_elapsed(&start);
406 if (diff > (0.25 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
407 torture_comment(tctx, "After SMBwrite truncate "
408 "server updated write_time after %.2f seconds"
409 "(1 sec == %.2f)(wrong!)\n",
410 diff, sec);
411 ret = false;
412 break;
413 }
414
415 torture_comment(tctx, "After SMBwrite truncate "
416 "server updated write_time after %.2f seconds"
417 "(1 sec == %.2f)(correct)\n",
418 diff, sec);
419 break;
420 }
421 fflush(stdout);
422 smb_msleep(1 * msec);
423 }
424
425 if (finfo1.all_info.out.write_time == finfo2.all_info.out.write_time) {
426 torture_result(tctx, TORTURE_FAIL,
427 "Server did not update write time (wrong!)");
428 ret = false;
429 }
430
431 fflush(stdout);
432 smb_msleep(2 * msec);
433
434 /* Do a non-zero length SMBwrite and make sure it doesn't update the write time. */
435 written = smbcli_smbwrite(cli->tree, fnum1, "x", 0, 1);
436
437 torture_assert_int_equal(tctx, written, 1,
438 "unexpected number of bytes written");
439
440 start = timeval_current();
441 end = timeval_add(&start, (10*sec), 0);
442 while (!timeval_expired(&end)) {
443 status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
444
445 if (!NT_STATUS_IS_OK(status)) {
446 torture_result(tctx, TORTURE_FAIL, "fileinfo failed: %s\n",
447 nt_errstr(status));
448 ret = false;
449 break;
450 }
451
452 if (finfo3.all_info.out.size != 10240) {
453 torture_result(tctx, TORTURE_FAIL,
454 "file not truncated, size = %u (should be 10240)",
455 (unsigned int)finfo3.all_info.out.size);
456 ret = false;
457 break;
458 }
459
460 torture_comment(tctx, "write time %s\n",
461 nt_time_string(tctx, finfo3.all_info.out.write_time));
462 if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
463 double diff = timeval_elapsed(&start);
464
465 torture_comment(tctx, "server updated write_time after %.2f seconds"
466 "(1 sec == %.2f)(correct)\n",
467 diff, sec);
468 break;
469 }
470 fflush(stdout);
471 smb_msleep(1 * msec);
472 }
473
474 if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
475 torture_result(tctx, TORTURE_FAIL,
476 "Server updated write time (wrong!)");
477 ret = false;
478 }
479
480 /* the close should trigger an write time update */
481 smbcli_close(cli->tree, fnum1);
482 fnum1 = -1;
483
484 status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
485 torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
486
487 if (finfo3.all_info.out.write_time == pinfo4.all_info.out.write_time) {
488 torture_result(tctx, TORTURE_FAIL,
489 "Server did not update write time on close (wrong!)");
490 ret = false;
491 } else if (finfo3.all_info.out.write_time < pinfo4.all_info.out.write_time) {
492 torture_comment(tctx, "Server updated write time on close (correct)\n");
493 }
494
495 if (fnum1 != -1)
496 smbcli_close(cli->tree, fnum1);
497 smbcli_unlink(cli->tree, fname);
498 smbcli_deltree(cli->tree, BASEDIR);
499
500 return ret;
501 }
502
503 /* Updating with a SET_FILE_END_OF_FILE_INFO
504 * changes the write time immediately - even on expand. */
505
506 static bool test_delayed_write_update1b(struct torture_context *tctx, struct smbcli_state *cli)
507 {
508 union smb_fileinfo finfo1, finfo2, finfo3, pinfo4;
509 const char *fname = BASEDIR "\\torture_file1b.txt";
510 NTSTATUS status;
511 int fnum1 = -1;
512 bool ret = true;
513 ssize_t written;
514 struct timeval start;
515 struct timeval end;
516 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
517 int normal_delay = 2000000;
518 double sec = ((double)used_delay) / ((double)normal_delay);
519 int msec = 1000 * sec;
520 char buf[2048];
521
522 torture_comment(tctx, "\nRunning test_delayed_write_update1b\n");
523
524 if (!torture_setup_dir(cli, BASEDIR)) {
525 return false;
526 }
527
528 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
529 if (fnum1 == -1) {
530 torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
531 return false;
532 }
533
534 memset(buf, 'x', 2048);
535 written = smbcli_write(cli->tree, fnum1, 0, buf, 0, 2048);
536
537 /* 3 second delay to ensure we get past any 2 second time
538 granularity (older systems may have that) */
539 smb_msleep(3 * msec);
540
541 finfo1.all_info.level = RAW_FILEINFO_ALL_INFO;
542 finfo1.all_info.in.file.fnum = fnum1;
543 finfo2 = finfo1;
544 finfo3 = finfo1;
545 pinfo4.all_info.level = RAW_FILEINFO_ALL_INFO;
546 pinfo4.all_info.in.file.path = fname;
547
548 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
549
550 torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
551
552 torture_comment(tctx, "Initial write time %s\n",
553 nt_time_string(tctx, finfo1.all_info.out.write_time));
554
555 /* Do a SET_END_OF_FILE_INFO call to truncate. */
556 status = smbcli_ftruncate(cli->tree, fnum1, (uint64_t)10240);
557
558 torture_assert_ntstatus_ok(tctx, status, "SET_END_OF_FILE failed");
559
560 start = timeval_current();
561 end = timeval_add(&start, (120*sec), 0);
562 while (!timeval_expired(&end)) {
563 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
564
565 if (!NT_STATUS_IS_OK(status)) {
566 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
567 ret = false;
568 break;
569 }
570
571 if (finfo2.all_info.out.size != 10240) {
572 torture_result(tctx, TORTURE_FAIL,
573 "file not truncated (size = %u, should be 10240)",
574 (unsigned int)finfo2.all_info.out.size );
575 ret = false;
576 break;
577 }
578
579 torture_comment(tctx, "write time %s\n",
580 nt_time_string(tctx, finfo2.all_info.out.write_time));
581 if (finfo1.all_info.out.write_time != finfo2.all_info.out.write_time) {
582 double diff = timeval_elapsed(&start);
583 if (diff > (0.25 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
584 torture_result(tctx, TORTURE_FAIL,
585 "After SET_END_OF_FILE truncate "
586 "server updated write_time after %.2f seconds"
587 "(1 sec == %.2f)(wrong!)",
588 diff, sec);
589 ret = false;
590 break;
591 }
592
593 torture_comment(tctx, "After SET_END_OF_FILE truncate "
594 "server updated write_time after %.2f seconds"
595 "(1 sec == %.2f)(correct)\n",
596 diff, sec);
597 break;
598 }
599 fflush(stdout);
600 smb_msleep(1 * msec);
601 }
602
603 if (finfo1.all_info.out.write_time == finfo2.all_info.out.write_time) {
604 torture_result(tctx, TORTURE_FAIL,
605 "Server did not update write time (wrong!)");
606 ret = false;
607 }
608
609 fflush(stdout);
610 smb_msleep(2 * msec);
611
612 /* Do a non-zero length SMBwrite and make sure it doesn't update the write time. */
613 written = smbcli_smbwrite(cli->tree, fnum1, "x", 0, 1);
614
615 torture_assert_int_equal(tctx, written, 1,
616 "unexpected number of bytes written");
617
618 start = timeval_current();
619 end = timeval_add(&start, (10*sec), 0);
620 while (!timeval_expired(&end)) {
621 status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
622
623 if (!NT_STATUS_IS_OK(status)) {
624 torture_result(tctx, TORTURE_FAIL,
625 "fileinfo failed: %s", nt_errstr(status));
626 ret = false;
627 break;
628 }
629
630 if (finfo3.all_info.out.size != 10240) {
631 DEBUG(0, ("file not truncated (size = %u, should be 10240)\n",
632 (unsigned int)finfo3.all_info.out.size ));
633 ret = false;
634 break;
635 }
636
637 torture_comment(tctx, "write time %s\n",
638 nt_time_string(tctx, finfo3.all_info.out.write_time));
639 if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
640 double diff = timeval_elapsed(&start);
641
642 torture_comment(tctx, "server updated write_time after %.2f seconds"
643 "(1 sec == %.2f)(correct)\n",
644 diff, sec);
645 break;
646 }
647 fflush(stdout);
648 smb_msleep(1 * msec);
649 }
650
651 if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
652 torture_result(tctx, TORTURE_FAIL, "Server updated write time (wrong!)\n");
653 ret = false;
654 }
655
656 /* the close should trigger an write time update */
657 smbcli_close(cli->tree, fnum1);
658 fnum1 = -1;
659
660 status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
661 torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
662
663 if (finfo3.all_info.out.write_time == pinfo4.all_info.out.write_time) {
664 torture_result(tctx, TORTURE_FAIL, "Server did not update write time on close (wrong!)\n");
665 ret = false;
666 } else if (finfo3.all_info.out.write_time < pinfo4.all_info.out.write_time) {
667 torture_comment(tctx, "Server updated write time on close (correct)\n");
668 }
669
670 if (fnum1 != -1)
671 smbcli_close(cli->tree, fnum1);
672 smbcli_unlink(cli->tree, fname);
673 smbcli_deltree(cli->tree, BASEDIR);
674
675 return ret;
676 }
677
678 /* Updating with a SET_ALLOCATION_INFO (truncate) does so immediately. */
679
680 static bool test_delayed_write_update1c(struct torture_context *tctx, struct smbcli_state *cli)
681 {
682 union smb_setfileinfo parms;
683 union smb_fileinfo finfo1, finfo2, finfo3, pinfo4;
684 const char *fname = BASEDIR "\\torture_file1c.txt";
685 NTSTATUS status;
686 int fnum1 = -1;
687 bool ret = true;
688 ssize_t written;
689 struct timeval start;
690 struct timeval end;
691 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
692 int normal_delay = 2000000;
693 double sec = ((double)used_delay) / ((double)normal_delay);
694 int msec = 1000 * sec;
695 char buf[2048];
696
697 torture_comment(tctx, "\nRunning test_delayed_write_update1c\n");
698
699 if (!torture_setup_dir(cli, BASEDIR)) {
700 return false;
701 }
702
703 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
704 if (fnum1 == -1) {
705 torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
706 return false;
707 }
708
709 memset(buf, 'x', 2048);
710 written = smbcli_write(cli->tree, fnum1, 0, buf, 0, 2048);
711
712 /* 3 second delay to ensure we get past any 2 second time
713 granularity (older systems may have that) */
714 smb_msleep(3 * msec);
715
716 finfo1.all_info.level = RAW_FILEINFO_ALL_INFO;
717 finfo1.all_info.in.file.fnum = fnum1;
718 finfo2 = finfo1;
719 finfo3 = finfo1;
720 pinfo4.all_info.level = RAW_FILEINFO_ALL_INFO;
721 pinfo4.all_info.in.file.path = fname;
722
723 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
724
725 torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
726
727 torture_comment(tctx, "Initial write time %s\n",
728 nt_time_string(tctx, finfo1.all_info.out.write_time));
729
730 /* Do a SET_ALLOCATION_SIZE call to truncate. */
731 parms.allocation_info.level = RAW_SFILEINFO_ALLOCATION_INFO;
732 parms.allocation_info.in.file.fnum = fnum1;
733 parms.allocation_info.in.alloc_size = 0;
734
735 status = smb_raw_setfileinfo(cli->tree, &parms);
736
737 torture_assert_ntstatus_ok(tctx, status,
738 "RAW_SFILEINFO_ALLOCATION_INFO failed");
739
740 start = timeval_current();
741 end = timeval_add(&start, (120*sec), 0);
742 while (!timeval_expired(&end)) {
743 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
744
745 if (!NT_STATUS_IS_OK(status)) {
746 torture_result(tctx, TORTURE_FAIL, "fileinfo failed: %s",
747 nt_errstr(status));
748 ret = false;
749 break;
750 }
751
752 if (finfo2.all_info.out.size != 0) {
753 torture_result(tctx, TORTURE_FAIL,
754 "file not truncated (size = %u, should be 10240)",
755 (unsigned int)finfo2.all_info.out.size);
756 ret = false;
757 break;
758 }
759
760 torture_comment(tctx, "write time %s\n",
761 nt_time_string(tctx, finfo2.all_info.out.write_time));
762 if (finfo1.all_info.out.write_time != finfo2.all_info.out.write_time) {
763 double diff = timeval_elapsed(&start);
764 if (diff > (0.25 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
765 torture_comment(tctx, "After SET_ALLOCATION_INFO truncate "
766 "server updated write_time after %.2f seconds"
767 "(1 sec == %.2f)(wrong!)\n",
768 diff, sec);
769 ret = false;
770 break;
771 }
772
773 torture_comment(tctx, "After SET_ALLOCATION_INFO truncate "
774 "server updated write_time after %.2f seconds"
775 "(1 sec == %.2f)(correct)\n",
776 diff, sec);
777 break;
778 }
779 fflush(stdout);
780 smb_msleep(1 * msec);
781 }
782
783 if (finfo1.all_info.out.write_time == finfo2.all_info.out.write_time) {
784 torture_result(tctx, TORTURE_FAIL,
785 "Server did not update write time (wrong!)");
786 ret = false;
787 }
788
789 fflush(stdout);
790 smb_msleep(2 * msec);
791
792 /* Do a non-zero length SMBwrite and make sure it doesn't update the write time. */
793 written = smbcli_smbwrite(cli->tree, fnum1, "x", 0, 1);
794 torture_assert_int_equal(tctx, written, 1,
795 "Unexpected number of bytes written");
796
797 start = timeval_current();
798 end = timeval_add(&start, (10*sec), 0);
799 while (!timeval_expired(&end)) {
800 status = smb_raw_fileinfo(cli->tree, tctx, &finfo3);
801
802 if (!NT_STATUS_IS_OK(status)) {
803 torture_result(tctx, TORTURE_FAIL, "fileinfo failed: %s",
804 nt_errstr(status));
805 ret = false;
806 break;
807 }
808
809 if (finfo3.all_info.out.size != 1) {
810 torture_result(tctx, TORTURE_FAIL, "file not expanded");
811 ret = false;
812 break;
813 }
814
815 torture_comment(tctx, "write time %s\n",
816 nt_time_string(tctx, finfo3.all_info.out.write_time));
817 if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
818 double diff = timeval_elapsed(&start);
819
820 torture_comment(tctx, "server updated write_time after %.2f seconds"
821 "(1 sec == %.2f)(correct)\n",
822 diff, sec);
823 break;
824 }
825 fflush(stdout);
826 smb_msleep(1 * msec);
827 }
828
829 if (finfo2.all_info.out.write_time != finfo3.all_info.out.write_time) {
830 torture_result(tctx, TORTURE_FAIL,
831 "Server updated write time (wrong!)");
832 ret = false;
833 }
834
835 /* the close should trigger an write time update */
836 smbcli_close(cli->tree, fnum1);
837 fnum1 = -1;
838
839 status = smb_raw_pathinfo(cli->tree, tctx, &pinfo4);
840 torture_assert_ntstatus_ok(tctx, status, "pathinfo failed");
841
842 if (finfo3.all_info.out.write_time == pinfo4.all_info.out.write_time) {
843 torture_result(tctx, TORTURE_FAIL, "Server did not update write time on close (wrong!)\n");
844 ret = false;
845 } else if (finfo3.all_info.out.write_time < pinfo4.all_info.out.write_time) {
846 torture_comment(tctx, "Server updated write time on close (correct)\n");
847 }
848
849 if (fnum1 != -1)
850 smbcli_close(cli->tree, fnum1);
851 smbcli_unlink(cli->tree, fname);
852 smbcli_deltree(cli->tree, BASEDIR);
853
854 return ret;
855 }
856
857 /*
858 * Do as above, but using 2 connections.
859 */
860
861 static bool test_delayed_write_update2(struct torture_context *tctx, struct smbcli_state *cli,
862 struct smbcli_state *cli2)
863 {
864 union smb_fileinfo finfo1, finfo2;
865 const char *fname = BASEDIR "\\torture_file.txt";
866 NTSTATUS status;
867 int fnum1 = -1;
868 int fnum2 = -1;
869 bool ret = true;
870 ssize_t written;
871 struct timeval start;
872 struct timeval end;
873 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
874 int normal_delay = 2000000;
875 double sec = ((double)used_delay) / ((double)normal_delay);
876 int msec = 1000 * sec;
877 union smb_flush flsh;
878
879 torture_comment(tctx, "\nRunning test_delayed_write_update2\n");
880
881 if (!torture_setup_dir(cli, BASEDIR)) {
882 return false;
883 }
884
885 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
886 if (fnum1 == -1) {
887 torture_comment(tctx, "Failed to open %s\n", fname);
888 return false;
889 }
890
891 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
892 finfo1.basic_info.in.file.fnum = fnum1;
893 finfo2 = finfo1;
894
895 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
896
897 torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
898
899 torture_comment(tctx, "Initial write time %s\n",
900 nt_time_string(tctx, finfo1.basic_info.out.write_time));
901
902 /* 3 second delay to ensure we get past any 2 second time
903 granularity (older systems may have that) */
904 smb_msleep(3 * msec);
905
906 {
907 /* Try using setfileinfo instead of write to update write time. */
908 union smb_setfileinfo sfinfo;
909 time_t t_set = time(NULL);
910 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO;
911 sfinfo.basic_info.in.file.fnum = fnum1;
912 sfinfo.basic_info.in.create_time = finfo1.basic_info.out.create_time;
913 sfinfo.basic_info.in.access_time = finfo1.basic_info.out.access_time;
914
915 /* I tried this with both + and - ve to see if it makes a different.
916 It doesn't - once the filetime is set via setfileinfo it stays that way. */
917 #if 1
918 unix_to_nt_time(&sfinfo.basic_info.in.write_time, t_set - 30000);
919 #else
920 unix_to_nt_time(&sfinfo.basic_info.in.write_time, t_set + 30000);
921 #endif
922 sfinfo.basic_info.in.change_time = finfo1.basic_info.out.change_time;
923 sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib;
924
925 status = smb_raw_setfileinfo(cli->tree, &sfinfo);
926
927 torture_assert_ntstatus_ok(tctx, status, "sfileinfo failed");
928 }
929
930 finfo2.basic_info.in.file.path = fname;
931
932 status = smb_raw_pathinfo(cli2->tree, tctx, &finfo2);
933
934 if (!NT_STATUS_IS_OK(status)) {
935 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
936 return false;
937 }
938 torture_comment(tctx, "write time %s\n",
939 nt_time_string(tctx, finfo2.basic_info.out.write_time));
940
941 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
942 torture_comment(tctx, "Server updated write_time (correct)\n");
943 } else {
944 torture_result(tctx, TORTURE_FAIL, "Server did not update write time (wrong!)\n");
945 ret = false;
946 }
947
948 /* Now try a write to see if the write time gets reset. */
949
950 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
951 finfo1.basic_info.in.file.fnum = fnum1;
952 finfo2 = finfo1;
953
954 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
955
956 if (!NT_STATUS_IS_OK(status)) {
957 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
958 return false;
959 }
960
961 torture_comment(tctx, "Modified write time %s\n",
962 nt_time_string(tctx, finfo1.basic_info.out.write_time));
963
964
965 torture_comment(tctx, "Doing a 10 byte write to extend the file and see if this changes the last write time.\n");
966
967 written = smbcli_write(cli->tree, fnum1, 0, "0123456789", 1, 10);
968
969 if (written != 10) {
970 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
971 (int)written, __location__);
972 return false;
973 }
974
975 /* Just to prove to tridge that the an smbflush has no effect on
976 the write time :-). The setfileinfo IS STICKY. JRA. */
977
978 torture_comment(tctx, "Doing flush after write\n");
979
980 flsh.flush.level = RAW_FLUSH_FLUSH;
981 flsh.flush.in.file.fnum = fnum1;
982 status = smb_raw_flush(cli->tree, &flsh);
983 if (!NT_STATUS_IS_OK(status)) {
984 DEBUG(0, ("smbflush failed: %s\n", nt_errstr(status)));
985 return false;
986 }
987
988 /* Once the time was set using setfileinfo then it stays set - writes
989 don't have any effect. But make sure. */
990 start = timeval_current();
991 end = timeval_add(&start, (15*sec), 0);
992 while (!timeval_expired(&end)) {
993 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
994
995 if (!NT_STATUS_IS_OK(status)) {
996 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
997 ret = false;
998 break;
999 }
1000 torture_comment(tctx, "write time %s\n",
1001 nt_time_string(tctx, finfo2.basic_info.out.write_time));
1002 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
1003 double diff = timeval_elapsed(&start);
1004 torture_comment(tctx, "Server updated write_time after %.2f seconds"
1005 "(1sec == %.2f) (wrong!)\n",
1006 diff, sec);
1007 ret = false;
1008 break;
1009 }
1010 fflush(stdout);
1011 smb_msleep(1 * msec);
1012 }
1013
1014 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
1015 torture_comment(tctx, "Server did not update write time (correct)\n");
1016 }
1017
1018 fflush(stdout);
1019 smb_msleep(2 * msec);
1020
1021 fnum2 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
1022 if (fnum2 == -1) {
1023 torture_comment(tctx, "Failed to open %s\n", fname);
1024 return false;
1025 }
1026
1027 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");
1028
1029 written = smbcli_write(cli->tree, fnum2, 0, "0123456789", 11, 10);
1030
1031 if (written != 10) {
1032 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
1033 (int)written, __location__);
1034 return false;
1035 }
1036
1037 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
1038
1039 if (!NT_STATUS_IS_OK(status)) {
1040 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
1041 return false;
1042 }
1043 torture_comment(tctx, "write time %s\n",
1044 nt_time_string(tctx, finfo2.basic_info.out.write_time));
1045 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
1046 torture_comment(tctx, "Server updated write_time (wrong!)\n");
1047 ret = false;
1048 }
1049
1050 torture_comment(tctx, "Closing the first fd to see if write time updated.\n");
1051 smbcli_close(cli->tree, fnum1);
1052 fnum1 = -1;
1053
1054 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");
1055
1056 written = smbcli_write(cli->tree, fnum2, 0, "0123456789", 21, 10);
1057
1058 if (written != 10) {
1059 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
1060 (int)written, __location__);
1061 return false;
1062 }
1063
1064 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1065 finfo1.basic_info.in.file.fnum = fnum2;
1066 finfo2 = finfo1;
1067 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
1068
1069 if (!NT_STATUS_IS_OK(status)) {
1070 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
1071 return false;
1072 }
1073 torture_comment(tctx, "write time %s\n",
1074 nt_time_string(tctx, finfo2.basic_info.out.write_time));
1075 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
1076 torture_comment(tctx, "Server updated write_time (wrong!)\n");
1077 ret = false;
1078 }
1079
1080 /* Once the time was set using setfileinfo then it stays set - writes
1081 don't have any effect. But make sure. */
1082 start = timeval_current();
1083 end = timeval_add(&start, (15*sec), 0);
1084 while (!timeval_expired(&end)) {
1085 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
1086
1087 if (!NT_STATUS_IS_OK(status)) {
1088 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
1089 ret = false;
1090 break;
1091 }
1092 torture_comment(tctx, "write time %s\n",
1093 nt_time_string(tctx, finfo2.basic_info.out.write_time));
1094 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
1095 double diff = timeval_elapsed(&start);
1096 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1097 "(1sec == %.2f) (wrong!)\n",
1098 diff, sec);
1099 ret = false;
1100 break;
1101 }
1102 fflush(stdout);
1103 smb_msleep(1 * msec);
1104 }
1105
1106 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
1107 torture_comment(tctx, "Server did not update write time (correct)\n");
1108 }
1109
1110 torture_comment(tctx, "Closing second fd to see if write time updated.\n");
1111
1112 smbcli_close(cli->tree, fnum2);
1113 fnum2 = -1;
1114
1115 fnum1 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
1116 if (fnum1 == -1) {
1117 torture_comment(tctx, "Failed to open %s\n", fname);
1118 return false;
1119 }
1120
1121 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1122 finfo1.basic_info.in.file.fnum = fnum1;
1123 finfo2 = finfo1;
1124
1125 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
1126
1127 if (!NT_STATUS_IS_OK(status)) {
1128 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
1129 return false;
1130 }
1131
1132 torture_comment(tctx, "Second open initial write time %s\n",
1133 nt_time_string(tctx, finfo1.basic_info.out.write_time));
1134
1135 smb_msleep(10 * msec);
1136 torture_comment(tctx, "Doing a 10 byte write to extend the file to see if this changes the last write time.\n");
1137
1138 written = smbcli_write(cli->tree, fnum1, 0, "0123456789", 31, 10);
1139
1140 if (written != 10) {
1141 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n",
1142 (int)written, __location__);
1143 return false;
1144 }
1145
1146 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1147 finfo1.basic_info.in.file.fnum = fnum1;
1148 finfo2 = finfo1;
1149 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
1150
1151 if (!NT_STATUS_IS_OK(status)) {
1152 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
1153 return false;
1154 }
1155 torture_comment(tctx, "write time %s\n",
1156 nt_time_string(tctx, finfo2.basic_info.out.write_time));
1157 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
1158 torture_comment(tctx, "Server updated write_time (wrong!)\n");
1159 ret = false;
1160 }
1161
1162 /* Now the write time should be updated again */
1163 start = timeval_current();
1164 end = timeval_add(&start, (15*sec), 0);
1165 while (!timeval_expired(&end)) {
1166 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
1167
1168 if (!NT_STATUS_IS_OK(status)) {
1169 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
1170 ret = false;
1171 break;
1172 }
1173 torture_comment(tctx, "write time %s\n",
1174 nt_time_string(tctx, finfo2.basic_info.out.write_time));
1175 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
1176 double diff = timeval_elapsed(&start);
1177 if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
1178 torture_comment(tctx, "Server updated write_time after %.2f seconds"
1179 "(1sec == %.2f) (wrong!)\n",
1180 diff, sec);
1181 ret = false;
1182 break;
1183 }
1184
1185 torture_comment(tctx, "Server updated write_time after %.2f seconds"
1186 "(1sec == %.2f) (correct)\n",
1187 diff, sec);
1188 break;
1189 }
1190 fflush(stdout);
1191 smb_msleep(1*msec);
1192 }
1193
1194 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
1195 torture_result(tctx, TORTURE_FAIL, "Server did not update write time (wrong!)\n");
1196 ret = false;
1197 }
1198
1199
1200 /* One more test to do. We should read the filetime via findfirst on the
1201 second connection to ensure it's the same. This is very easy for a Windows
1202 server but a bastard to get right on a POSIX server. JRA. */
1203
1204 if (fnum1 != -1)
1205 smbcli_close(cli->tree, fnum1);
1206 smbcli_unlink(cli->tree, fname);
1207 smbcli_deltree(cli->tree, BASEDIR);
1208
1209 return ret;
1210 }
1211
1212
1213 /* Windows does obviously not update the stat info during a write call. I
1214 * *think* this is the problem causing a spurious Excel 2003 on XP error
1215 * message when saving a file. Excel does a setfileinfo, writes, and then does
1216 * a getpath(!)info. Or so... For Samba sometimes it displays an error message
1217 * that the file might have been changed in between. What i've been able to
1218 * trace down is that this happens if the getpathinfo after the write shows a
1219 * different last write time than the setfileinfo showed. This is really
1220 * nasty....
1221 */
1222
1223 static bool test_finfo_after_write(struct torture_context *tctx, struct smbcli_state *cli,
1224 struct smbcli_state *cli2)
1225 {
1226 union smb_fileinfo finfo1, finfo2;
1227 const char *fname = BASEDIR "\\torture_file.txt";
1228 NTSTATUS status;
1229 int fnum1 = -1;
1230 int fnum2;
1231 bool ret = true;
1232 ssize_t written;
1233 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1234 int normal_delay = 2000000;
1235 double sec = ((double)used_delay) / ((double)normal_delay);
1236 int msec = 1000 * sec;
1237
1238 torture_comment(tctx, "\nRunning test_finfo_after_write\n");
1239
1240 if (!torture_setup_dir(cli, BASEDIR)) {
1241 return false;
1242 }
1243
1244 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1245 if (fnum1 == -1) {
1246 ret = false;
1247 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1248 goto done;
1249 }
1250
1251 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1252 finfo1.basic_info.in.file.fnum = fnum1;
1253
1254 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
1255
1256 if (!NT_STATUS_IS_OK(status)) {
1257 ret = false;
1258 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", nt_errstr(status));
1259 goto done;
1260 }
1261
1262 smb_msleep(1 * msec);
1263
1264 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1265
1266 if (written != 1) {
1267 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1268 ret = false;
1269 goto done;
1270 }
1271
1272 fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
1273 if (fnum2 == -1) {
1274 torture_result(tctx, TORTURE_FAIL, __location__": failed to open 2nd time - %s",
1275 smbcli_errstr(cli2->tree));
1276 ret = false;
1277 goto done;
1278 }
1279
1280 written = smbcli_write(cli2->tree, fnum2, 0, "x", 0, 1);
1281
1282 if (written != 1) {
1283 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1",
1284 (int)written);
1285 ret = false;
1286 goto done;
1287 }
1288
1289 finfo2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1290 finfo2.basic_info.in.file.path = fname;
1291
1292 status = smb_raw_pathinfo(cli2->tree, tctx, &finfo2);
1293
1294 if (!NT_STATUS_IS_OK(status)) {
1295 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s",
1296 nt_errstr(status));
1297 ret = false;
1298 goto done;
1299 }
1300
1301 if (finfo1.basic_info.out.create_time !=
1302 finfo2.basic_info.out.create_time) {
1303 torture_result(tctx, TORTURE_FAIL, __location__": create_time changed");
1304 ret = false;
1305 goto done;
1306 }
1307
1308 if (finfo1.basic_info.out.access_time !=
1309 finfo2.basic_info.out.access_time) {
1310 torture_result(tctx, TORTURE_FAIL, __location__": access_time changed");
1311 ret = false;
1312 goto done;
1313 }
1314
1315 if (finfo1.basic_info.out.write_time !=
1316 finfo2.basic_info.out.write_time) {
1317 torture_result(tctx, TORTURE_FAIL, __location__": write_time changed:\n"
1318 "write time conn 1 = %s, conn 2 = %s",
1319 nt_time_string(tctx, finfo1.basic_info.out.write_time),
1320 nt_time_string(tctx, finfo2.basic_info.out.write_time));
1321 ret = false;
1322 goto done;
1323 }
1324
1325 if (finfo1.basic_info.out.change_time !=
1326 finfo2.basic_info.out.change_time) {
1327 torture_result(tctx, TORTURE_FAIL, __location__": change_time changed");
1328 ret = false;
1329 goto done;
1330 }
1331
1332 /* One of the two following calls updates the qpathinfo. */
1333
1334 /* If you had skipped the smbcli_write on fnum2, it would
1335 * *not* have updated the stat on disk */
1336
1337 smbcli_close(cli2->tree, fnum2);
1338 cli2 = NULL;
1339
1340 /* This call is only for the people looking at ethereal :-) */
1341 finfo2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1342 finfo2.basic_info.in.file.path = fname;
1343
1344 status = smb_raw_pathinfo(cli->tree, tctx, &finfo2);
1345
1346 if (!NT_STATUS_IS_OK(status)) {
1347 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", nt_errstr(status));
1348 ret = false;
1349 goto done;
1350 }
1351
1352 done:
1353 if (fnum1 != -1)
1354 smbcli_close(cli->tree, fnum1);
1355 smbcli_unlink(cli->tree, fname);
1356 smbcli_deltree(cli->tree, BASEDIR);
1357
1358 return ret;
1359 }
1360
1361 #define COMPARE_WRITE_TIME_CMP(given, correct, cmp) do { \
1362 uint64_t r = 10*1000*1000; \
1363 NTTIME g = (given).basic_info.out.write_time; \
1364 NTTIME gr = (g / r) * r; \
1365 NTTIME c = (correct).basic_info.out.write_time; \
1366 NTTIME cr = (c / r) * r; \
1367 bool strict = torture_setting_bool(tctx, "strict mode", false); \
1368 bool err = false; \
1369 if (strict && (g cmp c)) { \
1370 err = true; \
1371 } else if ((g cmp c) && (gr cmp cr)) { \
1372 /* handle filesystem without high resolution timestamps */ \
1373 err = true; \
1374 } \
1375 if (err) { \
1376 torture_result(tctx, TORTURE_FAIL, __location__": wrong write_time (%s)%s(%llu) %s (%s)%s(%llu)", \
1377 #given, nt_time_string(tctx, g), (unsigned long long)g, \
1378 #cmp, #correct, nt_time_string(tctx, c), (unsigned long long)c); \
1379 ret = false; \
1380 goto done; \
1381 } \
1382 } while (0)
1383 #define COMPARE_WRITE_TIME_EQUAL(given,correct) \
1384 COMPARE_WRITE_TIME_CMP(given,correct,!=)
1385 #define COMPARE_WRITE_TIME_GREATER(given,correct) \
1386 COMPARE_WRITE_TIME_CMP(given,correct,<=)
1387 #define COMPARE_WRITE_TIME_LESS(given,correct) \
1388 COMPARE_WRITE_TIME_CMP(given,correct,>=)
1389
1390 #define COMPARE_ACCESS_TIME_CMP(given, correct, cmp) do { \
1391 NTTIME g = (given).basic_info.out.access_time; \
1392 NTTIME c = (correct).basic_info.out.access_time; \
1393 if (g cmp c) { \
1394 torture_result(tctx, TORTURE_FAIL, __location__": wrong access_time (%s)%s %s (%s)%s", \
1395 #given, nt_time_string(tctx, g), \
1396 #cmp, #correct, nt_time_string(tctx, c)); \
1397 ret = false; \
1398 goto done; \
1399 } \
1400 } while (0)
1401 #define COMPARE_ACCESS_TIME_EQUAL(given,correct) \
1402 COMPARE_ACCESS_TIME_CMP(given,correct,!=)
1403
1404 #define COMPARE_BOTH_TIMES_EQUAL(given,correct) do { \
1405 COMPARE_ACCESS_TIME_EQUAL(given,correct); \
1406 COMPARE_WRITE_TIME_EQUAL(given,correct); \
1407 } while (0)
1408
1409 #define GET_INFO_FILE(finfo) do { \
1410 NTSTATUS _status; \
1411 _status = smb_raw_fileinfo(cli->tree, tctx, &finfo); \
1412 if (!NT_STATUS_IS_OK(_status)) { \
1413 ret = false; \
1414 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", \
1415 nt_errstr(_status)); \
1416 goto done; \
1417 } \
1418 torture_comment(tctx, "fileinfo: Access(%s) Write(%s)\n", \
1419 nt_time_string(tctx, finfo.basic_info.out.access_time), \
1420 nt_time_string(tctx, finfo.basic_info.out.write_time)); \
1421 } while (0)
1422 #define GET_INFO_FILE2(finfo) do { \
1423 NTSTATUS _status; \
1424 _status = smb_raw_fileinfo(cli2->tree, tctx, &finfo); \
1425 if (!NT_STATUS_IS_OK(_status)) { \
1426 ret = false; \
1427 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", \
1428 nt_errstr(_status)); \
1429 goto done; \
1430 } \
1431 torture_comment(tctx, "fileinfo: Access(%s) Write(%s)\n", \
1432 nt_time_string(tctx, finfo.basic_info.out.access_time), \
1433 nt_time_string(tctx, finfo.basic_info.out.write_time)); \
1434 } while (0)
1435 #define GET_INFO_PATH(pinfo) do { \
1436 NTSTATUS _status; \
1437 _status = smb_raw_pathinfo(cli2->tree, tctx, &pinfo); \
1438 if (!NT_STATUS_IS_OK(_status)) { \
1439 torture_result(tctx, TORTURE_FAIL, __location__": pathinfo failed: %s", \
1440 nt_errstr(_status)); \
1441 ret = false; \
1442 goto done; \
1443 } \
1444 torture_comment(tctx, "pathinfo: Access(%s) Write(%s)\n", \
1445 nt_time_string(tctx, pinfo.basic_info.out.access_time), \
1446 nt_time_string(tctx, pinfo.basic_info.out.write_time)); \
1447 } while (0)
1448 #define GET_INFO_BOTH(finfo,pinfo) do { \
1449 GET_INFO_FILE(finfo); \
1450 GET_INFO_PATH(pinfo); \
1451 COMPARE_BOTH_TIMES_EQUAL(finfo,pinfo); \
1452 } while (0)
1453
1454 #define SET_INFO_FILE_EX(finfo, wrtime, tree, tfnum) do { \
1455 NTSTATUS _status; \
1456 union smb_setfileinfo sfinfo; \
1457 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO; \
1458 sfinfo.basic_info.in.file.fnum = tfnum; \
1459 sfinfo.basic_info.in.create_time = 0; \
1460 sfinfo.basic_info.in.access_time = 0; \
1461 unix_to_nt_time(&sfinfo.basic_info.in.write_time, (wrtime)); \
1462 sfinfo.basic_info.in.change_time = 0; \
1463 sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib; \
1464 _status = smb_raw_setfileinfo(tree, &sfinfo); \
1465 if (!NT_STATUS_IS_OK(_status)) { \
1466 torture_result(tctx, TORTURE_FAIL, __location__": setfileinfo failed: %s", \
1467 nt_errstr(_status)); \
1468 ret = false; \
1469 goto done; \
1470 } \
1471 } while (0)
1472 #define SET_INFO_FILE(finfo, wrtime) \
1473 SET_INFO_FILE_EX(finfo, wrtime, cli->tree, fnum1)
1474
1475 #define SET_INFO_FILE_NS(finfo, wrtime, ns, tree, tfnum) do { \
1476 NTSTATUS _status; \
1477 union smb_setfileinfo sfinfo; \
1478 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO; \
1479 sfinfo.basic_info.in.file.fnum = tfnum; \
1480 sfinfo.basic_info.in.create_time = 0; \
1481 sfinfo.basic_info.in.access_time = 0; \
1482 unix_to_nt_time(&sfinfo.basic_info.in.write_time, (wrtime)); \
1483 sfinfo.basic_info.in.write_time += (ns); \
1484 sfinfo.basic_info.in.change_time = 0; \
1485 sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib; \
1486 _status = smb_raw_setfileinfo(tree, &sfinfo); \
1487 if (!NT_STATUS_IS_OK(_status)) { \
1488 torture_result(tctx, TORTURE_FAIL, __location__": setfileinfo failed: %s", \
1489 nt_errstr(_status)); \
1490 ret = false; \
1491 goto done; \
1492 } \
1493 } while (0)
1494
1495 static bool test_delayed_write_update3(struct torture_context *tctx,
1496 struct smbcli_state *cli,
1497 struct smbcli_state *cli2)
1498 {
1499 union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
1500 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
1501 const char *fname = BASEDIR "\\torture_file3.txt";
1502 int fnum1 = -1;
1503 bool ret = true;
1504 ssize_t written;
1505 struct timeval start;
1506 struct timeval end;
1507 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1508 int normal_delay = 2000000;
1509 double sec = ((double)used_delay) / ((double)normal_delay);
1510 int msec = 1000 * sec;
1511
1512 torture_comment(tctx, "\nRunning test_delayed_write_update3\n");
1513
1514 if (!torture_setup_dir(cli, BASEDIR)) {
1515 return false;
1516 }
1517
1518 torture_comment(tctx, "Open the file handle\n");
1519 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1520 if (fnum1 == -1) {
1521 ret = false;
1522 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1523 goto done;
1524 }
1525
1526 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1527 finfo0.basic_info.in.file.fnum = fnum1;
1528 finfo1 = finfo0;
1529 finfo2 = finfo0;
1530 finfo3 = finfo0;
1531 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1532 pinfo0.basic_info.in.file.path = fname;
1533 pinfo1 = pinfo0;
1534 pinfo2 = pinfo0;
1535 pinfo3 = pinfo0;
1536 pinfo4 = pinfo0;
1537
1538 /* get the initial times */
1539 GET_INFO_BOTH(finfo0,pinfo0);
1540
1541 /*
1542 * make sure the write time is updated 2 seconds later
1543 * calcuated from the first write
1544 * (but expect upto 5 seconds extra time for a busy server)
1545 */
1546 start = timeval_current();
1547 end = timeval_add(&start, 7 * sec, 0);
1548 while (!timeval_expired(&end)) {
1549 /* do a write */
1550 torture_comment(tctx, "Do a write on the file handle\n");
1551 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1552 if (written != 1) {
1553 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1554 ret = false;
1555 goto done;
1556 }
1557 /* get the times after the write */
1558 GET_INFO_FILE(finfo1);
1559
1560 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
1561 double diff = timeval_elapsed(&start);
1562 if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
1563 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1564 "(1sec == %.2f) (wrong!)\n",
1565 diff, sec);
1566 ret = false;
1567 break;
1568 }
1569
1570 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1571 "(1sec == %.2f) (correct)\n",
1572 diff, sec);
1573 break;
1574 }
1575 smb_msleep(0.5 * msec);
1576 }
1577
1578 GET_INFO_BOTH(finfo1,pinfo1);
1579 COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
1580
1581 /* sure any further write doesn't update the write time */
1582 start = timeval_current();
1583 end = timeval_add(&start, 15 * sec, 0);
1584 while (!timeval_expired(&end)) {
1585 /* do a write */
1586 torture_comment(tctx, "Do a write on the file handle\n");
1587 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1588 if (written != 1) {
1589 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1590 ret = false;
1591 goto done;
1592 }
1593 /* get the times after the write */
1594 GET_INFO_BOTH(finfo2,pinfo2);
1595
1596 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
1597 double diff = timeval_elapsed(&start);
1598 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1599 "(1sec == %.2f) (wrong!)\n",
1600 diff, sec);
1601 ret = false;
1602 break;
1603 }
1604 smb_msleep(1 * msec);
1605 }
1606
1607 GET_INFO_BOTH(finfo2,pinfo2);
1608 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
1609 if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
1610 torture_comment(tctx, "Server did not update write_time (correct)\n");
1611 }
1612
1613 /* sleep */
1614 smb_msleep(5 * msec);
1615
1616 GET_INFO_BOTH(finfo3,pinfo3);
1617 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1618
1619 /*
1620 * the close updates the write time to the time of the close
1621 * and not to the time of the last write!
1622 */
1623 torture_comment(tctx, "Close the file handle\n");
1624 smbcli_close(cli->tree, fnum1);
1625 fnum1 = -1;
1626
1627 GET_INFO_PATH(pinfo4);
1628 COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
1629
1630 if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
1631 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
1632 }
1633
1634 done:
1635 if (fnum1 != -1)
1636 smbcli_close(cli->tree, fnum1);
1637 smbcli_unlink(cli->tree, fname);
1638 smbcli_deltree(cli->tree, BASEDIR);
1639
1640 return ret;
1641 }
1642
1643 /*
1644 * Show that a truncate write always updates the write time even
1645 * if an initial write has already updated the write time.
1646 */
1647
1648 static bool test_delayed_write_update3a(struct torture_context *tctx,
1649 struct smbcli_state *cli,
1650 struct smbcli_state *cli2)
1651 {
1652 union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
1653 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
1654 const char *fname = BASEDIR "\\torture_file3a.txt";
1655 int fnum1 = -1;
1656 bool ret = true;
1657 ssize_t written;
1658 int i;
1659 struct timeval start;
1660 struct timeval end;
1661 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1662 int normal_delay = 2000000;
1663 double sec = ((double)used_delay) / ((double)normal_delay);
1664 int msec = 1000 * sec;
1665
1666 torture_comment(tctx, "\nRunning test_delayed_write_update3a\n");
1667
1668 if (!torture_setup_dir(cli, BASEDIR)) {
1669 return false;
1670 }
1671
1672 torture_comment(tctx, "Open the file handle\n");
1673 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1674 if (fnum1 == -1) {
1675 ret = false;
1676 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1677 goto done;
1678 }
1679
1680 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1681 finfo0.basic_info.in.file.fnum = fnum1;
1682 finfo1 = finfo0;
1683 finfo2 = finfo0;
1684 finfo3 = finfo0;
1685 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1686 pinfo0.basic_info.in.file.path = fname;
1687 pinfo1 = pinfo0;
1688 pinfo2 = pinfo0;
1689 pinfo3 = pinfo0;
1690 pinfo4 = pinfo0;
1691
1692 /* get the initial times */
1693 GET_INFO_BOTH(finfo0,pinfo0);
1694
1695 /*
1696 * sleep some time, to demonstrate the handling of write times
1697 * doesn't depend on the time since the open
1698 */
1699 smb_msleep(5 * msec);
1700
1701 /* get the initial times */
1702 GET_INFO_BOTH(finfo1,pinfo1);
1703 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
1704
1705 /*
1706 * make sure the write time is updated 2 seconds later
1707 * calcuated from the first write
1708 * (but expect upto 5 seconds extra time for a busy server)
1709 */
1710 start = timeval_current();
1711 end = timeval_add(&start, 7 * sec, 0);
1712 while (!timeval_expired(&end)) {
1713 /* do a write */
1714 torture_comment(tctx, "Do a write on the file handle\n");
1715 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1716 if (written != 1) {
1717 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1718 ret = false;
1719 goto done;
1720 }
1721 /* get the times after the write */
1722 GET_INFO_FILE(finfo1);
1723
1724 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
1725 double diff = timeval_elapsed(&start);
1726 if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
1727 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1728 "(1sec == %.2f) (wrong!)\n",
1729 diff, sec);
1730 ret = false;
1731 break;
1732 }
1733
1734 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1735 "(1sec == %.2f) (correct)\n",
1736 diff, sec);
1737 break;
1738 }
1739 smb_msleep(0.5 * msec);
1740 }
1741
1742 GET_INFO_BOTH(finfo1,pinfo1);
1743 COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
1744
1745 smb_msleep(3 * msec);
1746
1747 /*
1748 * demonstrate that a truncate write always
1749 * updates the write time immediately
1750 */
1751 for (i=0; i < 3; i++) {
1752 smb_msleep(2 * msec);
1753 /* do a write */
1754 torture_comment(tctx, "Do a truncate SMBwrite [%d] on the file handle\n", i);
1755 written = smbcli_smbwrite(cli->tree, fnum1, "x", 10240, 0);
1756 if (written != 0) {
1757 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 0", (int)written);
1758 ret = false;
1759 goto done;
1760 }
1761 /* get the times after the write */
1762 GET_INFO_BOTH(finfo2,pinfo2);
1763 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
1764 finfo1 = finfo2;
1765 }
1766
1767 smb_msleep(3 * msec);
1768
1769 /* sure any further write doesn't update the write time */
1770 start = timeval_current();
1771 end = timeval_add(&start, 15 * sec, 0);
1772 while (!timeval_expired(&end)) {
1773 /* do a write */
1774 torture_comment(tctx, "Do a write on the file handle\n");
1775 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1776 if (written != 1) {
1777 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1778 ret = false;
1779 goto done;
1780 }
1781 /* get the times after the write */
1782 GET_INFO_BOTH(finfo2,pinfo2);
1783
1784 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
1785 double diff = timeval_elapsed(&start);
1786 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1787 "(1sec == %.2f) (wrong!)\n",
1788 diff, sec);
1789 ret = false;
1790 break;
1791 }
1792 smb_msleep(1 * msec);
1793 }
1794
1795 GET_INFO_BOTH(finfo2,pinfo2);
1796 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
1797 if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
1798 torture_comment(tctx, "Server did not update write_time (correct)\n");
1799 }
1800
1801 /* sleep */
1802 smb_msleep(3 * msec);
1803
1804 /* get the initial times */
1805 GET_INFO_BOTH(finfo1,pinfo1);
1806 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo2);
1807
1808 /*
1809 * demonstrate that a truncate write always
1810 * updates the write time immediately
1811 */
1812 for (i=0; i < 3; i++) {
1813 smb_msleep(2 * msec);
1814 /* do a write */
1815 torture_comment(tctx, "Do a truncate SMBwrite [%d] on the file handle\n", i);
1816 written = smbcli_smbwrite(cli->tree, fnum1, "x", 512, 0);
1817 if (written != 0) {
1818 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 0", (int)written);
1819 ret = false;
1820 goto done;
1821 }
1822 /* get the times after the write */
1823 GET_INFO_BOTH(finfo2,pinfo2);
1824 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
1825 finfo1 = finfo2;
1826 }
1827
1828 /* sleep */
1829 smb_msleep(3 * msec);
1830
1831 GET_INFO_BOTH(finfo3,pinfo3);
1832 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1833
1834 /*
1835 * the close doesn't update the write time
1836 */
1837 torture_comment(tctx, "Close the file handle\n");
1838 smbcli_close(cli->tree, fnum1);
1839 fnum1 = -1;
1840
1841 GET_INFO_PATH(pinfo4);
1842 COMPARE_WRITE_TIME_EQUAL(pinfo4, pinfo3);
1843
1844 if (pinfo4.basic_info.out.write_time == pinfo3.basic_info.out.write_time) {
1845 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
1846 }
1847
1848 done:
1849 if (fnum1 != -1)
1850 smbcli_close(cli->tree, fnum1);
1851 smbcli_unlink(cli->tree, fname);
1852 smbcli_deltree(cli->tree, BASEDIR);
1853
1854 return ret;
1855 }
1856
1857 /*
1858 * Show a close after write updates the write timestamp to
1859 * the close time, not the last write time.
1860 */
1861
1862 static bool test_delayed_write_update3b(struct torture_context *tctx,
1863 struct smbcli_state *cli,
1864 struct smbcli_state *cli2)
1865 {
1866 union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
1867 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
1868 const char *fname = BASEDIR "\\torture_file3b.txt";
1869 int fnum1 = -1;
1870 bool ret = true;
1871 ssize_t written;
1872 struct timeval start;
1873 struct timeval end;
1874 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1875 int normal_delay = 2000000;
1876 double sec = ((double)used_delay) / ((double)normal_delay);
1877 int msec = 1000 * sec;
1878
1879 torture_comment(tctx, "\nRunning test_delayed_write_update3b\n");
1880
1881 if (!torture_setup_dir(cli, BASEDIR)) {
1882 return false;
1883 }
1884
1885 torture_comment(tctx, "Open the file handle\n");
1886 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1887 if (fnum1 == -1) {
1888 ret = false;
1889 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1890 goto done;
1891 }
1892
1893 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1894 finfo0.basic_info.in.file.fnum = fnum1;
1895 finfo1 = finfo0;
1896 finfo2 = finfo0;
1897 finfo3 = finfo0;
1898 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1899 pinfo0.basic_info.in.file.path = fname;
1900 pinfo1 = pinfo0;
1901 pinfo2 = pinfo0;
1902 pinfo3 = pinfo0;
1903 pinfo4 = pinfo0;
1904
1905 /* get the initial times */
1906 GET_INFO_BOTH(finfo0,pinfo0);
1907
1908 /*
1909 * sleep some time, to demonstrate the handling of write times
1910 * doesn't depend on the time since the open
1911 */
1912 smb_msleep(5 * msec);
1913
1914 /* get the initial times */
1915 GET_INFO_BOTH(finfo1,pinfo1);
1916 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
1917
1918 /*
1919 * make sure the write time is updated 2 seconds later
1920 * calcuated from the first write
1921 * (but expect upto 5 seconds extra time for a busy server)
1922 */
1923 start = timeval_current();
1924 end = timeval_add(&start, 7 * sec, 0);
1925 while (!timeval_expired(&end)) {
1926 /* do a write */
1927 torture_comment(tctx, "Do a write on the file handle\n");
1928 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1929 if (written != 1) {
1930 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1931 ret = false;
1932 goto done;
1933 }
1934 /* get the times after the write */
1935 GET_INFO_FILE(finfo1);
1936
1937 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
1938 double diff = timeval_elapsed(&start);
1939 if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
1940 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1941 "(1sec == %.2f) (wrong!)\n",
1942 diff, sec);
1943 ret = false;
1944 break;
1945 }
1946
1947 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1948 "(1sec == %.2f) (correct)\n",
1949 diff, sec);
1950 break;
1951 }
1952 smb_msleep(0.5 * msec);
1953 }
1954
1955 GET_INFO_BOTH(finfo1,pinfo1);
1956 COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
1957
1958 /* sure any further write doesn't update the write time */
1959 start = timeval_current();
1960 end = timeval_add(&start, 15 * sec, 0);
1961 while (!timeval_expired(&end)) {
1962 /* do a write */
1963 torture_comment(tctx, "Do a write on the file handle\n");
1964 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1965 if (written != 1) {
1966 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1967 ret = false;
1968 goto done;
1969 }
1970 /* get the times after the write */
1971 GET_INFO_BOTH(finfo2,pinfo2);
1972
1973 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
1974 double diff = timeval_elapsed(&start);
1975 torture_comment(tctx, "Server updated write_time after %.2f seconds "
1976 "(1sec == %.2f) (wrong!)\n",
1977 diff, sec);
1978 ret = false;
1979 break;
1980 }
1981 smb_msleep(1 * msec);
1982 }
1983
1984 GET_INFO_BOTH(finfo2,pinfo2);
1985 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
1986 if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
1987 torture_comment(tctx, "Server did not update write_time (correct)\n");
1988 }
1989
1990 /* sleep */
1991 smb_msleep(5 * msec);
1992
1993 GET_INFO_BOTH(finfo3,pinfo3);
1994 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1995
1996 /*
1997 * the close updates the write time to the time of the close
1998 * and not to the time of the last write!
1999 */
2000 torture_comment(tctx, "Close the file handle\n");
2001 smbcli_close(cli->tree, fnum1);
2002 fnum1 = -1;
2003
2004 GET_INFO_PATH(pinfo4);
2005 COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
2006
2007 if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
2008 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
2009 }
2010
2011 done:
2012 if (fnum1 != -1)
2013 smbcli_close(cli->tree, fnum1);
2014 smbcli_unlink(cli->tree, fname);
2015 smbcli_deltree(cli->tree, BASEDIR);
2016
2017 return ret;
2018 }
2019
2020 /*
2021 * Check that a write after a truncate write doesn't update
2022 * the timestamp, but a truncate write after a write does.
2023 * Also prove that a close after a truncate write updates the
2024 * timestamp to current, not the time of last write.
2025 */
2026
2027 static bool test_delayed_write_update3c(struct torture_context *tctx,
2028 struct smbcli_state *cli,
2029 struct smbcli_state *cli2)
2030 {
2031 union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
2032 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
2033 const char *fname = BASEDIR "\\torture_file3c.txt";
2034 int fnum1 = -1;
2035 bool ret = true;
2036 ssize_t written;
2037 int i;
2038 struct timeval start;
2039 struct timeval end;
2040 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
2041 int normal_delay = 2000000;
2042 double sec = ((double)used_delay) / ((double)normal_delay);
2043 int msec = 1000 * sec;
2044
2045 torture_comment(tctx, "\nRunning test_delayed_write_update3c\n");
2046
2047 if (!torture_setup_dir(cli, BASEDIR)) {
2048 return false;
2049 }
2050
2051 torture_comment(tctx, "Open the file handle\n");
2052 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2053 if (fnum1 == -1) {
2054 ret = false;
2055 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
2056 goto done;
2057 }
2058
2059 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2060 finfo0.basic_info.in.file.fnum = fnum1;
2061 finfo1 = finfo0;
2062 finfo2 = finfo0;
2063 finfo3 = finfo0;
2064 finfo4 = finfo0;
2065 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2066 pinfo0.basic_info.in.file.path = fname;
2067 pinfo1 = pinfo0;
2068 pinfo2 = pinfo0;
2069 pinfo3 = pinfo0;
2070 pinfo4 = pinfo0;
2071 pinfo5 = pinfo0;
2072
2073 /* get the initial times */
2074 GET_INFO_BOTH(finfo0,pinfo0);
2075
2076 /*
2077 * sleep some time, to demonstrate the handling of write times
2078 * doesn't depend on the time since the open
2079 */
2080 smb_msleep(5 * msec);
2081
2082 /* get the initial times */
2083 GET_INFO_BOTH(finfo1,pinfo1);
2084 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
2085
2086 /*
2087 * demonstrate that a truncate write always
2088 * updates the write time immediately
2089 */
2090 for (i=0; i < 3; i++) {
2091 smb_msleep(2 * msec);
2092 /* do a write */
2093 torture_comment(tctx, "Do a truncate SMBwrite [%d] on the file handle\n", i);
2094 written = smbcli_smbwrite(cli->tree, fnum1, "x", 512, 0);
2095 if (written != 0) {
2096 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 0", (int)written);
2097 ret = false;
2098 goto done;
2099 }
2100 /* get the times after the write */
2101 GET_INFO_BOTH(finfo2,pinfo2);
2102 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
2103 finfo1 = finfo2;
2104 }
2105
2106 start = timeval_current();
2107 end = timeval_add(&start, 7 * sec, 0);
2108 while (!timeval_expired(&end)) {
2109 /* do a write */
2110 torture_comment(tctx, "Do a write on the file handle\n");
2111 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2112 if (written != 1) {
2113 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2114 ret = false;
2115 goto done;
2116 }
2117 /* get the times after the write */
2118 GET_INFO_FILE(finfo2);
2119
2120 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
2121 double diff = timeval_elapsed(&start);
2122 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2123 "(1sec == %.2f) (wrong!)\n",
2124 diff, sec);
2125 ret = false;
2126 break;
2127 }
2128 smb_msleep(1 * msec);
2129 }
2130
2131 GET_INFO_BOTH(finfo2,pinfo2);
2132 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
2133 if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
2134 torture_comment(tctx, "Server did not update write_time (correct)\n");
2135 }
2136
2137 /* sleep */
2138 smb_msleep(5 * msec);
2139
2140 /* get the initial times */
2141 GET_INFO_BOTH(finfo1,pinfo1);
2142 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo2);
2143
2144 /*
2145 * demonstrate that a truncate write always
2146 * updates the write time immediately
2147 */
2148 for (i=0; i < 3; i++) {
2149 smb_msleep(2 * msec);
2150 /* do a write */
2151 torture_comment(tctx, "Do a truncate write [%d] on the file handle\n", i);
2152 written = smbcli_smbwrite(cli->tree, fnum1, "x", 512, 0);
2153 if (written != 0) {
2154 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 0", (int)written);
2155 ret = false;
2156 goto done;
2157 }
2158 /* get the times after the write */
2159 GET_INFO_BOTH(finfo2,pinfo2);
2160 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
2161 finfo1 = finfo2;
2162 }
2163
2164 /* sleep */
2165 smb_msleep(5 * msec);
2166
2167 GET_INFO_BOTH(finfo2,pinfo2);
2168 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
2169
2170 /* sure any further write doesn't update the write time */
2171 start = timeval_current();
2172 end = timeval_add(&start, 15 * sec, 0);
2173 while (!timeval_expired(&end)) {
2174 /* do a write */
2175 torture_comment(tctx, "Do a write on the file handle\n");
2176 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2177 if (written != 1) {
2178 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2179 ret = false;
2180 goto done;
2181 }
2182 /* get the times after the write */
2183 GET_INFO_BOTH(finfo2,pinfo2);
2184
2185 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
2186 double diff = timeval_elapsed(&start);
2187 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2188 "(1sec == %.2f) (wrong!)\n",
2189 diff, sec);
2190 ret = false;
2191 break;
2192 }
2193 smb_msleep(1 * msec);
2194 }
2195
2196 GET_INFO_BOTH(finfo2,pinfo2);
2197 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
2198 if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
2199 torture_comment(tctx, "Server did not update write_time (correct)\n");
2200 }
2201
2202 /* sleep */
2203 smb_msleep(5 * msec);
2204
2205 GET_INFO_BOTH(finfo3,pinfo3);
2206 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
2207
2208 /*
2209 * the close updates the write time to the time of the close
2210 * and not to the time of the last write!
2211 */
2212 torture_comment(tctx, "Close the file handle\n");
2213 smbcli_close(cli->tree, fnum1);
2214 fnum1 = -1;
2215
2216 GET_INFO_PATH(pinfo4);
2217 COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
2218
2219 if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
2220 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
2221 }
2222
2223 done:
2224 if (fnum1 != -1)
2225 smbcli_close(cli->tree, fnum1);
2226 smbcli_unlink(cli->tree, fname);
2227 smbcli_deltree(cli->tree, BASEDIR);
2228
2229 return ret;
2230 }
2231
2232 /*
2233 * Show only the first write updates the timestamp, and a close
2234 * after writes updates to current (I think this is the same
2235 * as test 3b. JRA).
2236 */
2237
2238 static bool test_delayed_write_update4(struct torture_context *tctx,
2239 struct smbcli_state *cli,
2240 struct smbcli_state *cli2)
2241 {
2242 union smb_fileinfo finfo0, finfo1, finfo2, finfo3;
2243 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4;
2244 const char *fname = BASEDIR "\\torture_file4.txt";
2245 int fnum1 = -1;
2246 bool ret = true;
2247 ssize_t written;
2248 struct timeval start;
2249 struct timeval end;
2250 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
2251 int normal_delay = 2000000;
2252 double sec = ((double)used_delay) / ((double)normal_delay);
2253 int msec = 1000 * sec;
2254
2255 torture_comment(tctx, "\nRunning test_delayed_write_update4\n");
2256
2257 if (!torture_setup_dir(cli, BASEDIR)) {
2258 return false;
2259 }
2260
2261 torture_comment(tctx, "Open the file handle\n");
2262 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2263 if (fnum1 == -1) {
2264 ret = false;
2265 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
2266 goto done;
2267 }
2268
2269 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2270 finfo0.basic_info.in.file.fnum = fnum1;
2271 finfo1 = finfo0;
2272 finfo2 = finfo0;
2273 finfo3 = finfo0;
2274 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2275 pinfo0.basic_info.in.file.path = fname;
2276 pinfo1 = pinfo0;
2277 pinfo2 = pinfo0;
2278 pinfo3 = pinfo0;
2279 pinfo4 = pinfo0;
2280
2281 /* get the initial times */
2282 GET_INFO_BOTH(finfo0,pinfo0);
2283
2284 /* sleep a bit */
2285 smb_msleep(5 * msec);
2286
2287 /* do a write */
2288 torture_comment(tctx, "Do a write on the file handle\n");
2289 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2290 if (written != 1) {
2291 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2292 ret = false;
2293 goto done;
2294 }
2295
2296 GET_INFO_BOTH(finfo1,pinfo1);
2297 COMPARE_WRITE_TIME_EQUAL(finfo1,finfo0);
2298
2299 /*
2300 * make sure the write time is updated 2 seconds later
2301 * calcuated from the first write
2302 * (but expect upto 3 seconds extra time for a busy server)
2303 */
2304 start = timeval_current();
2305 end = timeval_add(&start, 5 * sec, 0);
2306 while (!timeval_expired(&end)) {
2307 /* get the times after the first write */
2308 GET_INFO_FILE(finfo1);
2309
2310 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
2311 double diff = timeval_elapsed(&start);
2312 if (diff < (TIMEDELAY_SECS * sec * 0.3)) { /* 0.3 to cope with vmware timing */
2313 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2314 "(1sec == %.2f) (wrong!)\n",
2315 diff, sec);
2316 ret = false;
2317 break;
2318 }
2319
2320 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2321 "(1sec == %.2f) (correct)\n",
2322 diff, sec);
2323 break;
2324 }
2325 smb_msleep(0.5 * msec);
2326 }
2327
2328 GET_INFO_BOTH(finfo1,pinfo1);
2329 COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
2330
2331 /* sure any further write doesn't update the write time */
2332 start = timeval_current();
2333 end = timeval_add(&start, 15 * sec, 0);
2334 while (!timeval_expired(&end)) {
2335 /* do a write */
2336 torture_comment(tctx, "Do a write on the file handle\n");
2337 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2338 if (written != 1) {
2339 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2340 ret = false;
2341 goto done;
2342 }
2343 /* get the times after the write */
2344 GET_INFO_BOTH(finfo2,pinfo2);
2345
2346 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
2347 double diff = timeval_elapsed(&start);
2348 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2349 "(1sec == %.2f) (wrong!)\n",
2350 diff, sec);
2351 ret = false;
2352 break;
2353 }
2354 smb_msleep(1 * msec);
2355 }
2356
2357 GET_INFO_BOTH(finfo2,pinfo2);
2358 COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
2359 if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
2360 torture_comment(tctx, "Server did not updatewrite_time (correct)\n");
2361 }
2362
2363 /* sleep */
2364 smb_msleep(5 * msec);
2365
2366 GET_INFO_BOTH(finfo3,pinfo3);
2367 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
2368
2369 /*
2370 * the close updates the write time to the time of the close
2371 * and not to the time of the last write!
2372 */
2373 torture_comment(tctx, "Close the file handle\n");
2374 smbcli_close(cli->tree, fnum1);
2375 fnum1 = -1;
2376
2377 GET_INFO_PATH(pinfo4);
2378 COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
2379
2380 if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
2381 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
2382 }
2383
2384 done:
2385 if (fnum1 != -1)
2386 smbcli_close(cli->tree, fnum1);
2387 smbcli_unlink(cli->tree, fname);
2388 smbcli_deltree(cli->tree, BASEDIR);
2389
2390 return ret;
2391 }
2392
2393 /*
2394 * Show writes and closes have no effect on updating times once a SETWRITETIME is done.
2395 */
2396
2397 static bool test_delayed_write_update5(struct torture_context *tctx,
2398 struct smbcli_state *cli,
2399 struct smbcli_state *cli2)
2400 {
2401 union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
2402 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6;
2403 const char *fname = BASEDIR "\\torture_file5.txt";
2404 int fnum1 = -1;
2405 bool ret = true;
2406 ssize_t written;
2407 struct timeval start;
2408 struct timeval end;
2409 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
2410 int normal_delay = 2000000;
2411 double sec = ((double)used_delay) / ((double)normal_delay);
2412 int msec = 1000 * sec;
2413
2414 torture_comment(tctx, "\nRunning test_delayed_write_update5\n");
2415
2416 if (!torture_setup_dir(cli, BASEDIR)) {
2417 return false;
2418 }
2419
2420 torture_comment(tctx, "Open the file handle\n");
2421 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2422 if (fnum1 == -1) {
2423 ret = false;
2424 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
2425 goto done;
2426 }
2427
2428 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2429 finfo0.basic_info.in.file.fnum = fnum1;
2430 finfo1 = finfo0;
2431 finfo2 = finfo0;
2432 finfo3 = finfo0;
2433 finfo4 = finfo0;
2434 finfo5 = finfo0;
2435 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2436 pinfo0.basic_info.in.file.path = fname;
2437 pinfo1 = pinfo0;
2438 pinfo2 = pinfo0;
2439 pinfo3 = pinfo0;
2440 pinfo4 = pinfo0;
2441 pinfo5 = pinfo0;
2442 pinfo6 = pinfo0;
2443
2444 /* get the initial times */
2445 GET_INFO_BOTH(finfo0,pinfo0);
2446
2447 /* do a write */
2448 torture_comment(tctx, "Do a write on the file handle\n");
2449 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2450 if (written != 1) {
2451 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2452 ret = false;
2453 goto done;
2454 }
2455
2456 GET_INFO_BOTH(finfo1,pinfo1);
2457 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
2458
2459 torture_comment(tctx, "Set write time in the future on the file handle\n");
2460 SET_INFO_FILE(finfo0, time(NULL) + 86400);
2461 GET_INFO_BOTH(finfo2,pinfo2);
2462 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
2463
2464 torture_comment(tctx, "Set write time in the past on the file handle\n");
2465 SET_INFO_FILE(finfo0, time(NULL) - 86400);
2466 GET_INFO_BOTH(finfo2,pinfo2);
2467 COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
2468
2469 /* make sure the 2 second delay from the first write are canceled */
2470 start = timeval_current();
2471 end = timeval_add(&start, 15 * sec, 0);
2472 while (!timeval_expired(&end)) {
2473
2474 /* get the times after the first write */
2475 GET_INFO_BOTH(finfo3,pinfo3);
2476
2477 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
2478 double diff = timeval_elapsed(&start);
2479 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2480 "(1sec == %.2f) (wrong!)\n",
2481 diff, sec);
2482 ret = false;
2483 break;
2484 }
2485 smb_msleep(1 * msec);
2486 }
2487
2488 GET_INFO_BOTH(finfo3,pinfo3);
2489 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
2490 if (finfo3.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
2491 torture_comment(tctx, "Server did not update write_time (correct)\n");
2492 }
2493
2494 /* sure any further write doesn't update the write time */
2495 start = timeval_current();
2496 end = timeval_add(&start, 15 * sec, 0);
2497 while (!timeval_expired(&end)) {
2498 /* do a write */
2499 torture_comment(tctx, "Do a write on the file handle\n");
2500 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2501 if (written != 1) {
2502 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2503 ret = false;
2504 goto done;
2505 }
2506 /* get the times after the write */
2507 GET_INFO_BOTH(finfo4,pinfo4);
2508
2509 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
2510 double diff = timeval_elapsed(&start);
2511 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2512 "(1sec == %.2f) (wrong!)\n",
2513 diff, sec);
2514 ret = false;
2515 break;
2516 }
2517 smb_msleep(1 * msec);
2518 }
2519
2520 GET_INFO_BOTH(finfo4,pinfo4);
2521 COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
2522 if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
2523 torture_comment(tctx, "Server did not update write_time (correct)\n");
2524 }
2525
2526 /* sleep */
2527 smb_msleep(5 * msec);
2528
2529 GET_INFO_BOTH(finfo5,pinfo5);
2530 COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
2531
2532 /*
2533 * the close doesn't update the write time
2534 */
2535 torture_comment(tctx, "Close the file handle\n");
2536 smbcli_close(cli->tree, fnum1);
2537 fnum1 = -1;
2538
2539 GET_INFO_PATH(pinfo6);
2540 COMPARE_WRITE_TIME_EQUAL(pinfo6, pinfo5);
2541
2542 if (pinfo6.basic_info.out.write_time == pinfo5.basic_info.out.write_time) {
2543 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
2544 }
2545
2546 done:
2547 if (fnum1 != -1)
2548 smbcli_close(cli->tree, fnum1);
2549 smbcli_unlink(cli->tree, fname);
2550 smbcli_deltree(cli->tree, BASEDIR);
2551
2552 return ret;
2553 }
2554
2555 /*
2556 * Show truncate writes and closes have no effect on updating times once a SETWRITETIME is done.
2557 */
2558
2559 static bool test_delayed_write_update5b(struct torture_context *tctx,
2560 struct smbcli_state *cli,
2561 struct smbcli_state *cli2)
2562 {
2563 union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
2564 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6;
2565 const char *fname = BASEDIR "\\torture_fileb.txt";
2566 int fnum1 = -1;
2567 bool ret = true;
2568 ssize_t written;
2569 struct timeval start;
2570 struct timeval end;
2571 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
2572 int normal_delay = 2000000;
2573 double sec = ((double)used_delay) / ((double)normal_delay);
2574 int msec = 1000 * sec;
2575
2576 torture_comment(tctx, "\nRunning test_delayed_write_update5b\n");
2577
2578 if (!torture_setup_dir(cli, BASEDIR)) {
2579 return false;
2580 }
2581
2582 torture_comment(tctx, "Open the file handle\n");
2583 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2584 if (fnum1 == -1) {
2585 ret = false;
2586 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
2587 goto done;
2588 }
2589
2590 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2591 finfo0.basic_info.in.file.fnum = fnum1;
2592 finfo1 = finfo0;
2593 finfo2 = finfo0;
2594 finfo3 = finfo0;
2595 finfo4 = finfo0;
2596 finfo5 = finfo0;
2597 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2598 pinfo0.basic_info.in.file.path = fname;
2599 pinfo1 = pinfo0;
2600 pinfo2 = pinfo0;
2601 pinfo3 = pinfo0;
2602 pinfo4 = pinfo0;
2603 pinfo5 = pinfo0;
2604 pinfo6 = pinfo0;
2605
2606 /* get the initial times */
2607 GET_INFO_BOTH(finfo0,pinfo0);
2608
2609 /* do a write */
2610 torture_comment(tctx, "Do a write on the file handle\n");
2611 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2612 if (written != 1) {
2613 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2614 ret = false;
2615 goto done;
2616 }
2617
2618 GET_INFO_BOTH(finfo1,pinfo1);
2619 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
2620
2621 torture_comment(tctx, "Set write time in the future on the file handle\n");
2622 SET_INFO_FILE(finfo0, time(NULL) + 86400);
2623 GET_INFO_BOTH(finfo2,pinfo2);
2624 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
2625
2626 torture_comment(tctx, "Set write time in the past on the file handle\n");
2627 SET_INFO_FILE(finfo0, time(NULL) - 86400);
2628 GET_INFO_BOTH(finfo2,pinfo2);
2629 COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
2630
2631 /* make sure the 2 second delay from the first write are canceled */
2632 start = timeval_current();
2633 end = timeval_add(&start, 15 * sec, 0);
2634 while (!timeval_expired(&end)) {
2635
2636 /* get the times after the first write */
2637 GET_INFO_BOTH(finfo3,pinfo3);
2638
2639 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
2640 double diff = timeval_elapsed(&start);
2641 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2642 "(1sec == %.2f) (wrong!)\n",
2643 diff, sec);
2644 ret = false;
2645 break;
2646 }
2647 smb_msleep(1 * msec);
2648 }
2649
2650 GET_INFO_BOTH(finfo3,pinfo3);
2651 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
2652 if (finfo3.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
2653 torture_comment(tctx, "Server did not update write_time (correct)\n");
2654 }
2655
2656 /* Do any further write (truncates) update the write time ? */
2657 start = timeval_current();
2658 end = timeval_add(&start, 15 * sec, 0);
2659 while (!timeval_expired(&end)) {
2660 /* do a write */
2661 torture_comment(tctx, "Do a truncate write on the file handle\n");
2662 written = smbcli_smbwrite(cli->tree, fnum1, "x", 1024, 0);
2663 if (written != 0) {
2664 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2665 ret = false;
2666 goto done;
2667 }
2668 /* get the times after the write */
2669 GET_INFO_BOTH(finfo4,pinfo4);
2670
2671 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
2672 double diff = timeval_elapsed(&start);
2673 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2674 "(1sec == %.2f) (wrong!)\n",
2675 diff, sec);
2676 ret = false;
2677 break;
2678 }
2679 smb_msleep(1 * msec);
2680 }
2681
2682 GET_INFO_BOTH(finfo4,pinfo4);
2683 COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
2684 if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
2685 torture_comment(tctx, "Server did not update write_time (correct)\n");
2686 }
2687
2688 /* sleep */
2689 smb_msleep(5 * msec);
2690
2691 GET_INFO_BOTH(finfo5,pinfo5);
2692 COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
2693
2694 /*
2695 * the close doesn't update the write time
2696 */
2697 torture_comment(tctx, "Close the file handle\n");
2698 smbcli_close(cli->tree, fnum1);
2699 fnum1 = -1;
2700
2701 GET_INFO_PATH(pinfo6);
2702 COMPARE_WRITE_TIME_EQUAL(pinfo6, pinfo5);
2703
2704 if (pinfo6.basic_info.out.write_time == pinfo5.basic_info.out.write_time) {
2705 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
2706 }
2707
2708 done:
2709 if (fnum1 != -1)
2710 smbcli_close(cli->tree, fnum1);
2711 smbcli_unlink(cli->tree, fname);
2712 smbcli_deltree(cli->tree, BASEDIR);
2713
2714 return ret;
2715 }
2716
2717 /*
2718 * Open 2 handles on a file. Write one one and then set the
2719 * WRITE TIME explicitly on the other. Ensure the write time
2720 * update is cancelled. Ensure the write time is updated to
2721 * the close time when the non-explicit set handle is closed.
2722 *
2723 */
2724
2725 static bool test_delayed_write_update6(struct torture_context *tctx,
2726 struct smbcli_state *cli,
2727 struct smbcli_state *cli2)
2728 {
2729 union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
2730 union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6, pinfo7;
2731 const char *fname = BASEDIR "\\torture_file6.txt";
2732 int fnum1 = -1;
2733 int fnum2 = -1;
2734 bool ret = true;
2735 ssize_t written;
2736 struct timeval start;
2737 struct timeval end;
2738 int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
2739 int normal_delay = 2000000;
2740 double sec = ((double)used_delay) / ((double)normal_delay);
2741 int msec = 1000 * sec;
2742 bool first = true;
2743
2744 torture_comment(tctx, "\nRunning test_delayed_write_update6\n");
2745
2746 if (!torture_setup_dir(cli, BASEDIR)) {
2747 return false;
2748 }
2749 again:
2750 torture_comment(tctx, "Open the file handle\n");
2751 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2752 if (fnum1 == -1) {
2753 ret = false;
2754 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
2755 goto done;
2756 }
2757
2758 if (fnum2 == -1) {
2759 torture_comment(tctx, "Open the 2nd file handle on 2nd connection\n");
2760 fnum2 = smbcli_open(cli2->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
2761 if (fnum2 == -1) {
2762 ret = false;
2763 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
2764 goto done;
2765 }
2766 }
2767
2768 finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2769 finfo0.basic_info.in.file.fnum = fnum1;
2770 finfo1 = finfo0;
2771 finfo2 = finfo0;
2772 finfo3 = finfo0;
2773 finfo4 = finfo0;
2774 finfo5 = finfo0;
2775 pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
2776 pinfo0.basic_info.in.file.path = fname;
2777 pinfo1 = pinfo0;
2778 pinfo2 = pinfo0;
2779 pinfo3 = pinfo0;
2780 pinfo4 = pinfo0;
2781 pinfo5 = pinfo0;
2782 pinfo6 = pinfo0;
2783 pinfo7 = pinfo0;
2784
2785 /* get the initial times */
2786 GET_INFO_BOTH(finfo0,pinfo0);
2787
2788 /* do a write */
2789 torture_comment(tctx, "Do a write on the file handle\n");
2790 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2791 if (written != 1) {
2792 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2793 ret = false;
2794 goto done;
2795 }
2796
2797 GET_INFO_BOTH(finfo1,pinfo1);
2798 COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
2799
2800 torture_comment(tctx, "Set write time in the future on the 2nd file handle\n");
2801 SET_INFO_FILE_EX(finfo0, time(NULL) + 86400, cli2->tree, fnum2);
2802 GET_INFO_BOTH(finfo2,pinfo2);
2803 COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
2804
2805 torture_comment(tctx, "Set write time in the past on the 2nd file handle\n");
2806 SET_INFO_FILE_EX(finfo0, time(NULL) - 86400, cli2->tree, fnum2);
2807 GET_INFO_BOTH(finfo2,pinfo2);
2808 COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
2809
2810 /* make sure the 2 second delay from the first write are canceled */
2811 start = timeval_current();
2812 end = timeval_add(&start, 10 * sec, 0);
2813 while (!timeval_expired(&end)) {
2814
2815 /* get the times after the first write */
2816 GET_INFO_BOTH(finfo3,pinfo3);
2817
2818 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
2819 double diff = timeval_elapsed(&start);
2820 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2821 "(1sec == %.2f) (wrong!)\n",
2822 diff, sec);
2823 ret = false;
2824 break;
2825 }
2826 smb_msleep(1 * msec);
2827 }
2828
2829 GET_INFO_BOTH(finfo3,pinfo3);
2830 COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
2831 if (finfo3.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
2832 torture_comment(tctx, "Server did not update write_time (correct)\n");
2833 }
2834
2835 /* sure any further write doesn't update the write time */
2836 start = timeval_current();
2837 end = timeval_add(&start, 10 * sec, 0);
2838 while (!timeval_expired(&end)) {
2839 /* do a write */
2840 torture_comment(tctx, "Do a write on the file handle\n");
2841 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
2842 if (written != 1) {
2843 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2844 ret = false;
2845 goto done;
2846 }
2847 /* get the times after the write */
2848 GET_INFO_BOTH(finfo4,pinfo4);
2849
2850 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
2851 double diff = timeval_elapsed(&start);
2852 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2853 "(1sec == %.2f) (wrong!)\n",
2854 diff, sec);
2855 ret = false;
2856 break;
2857 }
2858 smb_msleep(1 * msec);
2859 }
2860
2861 GET_INFO_BOTH(finfo4,pinfo4);
2862 COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
2863 if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
2864 torture_comment(tctx, "Server did not update write_time (correct)\n");
2865 }
2866
2867 /* sleep */
2868 smb_msleep(5 * msec);
2869
2870 GET_INFO_BOTH(finfo5,pinfo5);
2871 COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
2872
2873 /*
2874 * the close updates the write time to the time of the close
2875 * as the write time was set on the 2nd handle
2876 */
2877 torture_comment(tctx, "Close the file handle\n");
2878 smbcli_close(cli->tree, fnum1);
2879 fnum1 = -1;
2880
2881 GET_INFO_PATH(pinfo6);
2882 COMPARE_WRITE_TIME_GREATER(pinfo6, pinfo5);
2883
2884 if (pinfo6.basic_info.out.write_time > pinfo5.basic_info.out.write_time) {
2885 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
2886 }
2887
2888 /* See what the second write handle thinks the time is ? */
2889 finfo5.basic_info.in.file.fnum = fnum2;
2890 GET_INFO_FILE2(finfo5);
2891 COMPARE_WRITE_TIME_EQUAL(finfo5, pinfo6);
2892
2893 /* See if we have lost the sticky write time on handle2 */
2894 smb_msleep(3 * msec);
2895 torture_comment(tctx, "Have we lost the sticky write time ?\n");
2896
2897 /* Make sure any further normal write doesn't update the write time */
2898 start = timeval_current();
2899 end = timeval_add(&start, 10 * sec, 0);
2900 while (!timeval_expired(&end)) {
2901 /* do a write */
2902 torture_comment(tctx, "Do a write on the second file handle\n");
2903 written = smbcli_write(cli2->tree, fnum2, 0, "x", 0, 1);
2904 if (written != 1) {
2905 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2906 ret = false;
2907 goto done;
2908 }
2909 /* get the times after the write */
2910 GET_INFO_FILE2(finfo5);
2911 GET_INFO_PATH(pinfo6);
2912
2913 if (finfo5.basic_info.out.write_time > pinfo6.basic_info.out.write_time) {
2914 double diff = timeval_elapsed(&start);
2915 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2916 "(1sec == %.2f) (wrong!)\n",
2917 diff, sec);
2918 ret = false;
2919 break;
2920 }
2921 smb_msleep(1 * msec);
2922 }
2923
2924 /* What about a truncate write ? */
2925 start = timeval_current();
2926 end = timeval_add(&start, 10 * sec, 0);
2927 while (!timeval_expired(&end)) {
2928 /* do a write */
2929 torture_comment(tctx, "Do a truncate write on the second file handle\n");
2930 written = smbcli_write(cli2->tree, fnum2, 0, "x", 0, 0);
2931 if (written != 0) {
2932 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
2933 ret = false;
2934 goto done;
2935 }
2936 /* get the times after the write */
2937 GET_INFO_FILE2(finfo5);
2938 GET_INFO_PATH(pinfo6);
2939
2940 if (finfo5.basic_info.out.write_time > pinfo6.basic_info.out.write_time) {
2941 double diff = timeval_elapsed(&start);
2942 torture_comment(tctx, "Server updated write_time after %.2f seconds "
2943 "(1sec == %.2f) (wrong!)\n",
2944 diff, sec);
2945 ret = false;
2946 break;
2947 }
2948 smb_msleep(1 * msec);
2949 }
2950
2951
2952 /* keep the 2nd handle open and rerun tests */
2953 if (first) {
2954 first = false;
2955 goto again;
2956 }
2957
2958 /*
2959 * closing the 2nd handle will cause no write time update
2960 * as the write time was explicit set on this handle
2961 */
2962 torture_comment(tctx, "Close the 2nd file handle\n");
2963 smbcli_close(cli2->tree, fnum2);
2964 fnum2 = -1;
2965
2966 GET_INFO_PATH(pinfo7);
2967 COMPARE_WRITE_TIME_EQUAL(pinfo7, pinfo6);
2968
2969 if (pinfo7.basic_info.out.write_time == pinfo6.basic_info.out.write_time) {
2970 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
2971 }
2972
2973 done:
2974 if (fnum1 != -1)
2975 smbcli_close(cli->tree, fnum1);
2976 if (fnum2 != -1)
2977 smbcli_close(cli2->tree, fnum2);
2978 smbcli_unlink(cli->tree, fname);
2979 smbcli_deltree(cli->tree, BASEDIR);
2980
2981 return ret;
2982 }
2983
2984 static bool test_delayed_write_update7(struct torture_context *tctx, struct smbcli_state *cli)
2985 {
2986 union smb_open open_parms;
2987 union smb_fileinfo finfo1, finfo2, finfo3;
2988 const char *fname = BASEDIR "\\torture_file7.txt";
2989 NTSTATUS status;
2990 int fnum1 = -1;
2991 bool ret = true;
2992 TALLOC_CTX *mem_ctx;
2993
2994 torture_comment(tctx, "\nRunning test_delayed_write_update7 (timestamp resolution test)\n");
2995
2996 mem_ctx = talloc_init("test_delayed_write_update7");
2997 if (!mem_ctx) return false;
2998
2999 ZERO_STRUCT(finfo1);
3000 ZERO_STRUCT(finfo2);
3001 ZERO_STRUCT(finfo3);
3002 ZERO_STRUCT(open_parms);
3003
3004 if (!torture_setup_dir(cli, BASEDIR)) {
3005 return false;
3006 }
3007
3008 /* Create the file. */
3009 fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
3010 if (fnum1 == -1) {
3011 torture_result(tctx, TORTURE_FAIL, "Failed to open %s", fname);
3012 return false;
3013 }
3014
3015 finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
3016 finfo1.basic_info.in.file.fnum = fnum1;
3017 finfo2 = finfo1;
3018 finfo3 = finfo1;
3019
3020 /* Get the initial timestamps. */
3021 status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
3022
3023 torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
3024
3025 /* Set the pending write time to a value with ns. */
3026 SET_INFO_FILE_NS(finfo, time(NULL) + 86400, 103, cli->tree, fnum1);
3027
3028 /* Get the current pending write time by fnum. */
3029 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
3030
3031 torture_assert_ntstatus_ok(tctx, status, "fileinfo failed");
3032
3033 /* Ensure the time is actually different. */
3034 if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
3035 torture_result(tctx, TORTURE_FAIL,
3036 "setfileinfo time matches original fileinfo time");
3037 ret = false;
3038 }
3039
3040 /* Get the current pending write time by path. */
3041 finfo3.basic_info.in.file.path = fname;
3042 status = smb_raw_pathinfo(cli->tree, tctx, &finfo3);
3043
3044 if (finfo2.basic_info.out.write_time != finfo3.basic_info.out.write_time) {
3045 torture_result(tctx, TORTURE_FAIL,
3046 "qpathinfo time doens't match fileinfo time");
3047 ret = false;
3048 }
3049
3050 /* Now close the file. Re-open and check that the write
3051 time is identical to the one we wrote. */
3052
3053 smbcli_close(cli->tree, fnum1);
3054
3055 open_parms.ntcreatex.level = RAW_OPEN_NTCREATEX;
3056 open_parms.ntcreatex.in.flags = 0;
3057 open_parms.ntcreatex.in.access_mask = SEC_GENERIC_READ;
3058 open_parms.ntcreatex.in.file_attr = 0;
3059 open_parms.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_DELETE|
3060 NTCREATEX_SHARE_ACCESS_READ|
3061 NTCREATEX_SHARE_ACCESS_WRITE;
3062 open_parms.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
3063 open_parms.ntcreatex.in.create_options = 0;
3064 open_parms.ntcreatex.in.fname = fname;
3065
3066 status = smb_raw_open(cli->tree, mem_ctx, &open_parms);
3067 talloc_free(mem_ctx);
3068
3069 if (!NT_STATUS_IS_OK(status)) {
3070 torture_result(tctx, TORTURE_FAIL,
3071 "setfileinfo time matches original fileinfo time");
3072 ret = false;
3073 }
3074
3075 fnum1 = open_parms.ntcreatex.out.file.fnum;
3076
3077 /* Check the returned time matches. */
3078 if (open_parms.ntcreatex.out.write_time != finfo2.basic_info.out.write_time) {
3079 torture_result(tctx, TORTURE_FAIL,
3080 "final open time does not match set time");
3081 ret = false;
3082 }
3083
3084 done:
3085
3086 smbcli_close(cli->tree, fnum1);
3087
3088 smbcli_unlink(cli->tree, fname);
3089 smbcli_deltree(cli->tree, BASEDIR);
3090 return ret;
3091 }
3092
3093 /*
3094 testing of delayed update of write_time
3095 */
3096 struct torture_suite *torture_delay_write(void)
3097 {
3098 struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "delaywrite");
3099
3100 torture_suite_add_2smb_test(suite, "finfo update on close", test_finfo_after_write);
3101 torture_suite_add_1smb_test(suite, "delayed update of write time", test_delayed_write_update);
3102 torture_suite_add_1smb_test(suite, "update of write time and SMBwrite truncate", test_delayed_write_update1);
3103 torture_suite_add_1smb_test(suite, "update of write time and SMBwrite truncate expand", test_delayed_write_update1a);
3104 torture_suite_add_1smb_test(suite, "update of write time using SET_END_OF_FILE", test_delayed_write_update1b);
3105 torture_suite_add_1smb_test(suite, "update of write time using SET_ALLOCATION_SIZE", test_delayed_write_update1c);
3106 torture_suite_add_2smb_test(suite, "delayed update of write time using 2 connections", test_delayed_write_update2);
3107 torture_suite_add_2smb_test(suite, "delayed update of write time 3", test_delayed_write_update3);
3108 torture_suite_add_2smb_test(suite, "delayed update of write time 3a", test_delayed_write_update3a);
3109 torture_suite_add_2smb_test(suite, "delayed update of write time 3b", test_delayed_write_update3b);
3110 torture_suite_add_2smb_test(suite, "delayed update of write time 3c", test_delayed_write_update3c);
3111 torture_suite_add_2smb_test(suite, "delayed update of write time 4", test_delayed_write_update4);
3112 torture_suite_add_2smb_test(suite, "delayed update of write time 5", test_delayed_write_update5);
3113 torture_suite_add_2smb_test(suite, "delayed update of write time 5b", test_delayed_write_update5b);
3114 torture_suite_add_2smb_test(suite, "delayed update of write time 6", test_delayed_write_update6);
3115 torture_suite_add_1smb_test(suite, "timestamp resolution test", test_delayed_write_update7);
3116 torture_suite_add_1smb_test(suite, "timestamp resolution test", test_delayed_write_update7);
3117
3118 return suite;
3119 }
reg import