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