c03e89d36eb72738ea14ed639f597bc1b5ecde6e
[kai/samba.git] / source / torture / basic / delaywrite.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    test suite for delayed write update 
5
6    Copyright (C) Volker Lendecke 2004
7    Copyright (C) Andrew Tridgell 2004
8    Copyright (C) Jeremy Allison 2004
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
22 */
23
24 #include "includes.h"
25 #include "torture/torture.h"
26 #include "libcli/raw/libcliraw.h"
27 #include "libcli/raw/raw_proto.h"
28 #include "system/time.h"
29 #include "system/filesys.h"
30 #include "libcli/libcli.h"
31 #include "torture/util.h"
32
33 #define BASEDIR "\\delaywrite"
34
35 static bool test_delayed_write_update(struct torture_context *tctx, struct smbcli_state *cli)
36 {
37         union smb_fileinfo finfo1, finfo2;
38         const char *fname = BASEDIR "\\torture_file.txt";
39         NTSTATUS status;
40         int fnum1 = -1;
41         bool ret = true;
42         ssize_t written;
43         struct timeval start;
44         struct timeval end;
45         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
46         int normal_delay = 2000000;
47         double sec = ((double)used_delay) / ((double)normal_delay);
48         int msec = 1000 * sec;
49
50         if (!torture_setup_dir(cli, BASEDIR)) {
51                 return false;
52         }
53
54         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
55         if (fnum1 == -1) {
56                 torture_comment(tctx, "Failed to open %s\n", fname);
57                 return false;
58         }
59
60         finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
61         finfo1.basic_info.in.file.fnum = fnum1;
62         finfo2 = finfo1;
63
64         status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
65
66         if (!NT_STATUS_IS_OK(status)) {
67                 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
68                 return false;
69         }
70         
71         torture_comment(tctx, "Initial write time %s\n", 
72                nt_time_string(tctx, finfo1.basic_info.out.write_time));
73
74         /* 3 second delay to ensure we get past any 2 second time
75            granularity (older systems may have that) */
76         msleep(3 * msec);
77
78         written =  smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
79
80         if (written != 1) {
81                 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n", 
82                        (int)written, __location__);
83                 return false;
84         }
85
86         start = timeval_current();
87         end = timeval_add(&start, (120*sec), 0);
88         while (!timeval_expired(&end)) {
89                 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
90
91                 if (!NT_STATUS_IS_OK(status)) {
92                         DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
93                         ret = false;
94                         break;
95                 }
96                 torture_comment(tctx, "write time %s\n", 
97                        nt_time_string(tctx, finfo2.basic_info.out.write_time));
98                 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
99                         double diff = timeval_elapsed(&start);
100                         if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
101                                 torture_comment(tctx, "Server updated write_time after %.2f seconds"
102                                                 "(1 sec == %.2f)(wrong!)\n",
103                                                 diff, sec);
104                                 ret = false;
105                                 break;
106                         }
107
108                         torture_comment(tctx, "Server updated write_time after %.2f seconds"
109                                         "(1 sec == %.2f)(correct)\n",
110                                         diff, sec);
111                         break;
112                 }
113                 fflush(stdout);
114                 msleep(1 * msec);
115         }
116         
117         if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
118                 torture_comment(tctx, "Server did not update write time (wrong!)\n");
119                 ret = false;
120         }
121
122
123         if (fnum1 != -1)
124                 smbcli_close(cli->tree, fnum1);
125         smbcli_unlink(cli->tree, fname);
126         smbcli_deltree(cli->tree, BASEDIR);
127
128         return ret;
129 }
130
131 /* 
132  * Do as above, but using 2 connections.
133  */
134
135 static bool test_delayed_write_update2(struct torture_context *tctx, struct smbcli_state *cli, 
136                                                                            struct smbcli_state *cli2)
137 {
138         union smb_fileinfo finfo1, finfo2;
139         const char *fname = BASEDIR "\\torture_file.txt";
140         NTSTATUS status;
141         int fnum1 = -1;
142         int fnum2 = -1;
143         bool ret = true;
144         ssize_t written;
145         struct timeval start;
146         struct timeval end;
147         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
148         int normal_delay = 2000000;
149         double sec = ((double)used_delay) / ((double)normal_delay);
150         int msec = 1000 * sec;
151         union smb_flush flsh;
152
153         if (!torture_setup_dir(cli, BASEDIR)) {
154                 return false;
155         }
156
157         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
158         if (fnum1 == -1) {
159                 torture_comment(tctx, "Failed to open %s\n", fname);
160                 return false;
161         }
162
163         finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
164         finfo1.basic_info.in.file.fnum = fnum1;
165         finfo2 = finfo1;
166
167         status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
168
169         if (!NT_STATUS_IS_OK(status)) {
170                 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
171                 return false;
172         }
173         
174         torture_comment(tctx, "Initial write time %s\n", 
175                nt_time_string(tctx, finfo1.basic_info.out.write_time));
176
177         /* 3 second delay to ensure we get past any 2 second time
178            granularity (older systems may have that) */
179         msleep(3 * msec);
180
181         {
182                 /* Try using setfileinfo instead of write to update write time. */
183                 union smb_setfileinfo sfinfo;
184                 time_t t_set = time(NULL);
185                 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO;
186                 sfinfo.basic_info.in.file.fnum = fnum1;
187                 sfinfo.basic_info.in.create_time = finfo1.basic_info.out.create_time;
188                 sfinfo.basic_info.in.access_time = finfo1.basic_info.out.access_time;
189
190                 /* I tried this with both + and - ve to see if it makes a different.
191                    It doesn't - once the filetime is set via setfileinfo it stays that way. */
192 #if 1
193                 unix_to_nt_time(&sfinfo.basic_info.in.write_time, t_set - 30000);
194 #else
195                 unix_to_nt_time(&sfinfo.basic_info.in.write_time, t_set + 30000);
196 #endif
197                 sfinfo.basic_info.in.change_time = finfo1.basic_info.out.change_time;
198                 sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib;
199
200                 status = smb_raw_setfileinfo(cli->tree, &sfinfo);
201
202                 if (!NT_STATUS_IS_OK(status)) {
203                         DEBUG(0, ("sfileinfo failed: %s\n", nt_errstr(status)));
204                         return false;
205                 }
206         }
207
208         finfo2.basic_info.in.file.path = fname;
209         
210         status = smb_raw_pathinfo(cli2->tree, tctx, &finfo2);
211
212         if (!NT_STATUS_IS_OK(status)) {
213                 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
214                 return false;
215         }
216         torture_comment(tctx, "write time %s\n",
217                nt_time_string(tctx, finfo2.basic_info.out.write_time));
218
219         if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
220                 torture_comment(tctx, "Server updated write_time (correct)\n");
221         } else {
222                 torture_comment(tctx, "Server did not update write time (wrong!)\n");
223                 ret = false;
224         }
225
226         /* Now try a write to see if the write time gets reset. */
227
228         finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
229         finfo1.basic_info.in.file.fnum = fnum1;
230         finfo2 = finfo1;
231
232         status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
233
234         if (!NT_STATUS_IS_OK(status)) {
235                 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
236                 return false;
237         }
238         
239         torture_comment(tctx, "Modified write time %s\n", 
240                nt_time_string(tctx, finfo1.basic_info.out.write_time));
241
242
243         torture_comment(tctx, "Doing a 10 byte write to extend the file and see if this changes the last write time.\n");
244
245         written =  smbcli_write(cli->tree, fnum1, 0, "0123456789", 1, 10);
246
247         if (written != 10) {
248                 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n", 
249                        (int)written, __location__);
250                 return false;
251         }
252
253         /* Just to prove to tridge that the an smbflush has no effect on
254            the write time :-). The setfileinfo IS STICKY. JRA. */
255
256         torture_comment(tctx, "Doing flush after write\n");
257
258         flsh.flush.level        = RAW_FLUSH_FLUSH;
259         flsh.flush.in.file.fnum = fnum1;
260         status = smb_raw_flush(cli->tree, &flsh);
261         if (!NT_STATUS_IS_OK(status)) {
262                 DEBUG(0, ("smbflush failed: %s\n", nt_errstr(status)));
263                 return false;
264         }
265
266         /* Once the time was set using setfileinfo then it stays set - writes
267            don't have any effect. But make sure. */
268         start = timeval_current();
269         end = timeval_add(&start, (15*sec), 0);
270         while (!timeval_expired(&end)) {
271                 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
272
273                 if (!NT_STATUS_IS_OK(status)) {
274                         DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
275                         ret = false;
276                         break;
277                 }
278                 torture_comment(tctx, "write time %s\n", 
279                        nt_time_string(tctx, finfo2.basic_info.out.write_time));
280                 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
281                         double diff = timeval_elapsed(&start);
282                         torture_comment(tctx, "Server updated write_time after %.2f seconds"
283                                         "(1sec == %.2f) (wrong!)\n",
284                                         diff, sec);
285                         ret = false;
286                         break;
287                 }
288                 fflush(stdout);
289                 msleep(1 * msec);
290         }
291         
292         if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
293                 torture_comment(tctx, "Server did not update write time (correct)\n");
294         }
295
296         fnum2 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
297         if (fnum2 == -1) {
298                 torture_comment(tctx, "Failed to open %s\n", fname);
299                 return false;
300         }
301         
302         torture_comment(tctx, "Doing a 10 byte write to extend the file via second fd and see if this changes the last write time.\n");
303
304         written =  smbcli_write(cli->tree, fnum2, 0, "0123456789", 11, 10);
305
306         if (written != 10) {
307                 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n", 
308                        (int)written, __location__);
309                 return false;
310         }
311
312         status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
313
314         if (!NT_STATUS_IS_OK(status)) {
315                 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
316                 return false;
317         }
318         torture_comment(tctx, "write time %s\n", 
319                nt_time_string(tctx, finfo2.basic_info.out.write_time));
320         if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
321                 torture_comment(tctx, "Server updated write_time (wrong!)\n");
322                 ret = false;
323         }
324
325         torture_comment(tctx, "Closing the first fd to see if write time updated.\n");
326         smbcli_close(cli->tree, fnum1);
327         fnum1 = -1;
328
329         torture_comment(tctx, "Doing a 10 byte write to extend the file via second fd and see if this changes the last write time.\n");
330
331         written =  smbcli_write(cli->tree, fnum2, 0, "0123456789", 21, 10);
332
333         if (written != 10) {
334                 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n", 
335                        (int)written, __location__);
336                 return false;
337         }
338
339         finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
340         finfo1.basic_info.in.file.fnum = fnum2;
341         finfo2 = finfo1;
342         status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
343
344         if (!NT_STATUS_IS_OK(status)) {
345                 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
346                 return false;
347         }
348         torture_comment(tctx, "write time %s\n", 
349                nt_time_string(tctx, finfo2.basic_info.out.write_time));
350         if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
351                 torture_comment(tctx, "Server updated write_time (wrong!)\n");
352                 ret = false;
353         }
354
355         /* Once the time was set using setfileinfo then it stays set - writes
356            don't have any effect. But make sure. */
357         start = timeval_current();
358         end = timeval_add(&start, (15*sec), 0);
359         while (!timeval_expired(&end)) {
360                 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
361
362                 if (!NT_STATUS_IS_OK(status)) {
363                         DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
364                         ret = false;
365                         break;
366                 }
367                 torture_comment(tctx, "write time %s\n", 
368                        nt_time_string(tctx, finfo2.basic_info.out.write_time));
369                 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
370                         double diff = timeval_elapsed(&start);
371                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
372                                         "(1sec == %.2f) (wrong!)\n",
373                                         diff, sec);
374                         ret = false;
375                         break;
376                 }
377                 fflush(stdout);
378                 msleep(1 * msec);
379         }
380         
381         if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
382                 torture_comment(tctx, "Server did not update write time (correct)\n");
383         }
384
385         torture_comment(tctx, "Closing second fd to see if write time updated.\n");
386
387         smbcli_close(cli->tree, fnum2);
388         fnum2 = -1;
389
390         fnum1 = smbcli_open(cli->tree, fname, O_RDWR, DENY_NONE);
391         if (fnum1 == -1) {
392                 torture_comment(tctx, "Failed to open %s\n", fname);
393                 return false;
394         }
395
396         finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
397         finfo1.basic_info.in.file.fnum = fnum1;
398         finfo2 = finfo1;
399
400         status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
401
402         if (!NT_STATUS_IS_OK(status)) {
403                 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
404                 return false;
405         }
406         
407         torture_comment(tctx, "Second open initial write time %s\n", 
408                nt_time_string(tctx, finfo1.basic_info.out.write_time));
409
410         msleep(10 * msec);
411         torture_comment(tctx, "Doing a 10 byte write to extend the file to see if this changes the last write time.\n");
412
413         written =  smbcli_write(cli->tree, fnum1, 0, "0123456789", 31, 10);
414
415         if (written != 10) {
416                 torture_comment(tctx, "write failed - wrote %d bytes (%s)\n", 
417                        (int)written, __location__);
418                 return false;
419         }
420
421         finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
422         finfo1.basic_info.in.file.fnum = fnum1;
423         finfo2 = finfo1;
424         status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
425
426         if (!NT_STATUS_IS_OK(status)) {
427                 DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
428                 return false;
429         }
430         torture_comment(tctx, "write time %s\n", 
431                nt_time_string(tctx, finfo2.basic_info.out.write_time));
432         if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
433                 torture_comment(tctx, "Server updated write_time (wrong!)\n");
434                 ret = false;
435         }
436
437         /* Now the write time should be updated again */
438         start = timeval_current();
439         end = timeval_add(&start, (15*sec), 0);
440         while (!timeval_expired(&end)) {
441                 status = smb_raw_fileinfo(cli->tree, tctx, &finfo2);
442
443                 if (!NT_STATUS_IS_OK(status)) {
444                         DEBUG(0, ("fileinfo failed: %s\n", nt_errstr(status)));
445                         ret = false;
446                         break;
447                 }
448                 torture_comment(tctx, "write time %s\n", 
449                        nt_time_string(tctx, finfo2.basic_info.out.write_time));
450                 if (finfo1.basic_info.out.write_time != finfo2.basic_info.out.write_time) {
451                         double diff = timeval_elapsed(&start);
452                         if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
453                                 torture_comment(tctx, "Server updated write_time after %.2f seconds"
454                                                 "(1sec == %.2f) (wrong!)\n",
455                                                 diff, sec);
456                                 ret = false;
457                                 break;
458                         }
459
460                         torture_comment(tctx, "Server updated write_time after %.2f seconds"
461                                         "(1sec == %.2f) (correct)\n",
462                                         diff, sec);
463                         break;
464                 }
465                 fflush(stdout);
466                 msleep(1*msec);
467         }
468         
469         if (finfo1.basic_info.out.write_time == finfo2.basic_info.out.write_time) {
470                 torture_comment(tctx, "Server did not update write time (wrong!)\n");
471                 ret = false;
472         }
473
474
475         /* One more test to do. We should read the filetime via findfirst on the
476            second connection to ensure it's the same. This is very easy for a Windows
477            server but a bastard to get right on a POSIX server. JRA. */
478
479         if (fnum1 != -1)
480                 smbcli_close(cli->tree, fnum1);
481         smbcli_unlink(cli->tree, fname);
482         smbcli_deltree(cli->tree, BASEDIR);
483
484         return ret;
485 }
486
487
488 /* Windows does obviously not update the stat info during a write call. I
489  * *think* this is the problem causing a spurious Excel 2003 on XP error
490  * message when saving a file. Excel does a setfileinfo, writes, and then does
491  * a getpath(!)info. Or so... For Samba sometimes it displays an error message
492  * that the file might have been changed in between. What i've been able to
493  * trace down is that this happens if the getpathinfo after the write shows a
494  * different last write time than the setfileinfo showed. This is really
495  * nasty....
496  */
497
498 static bool test_finfo_after_write(struct torture_context *tctx, struct smbcli_state *cli, 
499                                                                    struct smbcli_state *cli2)
500 {
501         union smb_fileinfo finfo1, finfo2;
502         const char *fname = BASEDIR "\\torture_file.txt";
503         NTSTATUS status;
504         int fnum1 = -1;
505         int fnum2;
506         bool ret = true;
507         ssize_t written;
508         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
509         int normal_delay = 2000000;
510         double sec = ((double)used_delay) / ((double)normal_delay);
511         int msec = 1000 * sec;
512
513         if (!torture_setup_dir(cli, BASEDIR)) {
514                 return false;
515         }
516
517         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
518         if (fnum1 == -1) {
519                 ret = false;
520                 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
521                 goto done;
522         }
523
524         finfo1.basic_info.level = RAW_FILEINFO_BASIC_INFO;
525         finfo1.basic_info.in.file.fnum = fnum1;
526
527         status = smb_raw_fileinfo(cli->tree, tctx, &finfo1);
528
529         if (!NT_STATUS_IS_OK(status)) {
530                 ret = false;
531                 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", nt_errstr(status));
532                 goto done;
533         }
534
535         msleep(1 * msec);
536
537         written =  smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
538
539         if (written != 1) {
540                 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
541                 ret = false;
542                 goto done;
543         }
544
545         fnum2 = smbcli_open(cli2->tree, fname, O_RDWR, DENY_NONE);
546         if (fnum2 == -1) {
547                 torture_result(tctx, TORTURE_FAIL, __location__": failed to open 2nd time - %s", 
548                        smbcli_errstr(cli2->tree));
549                 ret = false;
550                 goto done;
551         }
552         
553         written =  smbcli_write(cli2->tree, fnum2, 0, "x", 0, 1);
554         
555         if (written != 1) {
556                 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", 
557                        (int)written);
558                 ret = false;
559                 goto done;
560         }
561         
562         finfo2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
563         finfo2.basic_info.in.file.path = fname;
564         
565         status = smb_raw_pathinfo(cli2->tree, tctx, &finfo2);
566         
567         if (!NT_STATUS_IS_OK(status)) {
568                 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", 
569                           nt_errstr(status));
570                 ret = false;
571                 goto done;
572         }
573         
574         if (finfo1.basic_info.out.create_time !=
575             finfo2.basic_info.out.create_time) {
576                 torture_result(tctx, TORTURE_FAIL, __location__": create_time changed");
577                 ret = false;
578                 goto done;
579         }
580         
581         if (finfo1.basic_info.out.access_time !=
582             finfo2.basic_info.out.access_time) {
583                 torture_result(tctx, TORTURE_FAIL, __location__": access_time changed");
584                 ret = false;
585                 goto done;
586         }
587         
588         if (finfo1.basic_info.out.write_time !=
589             finfo2.basic_info.out.write_time) {
590                 torture_result(tctx, TORTURE_FAIL, __location__": write_time changed:\n"
591                                            "write time conn 1 = %s, conn 2 = %s", 
592                        nt_time_string(tctx, finfo1.basic_info.out.write_time),
593                        nt_time_string(tctx, finfo2.basic_info.out.write_time));
594                 ret = false;
595                 goto done;
596         }
597         
598         if (finfo1.basic_info.out.change_time !=
599             finfo2.basic_info.out.change_time) {
600                 torture_result(tctx, TORTURE_FAIL, __location__": change_time changed");
601                 ret = false;
602                 goto done;
603         }
604         
605         /* One of the two following calls updates the qpathinfo. */
606         
607         /* If you had skipped the smbcli_write on fnum2, it would
608          * *not* have updated the stat on disk */
609         
610         smbcli_close(cli2->tree, fnum2);
611         cli2 = NULL;
612
613         /* This call is only for the people looking at ethereal :-) */
614         finfo2.basic_info.level = RAW_FILEINFO_BASIC_INFO;
615         finfo2.basic_info.in.file.path = fname;
616
617         status = smb_raw_pathinfo(cli->tree, tctx, &finfo2);
618
619         if (!NT_STATUS_IS_OK(status)) {
620                 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", nt_errstr(status));
621                 ret = false;
622                 goto done;
623         }
624
625  done:
626         if (fnum1 != -1)
627                 smbcli_close(cli->tree, fnum1);
628         smbcli_unlink(cli->tree, fname);
629         smbcli_deltree(cli->tree, BASEDIR);
630
631         return ret;
632 }
633
634 #define COMPARE_WRITE_TIME_CMP(given, correct, cmp) do { \
635         uint64_t r = 10*1000*1000; \
636         NTTIME g = (given).basic_info.out.write_time; \
637         NTTIME gr = (g / r) * r; \
638         NTTIME c = (correct).basic_info.out.write_time; \
639         NTTIME cr = (c / r) * r; \
640         bool strict = torture_setting_bool(tctx, "strict mode", false); \
641         bool err = false; \
642         if (strict && (g cmp c)) { \
643                 err = true; \
644         } else if ((g cmp c) && (gr cmp cr)) { \
645                 /* handle filesystem without high resolution timestamps */ \
646                 err = true; \
647         } \
648         if (err) { \
649                 torture_result(tctx, TORTURE_FAIL, __location__": wrong write_time (%s)%s(%llu) %s (%s)%s(%llu)", \
650                                 #given, nt_time_string(tctx, g), (unsigned long long)g, \
651                                 #cmp, #correct, nt_time_string(tctx, c), (unsigned long long)c); \
652                 ret = false; \
653                 goto done; \
654         } \
655 } while (0)
656 #define COMPARE_WRITE_TIME_EQUAL(given,correct) \
657         COMPARE_WRITE_TIME_CMP(given,correct,!=)
658 #define COMPARE_WRITE_TIME_GREATER(given,correct) \
659         COMPARE_WRITE_TIME_CMP(given,correct,<=)
660 #define COMPARE_WRITE_TIME_LESS(given,correct) \
661         COMPARE_WRITE_TIME_CMP(given,correct,>=)
662
663 #define COMPARE_ACCESS_TIME_CMP(given, correct, cmp) do { \
664         NTTIME g = (given).basic_info.out.access_time; \
665         NTTIME c = (correct).basic_info.out.access_time; \
666         if (g cmp c) { \
667                 torture_result(tctx, TORTURE_FAIL, __location__": wrong access_time (%s)%s %s (%s)%s", \
668                                 #given, nt_time_string(tctx, g), \
669                                 #cmp, #correct, nt_time_string(tctx, c)); \
670                 ret = false; \
671                 goto done; \
672         } \
673 } while (0)
674 #define COMPARE_ACCESS_TIME_EQUAL(given,correct) \
675         COMPARE_ACCESS_TIME_CMP(given,correct,!=)
676
677 #define COMPARE_BOTH_TIMES_EQUAL(given,correct) do { \
678         COMPARE_ACCESS_TIME_EQUAL(given,correct); \
679         COMPARE_WRITE_TIME_EQUAL(given,correct); \
680 } while (0)
681
682 #define GET_INFO_FILE(finfo) do { \
683         NTSTATUS _status; \
684         _status = smb_raw_fileinfo(cli->tree, tctx, &finfo); \
685         if (!NT_STATUS_IS_OK(_status)) { \
686                 ret = false; \
687                 torture_result(tctx, TORTURE_FAIL, __location__": fileinfo failed: %s", \
688                                nt_errstr(_status)); \
689                 goto done; \
690         } \
691         torture_comment(tctx, "fileinfo: Access(%s) Write(%s)\n", \
692                         nt_time_string(tctx, finfo.basic_info.out.access_time), \
693                         nt_time_string(tctx, finfo.basic_info.out.write_time)); \
694 } while (0)
695 #define GET_INFO_PATH(pinfo) do { \
696         NTSTATUS _status; \
697         _status = smb_raw_pathinfo(cli2->tree, tctx, &pinfo); \
698         if (!NT_STATUS_IS_OK(_status)) { \
699                 torture_result(tctx, TORTURE_FAIL, __location__": pathinfo failed: %s", \
700                                nt_errstr(_status)); \
701                 ret = false; \
702                 goto done; \
703         } \
704         torture_comment(tctx, "pathinfo: Access(%s) Write(%s)\n", \
705                         nt_time_string(tctx, pinfo.basic_info.out.access_time), \
706                         nt_time_string(tctx, pinfo.basic_info.out.write_time)); \
707 } while (0)
708 #define GET_INFO_BOTH(finfo,pinfo) do { \
709         GET_INFO_FILE(finfo); \
710         GET_INFO_PATH(pinfo); \
711         COMPARE_BOTH_TIMES_EQUAL(finfo,pinfo); \
712 } while (0)
713
714 #define SET_INFO_FILE_EX(finfo, wrtime, tree, tfnum) do { \
715         NTSTATUS _status; \
716         union smb_setfileinfo sfinfo; \
717         sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFO; \
718         sfinfo.basic_info.in.file.fnum = tfnum; \
719         sfinfo.basic_info.in.create_time = 0; \
720         sfinfo.basic_info.in.access_time = 0; \
721         unix_to_nt_time(&sfinfo.basic_info.in.write_time, (wrtime)); \
722         sfinfo.basic_info.in.change_time = 0; \
723         sfinfo.basic_info.in.attrib = finfo1.basic_info.out.attrib; \
724         _status = smb_raw_setfileinfo(tree, &sfinfo); \
725         if (!NT_STATUS_IS_OK(_status)) { \
726                 torture_result(tctx, TORTURE_FAIL, __location__": setfileinfo failed: %s", \
727                                nt_errstr(_status)); \
728                 ret = false; \
729                 goto done; \
730         } \
731 } while (0)
732 #define SET_INFO_FILE(finfo, wrtime) \
733         SET_INFO_FILE_EX(finfo, wrtime, cli->tree, fnum1)
734
735 static bool test_delayed_write_update3(struct torture_context *tctx,
736                                        struct smbcli_state *cli,
737                                        struct smbcli_state *cli2)
738 {
739         union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
740         union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
741         const char *fname = BASEDIR "\\torture_file.txt";
742         int fnum1 = -1;
743         bool ret = true;
744         ssize_t written;
745         struct timeval start;
746         struct timeval end;
747         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
748         int normal_delay = 2000000;
749         double sec = ((double)used_delay) / ((double)normal_delay);
750         int msec = 1000 * sec;
751
752         if (!torture_setup_dir(cli, BASEDIR)) {
753                 return false;
754         }
755
756         torture_comment(tctx, "Open the file handle\n");
757         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
758         if (fnum1 == -1) {
759                 ret = false;
760                 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
761                 goto done;
762         }
763
764         finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
765         finfo0.basic_info.in.file.fnum = fnum1;
766         finfo1 = finfo0;
767         finfo2 = finfo0;
768         finfo3 = finfo0;
769         finfo4 = finfo0;
770         pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
771         pinfo0.basic_info.in.file.path = fname;
772         pinfo1 = pinfo0;
773         pinfo2 = pinfo0;
774         pinfo3 = pinfo0;
775         pinfo4 = pinfo0;
776         pinfo5 = pinfo0;
777
778         /* get the initial times */
779         GET_INFO_BOTH(finfo0,pinfo0);
780
781         /*
782          * make sure the write time is updated 2 seconds later
783          * calcuated from the first write
784          * (but expect upto 5 seconds extra time for a busy server)
785          */
786         start = timeval_current();
787         end = timeval_add(&start, 7 * sec, 0);
788         while (!timeval_expired(&end)) {
789                 /* do a write */
790                 torture_comment(tctx, "Do a write on the file handle\n");
791                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
792                 if (written != 1) {
793                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
794                         ret = false;
795                         goto done;
796                 }
797                 /* get the times after the write */
798                 GET_INFO_FILE(finfo1);
799
800                 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
801                         double diff = timeval_elapsed(&start);
802                         if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
803                                 torture_comment(tctx, "Server updated write_time after %.2f seconds "
804                                                 "(1sec == %.2f) (wrong!)\n",
805                                                 diff, sec);
806                                 ret = false;
807                                 break;
808                         }
809
810                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
811                                         "(1sec == %.2f) (correct)\n",
812                                         diff, sec);
813                         break;
814                 }
815                 msleep(0.5 * msec);
816         }
817
818         GET_INFO_BOTH(finfo1,pinfo1);
819         COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
820
821         /* sure any further write doesn't update the write time */
822         start = timeval_current();
823         end = timeval_add(&start, 15 * sec, 0);
824         while (!timeval_expired(&end)) {
825                 /* do a write */
826                 torture_comment(tctx, "Do a write on the file handle\n");
827                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
828                 if (written != 1) {
829                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
830                         ret = false;
831                         goto done;
832                 }
833                 /* get the times after the write */
834                 GET_INFO_BOTH(finfo2,pinfo2);
835
836                 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
837                         double diff = timeval_elapsed(&start);
838                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
839                                         "(1sec == %.2f) (wrong!)\n",
840                                         diff, sec);
841                         ret = false;
842                         break;
843                 }
844                 msleep(2 * msec);
845         }
846
847         GET_INFO_BOTH(finfo2,pinfo2);
848         COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
849         if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
850                 torture_comment(tctx, "Server did not update write_time (correct)\n");
851         }
852
853         /* sleep */
854         msleep(5 * msec);
855
856         GET_INFO_BOTH(finfo3,pinfo3);
857         COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
858
859         /*
860          * the close updates the write time to the time of the close
861          * and not to the time of the last write!
862          */
863         torture_comment(tctx, "Close the file handle\n");
864         smbcli_close(cli->tree, fnum1);
865         fnum1 = -1;
866
867         GET_INFO_PATH(pinfo4);
868         COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
869
870         if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
871                 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
872         }
873
874  done:
875         if (fnum1 != -1)
876                 smbcli_close(cli->tree, fnum1);
877         smbcli_unlink(cli->tree, fname);
878         smbcli_deltree(cli->tree, BASEDIR);
879
880         return ret;
881 }
882
883 static bool test_delayed_write_update4(struct torture_context *tctx,
884                                        struct smbcli_state *cli,
885                                        struct smbcli_state *cli2)
886 {
887         union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
888         union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
889         const char *fname = BASEDIR "\\torture_file.txt";
890         int fnum1 = -1;
891         bool ret = true;
892         ssize_t written;
893         struct timeval start;
894         struct timeval end;
895         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
896         int normal_delay = 2000000;
897         double sec = ((double)used_delay) / ((double)normal_delay);
898         int msec = 1000 * sec;
899
900         if (!torture_setup_dir(cli, BASEDIR)) {
901                 return false;
902         }
903
904         torture_comment(tctx, "Open the file handle\n");
905         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
906         if (fnum1 == -1) {
907                 ret = false;
908                 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
909                 goto done;
910         }
911
912         finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
913         finfo0.basic_info.in.file.fnum = fnum1;
914         finfo1 = finfo0;
915         finfo2 = finfo0;
916         finfo3 = finfo0;
917         finfo4 = finfo0;
918         pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
919         pinfo0.basic_info.in.file.path = fname;
920         pinfo1 = pinfo0;
921         pinfo2 = pinfo0;
922         pinfo3 = pinfo0;
923         pinfo4 = pinfo0;
924         pinfo5 = pinfo0;
925
926         /* get the initial times */
927         GET_INFO_BOTH(finfo0,pinfo0);
928
929         /* sleep a bit */
930         msleep(5 * msec);
931
932         /* do a write */
933         torture_comment(tctx, "Do a write on the file handle\n");
934         written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
935         if (written != 1) {
936                 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
937                 ret = false;
938                 goto done;
939         }
940
941         GET_INFO_BOTH(finfo1,pinfo1);
942         COMPARE_WRITE_TIME_EQUAL(finfo1,finfo0);
943
944         /*
945          * make sure the write time is updated 2 seconds later
946          * calcuated from the first write
947          * (but expect upto 3 seconds extra time for a busy server)
948          */
949         start = timeval_current();
950         end = timeval_add(&start, 5 * sec, 0);
951         while (!timeval_expired(&end)) {
952                 /* get the times after the first write */
953                 GET_INFO_FILE(finfo1);
954
955                 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
956                         double diff = timeval_elapsed(&start);
957                         if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
958                                 torture_comment(tctx, "Server updated write_time after %.2f seconds "
959                                                 "(1sec == %.2f) (wrong!)\n",
960                                                 diff, sec);
961                                 ret = false;
962                                 break;
963                         }
964
965                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
966                                         "(1sec == %.2f) (correct)\n",
967                                         diff, sec);
968                         break;
969                 }
970                 msleep(0.5 * msec);
971         }
972
973         GET_INFO_BOTH(finfo1,pinfo1);
974         COMPARE_WRITE_TIME_GREATER(pinfo1, pinfo0);
975
976         /* sure any further write doesn't update the write time */
977         start = timeval_current();
978         end = timeval_add(&start, 15 * sec, 0);
979         while (!timeval_expired(&end)) {
980                 /* do a write */
981                 torture_comment(tctx, "Do a write on the file handle\n");
982                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
983                 if (written != 1) {
984                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
985                         ret = false;
986                         goto done;
987                 }
988                 /* get the times after the write */
989                 GET_INFO_BOTH(finfo2,pinfo2);
990
991                 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
992                         double diff = timeval_elapsed(&start);
993                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
994                                         "(1sec == %.2f) (wrong!)\n",
995                                         diff, sec);
996                         ret = false;
997                         break;
998                 }
999                 msleep(2 * msec);
1000         }
1001
1002         GET_INFO_BOTH(finfo2,pinfo2);
1003         COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
1004         if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
1005                 torture_comment(tctx, "Server did not updatewrite_time (correct)\n");
1006         }
1007
1008         /* sleep */
1009         msleep(5 * msec);
1010
1011         GET_INFO_BOTH(finfo3,pinfo3);
1012         COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1013
1014         /*
1015          * the close updates the write time to the time of the close
1016          * and not to the time of the last write!
1017          */
1018         torture_comment(tctx, "Close the file handle\n");
1019         smbcli_close(cli->tree, fnum1);
1020         fnum1 = -1;
1021
1022         GET_INFO_PATH(pinfo4);
1023         COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
1024
1025         if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
1026                 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
1027         }
1028
1029  done:
1030         if (fnum1 != -1)
1031                 smbcli_close(cli->tree, fnum1);
1032         smbcli_unlink(cli->tree, fname);
1033         smbcli_deltree(cli->tree, BASEDIR);
1034
1035         return ret;
1036 }
1037
1038 static bool test_delayed_write_update5(struct torture_context *tctx,
1039                                        struct smbcli_state *cli,
1040                                        struct smbcli_state *cli2)
1041 {
1042         union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
1043         union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6;
1044         const char *fname = BASEDIR "\\torture_file.txt";
1045         int fnum1 = -1;
1046         bool ret = true;
1047         ssize_t written;
1048         struct timeval start;
1049         struct timeval end;
1050         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1051         int normal_delay = 2000000;
1052         double sec = ((double)used_delay) / ((double)normal_delay);
1053         int msec = 1000 * sec;
1054
1055         if (!torture_setup_dir(cli, BASEDIR)) {
1056                 return false;
1057         }
1058
1059         torture_comment(tctx, "Open the file handle\n");
1060         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1061         if (fnum1 == -1) {
1062                 ret = false;
1063                 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1064                 goto done;
1065         }
1066
1067         finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1068         finfo0.basic_info.in.file.fnum = fnum1;
1069         finfo1 = finfo0;
1070         finfo2 = finfo0;
1071         finfo3 = finfo0;
1072         finfo4 = finfo0;
1073         finfo5 = finfo0;
1074         pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1075         pinfo0.basic_info.in.file.path = fname;
1076         pinfo1 = pinfo0;
1077         pinfo2 = pinfo0;
1078         pinfo3 = pinfo0;
1079         pinfo4 = pinfo0;
1080         pinfo5 = pinfo0;
1081         pinfo6 = pinfo0;
1082
1083         /* get the initial times */
1084         GET_INFO_BOTH(finfo0,pinfo0);
1085
1086         /* do a write */
1087         torture_comment(tctx, "Do a write on the file handle\n");
1088         written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1089         if (written != 1) {
1090                 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1091                 ret = false;
1092                 goto done;
1093         }
1094
1095         GET_INFO_BOTH(finfo1,pinfo1);
1096         COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
1097
1098         torture_comment(tctx, "Set write time in the future on the file handle\n");
1099         SET_INFO_FILE(finfo0, time(NULL) + 86400);
1100         GET_INFO_BOTH(finfo2,pinfo2);
1101         COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
1102
1103         torture_comment(tctx, "Set write time in the past on the file handle\n");
1104         SET_INFO_FILE(finfo0, time(NULL) - 86400);
1105         GET_INFO_BOTH(finfo2,pinfo2);
1106         COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
1107
1108         /* make sure the 2 second delay from the first write are canceled */
1109         start = timeval_current();
1110         end = timeval_add(&start, 15 * sec, 0);
1111         while (!timeval_expired(&end)) {
1112
1113                 /* get the times after the first write */
1114                 GET_INFO_BOTH(finfo3,pinfo3);
1115
1116                 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
1117                         double diff = timeval_elapsed(&start);
1118                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
1119                                         "(1sec == %.2f) (wrong!)\n",
1120                                         diff, sec);
1121                         ret = false;
1122                         break;
1123                 }
1124                 msleep(2 * msec);
1125         }
1126
1127         GET_INFO_BOTH(finfo3,pinfo3);
1128         COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1129         if (finfo3.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1130                 torture_comment(tctx, "Server did not update write_time (correct)\n");
1131         }
1132
1133         /* sure any further write doesn't update the write time */
1134         start = timeval_current();
1135         end = timeval_add(&start, 15 * sec, 0);
1136         while (!timeval_expired(&end)) {
1137                 /* do a write */
1138                 torture_comment(tctx, "Do a write on the file handle\n");
1139                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1140                 if (written != 1) {
1141                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1142                         ret = false;
1143                         goto done;
1144                 }
1145                 /* get the times after the write */
1146                 GET_INFO_BOTH(finfo4,pinfo4);
1147
1148                 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
1149                         double diff = timeval_elapsed(&start);
1150                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
1151                                         "(1sec == %.2f) (wrong!)\n",
1152                                         diff, sec);
1153                         ret = false;
1154                         break;
1155                 }
1156                 msleep(2 * msec);
1157         }
1158
1159         GET_INFO_BOTH(finfo4,pinfo4);
1160         COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
1161         if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1162                 torture_comment(tctx, "Server did not update write_time (correct)\n");
1163         }
1164
1165         /* sleep */
1166         msleep(5 * msec);
1167
1168         GET_INFO_BOTH(finfo5,pinfo5);
1169         COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
1170
1171         /*
1172          * the close doesn't update the write time
1173          */
1174         torture_comment(tctx, "Close the file handle\n");
1175         smbcli_close(cli->tree, fnum1);
1176         fnum1 = -1;
1177
1178         GET_INFO_PATH(pinfo6);
1179         COMPARE_WRITE_TIME_EQUAL(pinfo6, pinfo5);
1180
1181         if (pinfo6.basic_info.out.write_time == pinfo5.basic_info.out.write_time) {
1182                 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
1183         }
1184
1185  done:
1186         if (fnum1 != -1)
1187                 smbcli_close(cli->tree, fnum1);
1188         smbcli_unlink(cli->tree, fname);
1189         smbcli_deltree(cli->tree, BASEDIR);
1190
1191         return ret;
1192 }
1193
1194 static bool test_delayed_write_update6(struct torture_context *tctx,
1195                                        struct smbcli_state *cli,
1196                                        struct smbcli_state *cli2)
1197 {
1198         union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
1199         union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6, pinfo7;
1200         const char *fname = BASEDIR "\\torture_file.txt";
1201         int fnum1 = -1;
1202         int fnum2 = -1;
1203         bool ret = true;
1204         ssize_t written;
1205         struct timeval start;
1206         struct timeval end;
1207         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1208         int normal_delay = 2000000;
1209         double sec = ((double)used_delay) / ((double)normal_delay);
1210         int msec = 1000 * sec;
1211         bool first = true;
1212
1213         if (!torture_setup_dir(cli, BASEDIR)) {
1214                 return false;
1215         }
1216 again:
1217         torture_comment(tctx, "Open the file handle\n");
1218         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1219         if (fnum1 == -1) {
1220                 ret = false;
1221                 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1222                 goto done;
1223         }
1224
1225         if (fnum2 == -1) {
1226                 torture_comment(tctx, "Open the 2nd file handle on 2nd connection\n");
1227                 fnum2 = smbcli_open(cli2->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1228                 if (fnum2 == -1) {
1229                         ret = false;
1230                         torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1231                         goto done;
1232                 }
1233         }
1234
1235         finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1236         finfo0.basic_info.in.file.fnum = fnum1;
1237         finfo1 = finfo0;
1238         finfo2 = finfo0;
1239         finfo3 = finfo0;
1240         finfo4 = finfo0;
1241         finfo5 = finfo0;
1242         pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1243         pinfo0.basic_info.in.file.path = fname;
1244         pinfo1 = pinfo0;
1245         pinfo2 = pinfo0;
1246         pinfo3 = pinfo0;
1247         pinfo4 = pinfo0;
1248         pinfo5 = pinfo0;
1249         pinfo6 = pinfo0;
1250         pinfo7 = pinfo0;
1251
1252         /* get the initial times */
1253         GET_INFO_BOTH(finfo0,pinfo0);
1254
1255         /* do a write */
1256         torture_comment(tctx, "Do a write on the file handle\n");
1257         written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1258         if (written != 1) {
1259                 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1260                 ret = false;
1261                 goto done;
1262         }
1263
1264         GET_INFO_BOTH(finfo1,pinfo1);
1265         COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
1266
1267         torture_comment(tctx, "Set write time in the future on the 2nd file handle\n");
1268         SET_INFO_FILE_EX(finfo0, time(NULL) + 86400, cli2->tree, fnum2);
1269         GET_INFO_BOTH(finfo2,pinfo2);
1270         COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
1271
1272         torture_comment(tctx, "Set write time in the past on the 2nd file handle\n");
1273         SET_INFO_FILE_EX(finfo0, time(NULL) - 86400, cli2->tree, fnum2);
1274         GET_INFO_BOTH(finfo2,pinfo2);
1275         COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
1276
1277         /* make sure the 2 second delay from the first write are canceled */
1278         start = timeval_current();
1279         end = timeval_add(&start, 15 * sec, 0);
1280         while (!timeval_expired(&end)) {
1281
1282                 /* get the times after the first write */
1283                 GET_INFO_BOTH(finfo3,pinfo3);
1284
1285                 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
1286                         double diff = timeval_elapsed(&start);
1287                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
1288                                         "(1sec == %.2f) (wrong!)\n",
1289                                         diff, sec);
1290                         ret = false;
1291                         break;
1292                 }
1293                 msleep(2 * msec);
1294         }
1295
1296         GET_INFO_BOTH(finfo3,pinfo3);
1297         COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1298         if (finfo3.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1299                 torture_comment(tctx, "Server did not update write_time (correct)\n");
1300         }
1301
1302         /* sure any further write doesn't update the write time */
1303         start = timeval_current();
1304         end = timeval_add(&start, 15 * sec, 0);
1305         while (!timeval_expired(&end)) {
1306                 /* do a write */
1307                 torture_comment(tctx, "Do a write on the file handle\n");
1308                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1309                 if (written != 1) {
1310                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1311                         ret = false;
1312                         goto done;
1313                 }
1314                 /* get the times after the write */
1315                 GET_INFO_BOTH(finfo4,pinfo4);
1316
1317                 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
1318                         double diff = timeval_elapsed(&start);
1319                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
1320                                         "(1sec == %.2f) (wrong!)\n",
1321                                         diff, sec);
1322                         ret = false;
1323                         break;
1324                 }
1325                 msleep(2 * msec);
1326         }
1327
1328         GET_INFO_BOTH(finfo4,pinfo4);
1329         COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
1330         if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1331                 torture_comment(tctx, "Server did not update write_time (correct)\n");
1332         }
1333
1334         /* sleep */
1335         msleep(5 * msec);
1336
1337         GET_INFO_BOTH(finfo5,pinfo5);
1338         COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
1339
1340         /*
1341          * the close updates the write time to the time of the close
1342          * as the write time was set on the 2nd handle
1343          */
1344         torture_comment(tctx, "Close the file handle\n");
1345         smbcli_close(cli->tree, fnum1);
1346         fnum1 = -1;
1347
1348         GET_INFO_PATH(pinfo6);
1349         COMPARE_WRITE_TIME_GREATER(pinfo6, pinfo5);
1350
1351         if (pinfo6.basic_info.out.write_time > pinfo5.basic_info.out.write_time) {
1352                 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
1353         }
1354
1355         /* keep the 2nd handle open and rerun tests */
1356         if (first) {
1357                 first = false;
1358                 goto again;
1359         }
1360
1361         /*
1362          * closing the 2nd handle will cause no write time update
1363          * as the write time was explicit set on this handle
1364          */
1365         torture_comment(tctx, "Close the 2nd file handle\n");
1366         smbcli_close(cli2->tree, fnum2);
1367         fnum2 = -1;
1368
1369         GET_INFO_PATH(pinfo7);
1370         COMPARE_WRITE_TIME_EQUAL(pinfo7, pinfo6);
1371
1372         if (pinfo7.basic_info.out.write_time == pinfo6.basic_info.out.write_time) {
1373                 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
1374         }
1375
1376  done:
1377         if (fnum1 != -1)
1378                 smbcli_close(cli->tree, fnum1);
1379         if (fnum2 != -1)
1380                 smbcli_close(cli2->tree, fnum2);
1381         smbcli_unlink(cli->tree, fname);
1382         smbcli_deltree(cli->tree, BASEDIR);
1383
1384         return ret;
1385 }
1386
1387
1388 /* 
1389    testing of delayed update of write_time
1390 */
1391 struct torture_suite *torture_delay_write(void)
1392 {
1393         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "DELAYWRITE");
1394
1395         torture_suite_add_2smb_test(suite, "finfo update on close", test_finfo_after_write);
1396         torture_suite_add_1smb_test(suite, "delayed update of write time", test_delayed_write_update);
1397         torture_suite_add_2smb_test(suite, "delayed update of write time using 2 connections", test_delayed_write_update2);
1398         torture_suite_add_2smb_test(suite, "delayed update of write time 3", test_delayed_write_update3);
1399         torture_suite_add_2smb_test(suite, "delayed update of write time 4", test_delayed_write_update4);
1400         torture_suite_add_2smb_test(suite, "delayed update of write time 5", test_delayed_write_update5);
1401         torture_suite_add_2smb_test(suite, "delayed update of write time 6", test_delayed_write_update6);
1402
1403         return suite;
1404 }