source: vendor/current/source4/torture/basic/delaywrite.c@ 740

Last change on this file since 740 was 740, checked in by Silvan Scherrer, 12 years ago

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