source4/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 (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
 820         /* sure any further write doesn't update the write time */
 821         start = timeval_current();
 822         end = timeval_add(&start, 15 * sec, 0);
 823         while (!timeval_expired(&end)) {
 824                 /* do a write */
 825                 torture_comment(tctx, "Do a write on the file handle\n");
 826                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
 827                 if (written != 1) {
 828                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
 829                         ret = false;
 830                         goto done;
 831                 }
 832                 /* get the times after the write */
 833                 GET_INFO_BOTH(finfo2,pinfo2);
 834
 835                 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
 836                         double diff = timeval_elapsed(&start);
 837                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
 838                                         "(1sec == %.2f) (wrong!)\n",
 839                                         diff, sec);
 840                         ret = false;
 841                         break;
 842                 }
 843                 msleep(2 * msec);
 844         }
 845
 846         GET_INFO_BOTH(finfo2,pinfo2);
 847         COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
 848         if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
 849                 torture_comment(tctx, "Server did not update write_time (correct)\n");
 850         }
 851
 852         /* sleep */
 853         msleep(5 * msec);
 854
 855         GET_INFO_BOTH(finfo3,pinfo3);
 856         COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
 857
 858         /*
 859          * the close updates the write time to the time of the close
 860          * and not to the time of the last write!
 861          */
 862         torture_comment(tctx, "Close the file handle\n");
 863         smbcli_close(cli->tree, fnum1);
 864         fnum1 = -1;
 865
 866         GET_INFO_PATH(pinfo4);
 867         COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
 868
 869         if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
 870                 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
 871         }
 872
 873  done:
 874         if (fnum1 != -1)
 875                 smbcli_close(cli->tree, fnum1);
 876         smbcli_unlink(cli->tree, fname);
 877         smbcli_deltree(cli->tree, BASEDIR);
 878
 879         return ret;
 880 }
 881
 882 static bool test_delayed_write_update4(struct torture_context *tctx,
 883                                        struct smbcli_state *cli,
 884                                        struct smbcli_state *cli2)
 885 {
 886         union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4;
 887         union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5;
 888         const char *fname = BASEDIR "\\torture_file.txt";
 889         int fnum1 = -1;
 890         bool ret = true;
 891         ssize_t written;
 892         struct timeval start;
 893         struct timeval end;
 894         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
 895         int normal_delay = 2000000;
 896         double sec = ((double)used_delay) / ((double)normal_delay);
 897         int msec = 1000 * sec;
 898
 899         if (!torture_setup_dir(cli, BASEDIR)) {
 900                 return false;
 901         }
 902
 903         torture_comment(tctx, "Open the file handle\n");
 904         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
 905         if (fnum1 == -1) {
 906                 ret = false;
 907                 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
 908                 goto done;
 909         }
 910
 911         finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 912         finfo0.basic_info.in.file.fnum = fnum1;
 913         finfo1 = finfo0;
 914         finfo2 = finfo0;
 915         finfo3 = finfo0;
 916         finfo4 = finfo0;
 917         pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
 918         pinfo0.basic_info.in.file.path = fname;
 919         pinfo1 = pinfo0;
 920         pinfo2 = pinfo0;
 921         pinfo3 = pinfo0;
 922         pinfo4 = pinfo0;
 923         pinfo5 = pinfo0;
 924
 925         /* get the initial times */
 926         GET_INFO_BOTH(finfo0,pinfo0);
 927
 928         /* sleep a bit */
 929         msleep(5 * msec);
 930
 931         /* do a write */
 932         torture_comment(tctx, "Do a write on the file handle\n");
 933         written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
 934         if (written != 1) {
 935                 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
 936                 ret = false;
 937                 goto done;
 938         }
 939
 940         GET_INFO_BOTH(finfo1,pinfo1);
 941         COMPARE_WRITE_TIME_EQUAL(finfo1,finfo0);
 942
 943         /*
 944          * make sure the write time is updated 2 seconds later
 945          * calcuated from the first write
 946          * (but expect upto 3 seconds extra time for a busy server)
 947          */
 948         start = timeval_current();
 949         end = timeval_add(&start, 5 * sec, 0);
 950         while (!timeval_expired(&end)) {
 951                 /* get the times after the first write */
 952                 GET_INFO_FILE(finfo1);
 953
 954                 if (finfo1.basic_info.out.write_time > finfo0.basic_info.out.write_time) {
 955                         double diff = timeval_elapsed(&start);
 956                         if (diff < (2 * sec * 0.75)) { /* 0.75 to cope with vmware timing */
 957                                 torture_comment(tctx, "Server updated write_time after %.2f seconds "
 958                                                 "(1sec == %.2f) (wrong!)\n",
 959                                                 diff, sec);
 960                                 ret = false;
 961                                 break;
 962                         }
 963
 964                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
 965                                         "(1sec == %.2f) (correct)\n",
 966                                         diff, sec);
 967                         break;
 968                 }
 969                 msleep(0.5 * msec);
 970         }
 971
 972         GET_INFO_BOTH(finfo1,pinfo1);
 973
 974         /* sure any further write doesn't update the write time */
 975         start = timeval_current();
 976         end = timeval_add(&start, 15 * sec, 0);
 977         while (!timeval_expired(&end)) {
 978                 /* do a write */
 979                 torture_comment(tctx, "Do a write on the file handle\n");
 980                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
 981                 if (written != 1) {
 982                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
 983                         ret = false;
 984                         goto done;
 985                 }
 986                 /* get the times after the write */
 987                 GET_INFO_BOTH(finfo2,pinfo2);
 988
 989                 if (finfo2.basic_info.out.write_time > finfo1.basic_info.out.write_time) {
 990                         double diff = timeval_elapsed(&start);
 991                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
 992                                         "(1sec == %.2f) (wrong!)\n",
 993                                         diff, sec);
 994                         ret = false;
 995                         break;
 996                 }
 997                 msleep(2 * msec);
 998         }
 999
1000         GET_INFO_BOTH(finfo2,pinfo2);
1001         COMPARE_WRITE_TIME_EQUAL(finfo2, finfo1);
1002         if (finfo2.basic_info.out.write_time == finfo1.basic_info.out.write_time) {
1003                 torture_comment(tctx, "Server did not updatewrite_time (correct)\n");
1004         }
1005
1006         /* sleep */
1007         msleep(5 * msec);
1008
1009         GET_INFO_BOTH(finfo3,pinfo3);
1010         COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1011
1012         /*
1013          * the close updates the write time to the time of the close
1014          * and not to the time of the last write!
1015          */
1016         torture_comment(tctx, "Close the file handle\n");
1017         smbcli_close(cli->tree, fnum1);
1018         fnum1 = -1;
1019
1020         GET_INFO_PATH(pinfo4);
1021         COMPARE_WRITE_TIME_GREATER(pinfo4, pinfo3);
1022
1023         if (pinfo4.basic_info.out.write_time > pinfo3.basic_info.out.write_time) {
1024                 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
1025         }
1026
1027  done:
1028         if (fnum1 != -1)
1029                 smbcli_close(cli->tree, fnum1);
1030         smbcli_unlink(cli->tree, fname);
1031         smbcli_deltree(cli->tree, BASEDIR);
1032
1033         return ret;
1034 }
1035
1036 static bool test_delayed_write_update5(struct torture_context *tctx,
1037                                        struct smbcli_state *cli,
1038                                        struct smbcli_state *cli2)
1039 {
1040         union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
1041         union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6;
1042         const char *fname = BASEDIR "\\torture_file.txt";
1043         int fnum1 = -1;
1044         bool ret = true;
1045         ssize_t written;
1046         struct timeval start;
1047         struct timeval end;
1048         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1049         int normal_delay = 2000000;
1050         double sec = ((double)used_delay) / ((double)normal_delay);
1051         int msec = 1000 * sec;
1052
1053         if (!torture_setup_dir(cli, BASEDIR)) {
1054                 return false;
1055         }
1056
1057         torture_comment(tctx, "Open the file handle\n");
1058         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1059         if (fnum1 == -1) {
1060                 ret = false;
1061                 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1062                 goto done;
1063         }
1064
1065         finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1066         finfo0.basic_info.in.file.fnum = fnum1;
1067         finfo1 = finfo0;
1068         finfo2 = finfo0;
1069         finfo3 = finfo0;
1070         finfo4 = finfo0;
1071         finfo5 = finfo0;
1072         pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1073         pinfo0.basic_info.in.file.path = fname;
1074         pinfo1 = pinfo0;
1075         pinfo2 = pinfo0;
1076         pinfo3 = pinfo0;
1077         pinfo4 = pinfo0;
1078         pinfo5 = pinfo0;
1079         pinfo6 = pinfo0;
1080
1081         /* get the initial times */
1082         GET_INFO_BOTH(finfo0,pinfo0);
1083
1084         /* do a write */
1085         torture_comment(tctx, "Do a write on the file handle\n");
1086         written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1087         if (written != 1) {
1088                 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1089                 ret = false;
1090                 goto done;
1091         }
1092
1093         GET_INFO_BOTH(finfo1,pinfo1);
1094         COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
1095
1096         torture_comment(tctx, "Set write time in the future on the file handle\n");
1097         SET_INFO_FILE(finfo0, time(NULL) + 86400);
1098         GET_INFO_BOTH(finfo2,pinfo2);
1099         COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
1100
1101         torture_comment(tctx, "Set write time in the past on the file handle\n");
1102         SET_INFO_FILE(finfo0, time(NULL) - 86400);
1103         GET_INFO_BOTH(finfo2,pinfo2);
1104         COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
1105
1106         /* make sure the 2 second delay from the first write are canceled */
1107         start = timeval_current();
1108         end = timeval_add(&start, 15 * sec, 0);
1109         while (!timeval_expired(&end)) {
1110
1111                 /* get the times after the first write */
1112                 GET_INFO_BOTH(finfo3,pinfo3);
1113
1114                 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
1115                         double diff = timeval_elapsed(&start);
1116                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
1117                                         "(1sec == %.2f) (wrong!)\n",
1118                                         diff, sec);
1119                         ret = false;
1120                         break;
1121                 }
1122                 msleep(2 * msec);
1123         }
1124
1125         GET_INFO_BOTH(finfo3,pinfo3);
1126         COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1127         if (finfo3.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1128                 torture_comment(tctx, "Server did not update write_time (correct)\n");
1129         }
1130
1131         /* sure any further write doesn't update the write time */
1132         start = timeval_current();
1133         end = timeval_add(&start, 15 * sec, 0);
1134         while (!timeval_expired(&end)) {
1135                 /* do a write */
1136                 torture_comment(tctx, "Do a write on the file handle\n");
1137                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1138                 if (written != 1) {
1139                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1140                         ret = false;
1141                         goto done;
1142                 }
1143                 /* get the times after the write */
1144                 GET_INFO_BOTH(finfo4,pinfo4);
1145
1146                 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
1147                         double diff = timeval_elapsed(&start);
1148                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
1149                                         "(1sec == %.2f) (wrong!)\n",
1150                                         diff, sec);
1151                         ret = false;
1152                         break;
1153                 }
1154                 msleep(2 * msec);
1155         }
1156
1157         GET_INFO_BOTH(finfo4,pinfo4);
1158         COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
1159         if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1160                 torture_comment(tctx, "Server did not update write_time (correct)\n");
1161         }
1162
1163         /* sleep */
1164         msleep(5 * msec);
1165
1166         GET_INFO_BOTH(finfo5,pinfo5);
1167         COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
1168
1169         /*
1170          * the close doesn't update the write time
1171          */
1172         torture_comment(tctx, "Close the file handle\n");
1173         smbcli_close(cli->tree, fnum1);
1174         fnum1 = -1;
1175
1176         GET_INFO_PATH(pinfo6);
1177         COMPARE_WRITE_TIME_EQUAL(pinfo6, pinfo5);
1178
1179         if (pinfo6.basic_info.out.write_time == pinfo5.basic_info.out.write_time) {
1180                 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
1181         }
1182
1183  done:
1184         if (fnum1 != -1)
1185                 smbcli_close(cli->tree, fnum1);
1186         smbcli_unlink(cli->tree, fname);
1187         smbcli_deltree(cli->tree, BASEDIR);
1188
1189         return ret;
1190 }
1191
1192 static bool test_delayed_write_update6(struct torture_context *tctx,
1193                                        struct smbcli_state *cli,
1194                                        struct smbcli_state *cli2)
1195 {
1196         union smb_fileinfo finfo0, finfo1, finfo2, finfo3, finfo4, finfo5;
1197         union smb_fileinfo pinfo0, pinfo1, pinfo2, pinfo3, pinfo4, pinfo5, pinfo6, pinfo7;
1198         const char *fname = BASEDIR "\\torture_file.txt";
1199         int fnum1 = -1;
1200         int fnum2 = -1;
1201         bool ret = true;
1202         ssize_t written;
1203         struct timeval start;
1204         struct timeval end;
1205         int used_delay = torture_setting_int(tctx, "writetimeupdatedelay", 2000000);
1206         int normal_delay = 2000000;
1207         double sec = ((double)used_delay) / ((double)normal_delay);
1208         int msec = 1000 * sec;
1209         bool first = true;
1210
1211         if (!torture_setup_dir(cli, BASEDIR)) {
1212                 return false;
1213         }
1214 again:
1215         torture_comment(tctx, "Open the file handle\n");
1216         fnum1 = smbcli_open(cli->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1217         if (fnum1 == -1) {
1218                 ret = false;
1219                 torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1220                 goto done;
1221         }
1222
1223         if (fnum2 == -1) {
1224                 torture_comment(tctx, "Open the 2nd file handle on 2nd connection\n");
1225                 fnum2 = smbcli_open(cli2->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
1226                 if (fnum2 == -1) {
1227                         ret = false;
1228                         torture_result(tctx, TORTURE_FAIL, __location__": unable to open %s", fname);
1229                         goto done;
1230                 }
1231         }
1232
1233         finfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1234         finfo0.basic_info.in.file.fnum = fnum1;
1235         finfo1 = finfo0;
1236         finfo2 = finfo0;
1237         finfo3 = finfo0;
1238         finfo4 = finfo0;
1239         finfo5 = finfo0;
1240         pinfo0.basic_info.level = RAW_FILEINFO_BASIC_INFO;
1241         pinfo0.basic_info.in.file.path = fname;
1242         pinfo1 = pinfo0;
1243         pinfo2 = pinfo0;
1244         pinfo3 = pinfo0;
1245         pinfo4 = pinfo0;
1246         pinfo5 = pinfo0;
1247         pinfo6 = pinfo0;
1248         pinfo7 = pinfo0;
1249
1250         /* get the initial times */
1251         GET_INFO_BOTH(finfo0,pinfo0);
1252
1253         /* do a write */
1254         torture_comment(tctx, "Do a write on the file handle\n");
1255         written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1256         if (written != 1) {
1257                 torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1258                 ret = false;
1259                 goto done;
1260         }
1261
1262         GET_INFO_BOTH(finfo1,pinfo1);
1263         COMPARE_WRITE_TIME_EQUAL(finfo1, finfo0);
1264
1265         torture_comment(tctx, "Set write time in the future on the 2nd file handle\n");
1266         SET_INFO_FILE_EX(finfo0, time(NULL) + 86400, cli2->tree, fnum2);
1267         GET_INFO_BOTH(finfo2,pinfo2);
1268         COMPARE_WRITE_TIME_GREATER(finfo2, finfo1);
1269
1270         torture_comment(tctx, "Set write time in the past on the 2nd file handle\n");
1271         SET_INFO_FILE_EX(finfo0, time(NULL) - 86400, cli2->tree, fnum2);
1272         GET_INFO_BOTH(finfo2,pinfo2);
1273         COMPARE_WRITE_TIME_LESS(finfo2, finfo1);
1274
1275         /* make sure the 2 second delay from the first write are canceled */
1276         start = timeval_current();
1277         end = timeval_add(&start, 15 * sec, 0);
1278         while (!timeval_expired(&end)) {
1279
1280                 /* get the times after the first write */
1281                 GET_INFO_BOTH(finfo3,pinfo3);
1282
1283                 if (finfo3.basic_info.out.write_time > finfo2.basic_info.out.write_time) {
1284                         double diff = timeval_elapsed(&start);
1285                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
1286                                         "(1sec == %.2f) (wrong!)\n",
1287                                         diff, sec);
1288                         ret = false;
1289                         break;
1290                 }
1291                 msleep(2 * msec);
1292         }
1293
1294         GET_INFO_BOTH(finfo3,pinfo3);
1295         COMPARE_WRITE_TIME_EQUAL(finfo3, finfo2);
1296         if (finfo3.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1297                 torture_comment(tctx, "Server did not update write_time (correct)\n");
1298         }
1299
1300         /* sure any further write doesn't update the write time */
1301         start = timeval_current();
1302         end = timeval_add(&start, 15 * sec, 0);
1303         while (!timeval_expired(&end)) {
1304                 /* do a write */
1305                 torture_comment(tctx, "Do a write on the file handle\n");
1306                 written = smbcli_write(cli->tree, fnum1, 0, "x", 0, 1);
1307                 if (written != 1) {
1308                         torture_result(tctx, TORTURE_FAIL, __location__": written gave %d - should have been 1", (int)written);
1309                         ret = false;
1310                         goto done;
1311                 }
1312                 /* get the times after the write */
1313                 GET_INFO_BOTH(finfo4,pinfo4);
1314
1315                 if (finfo4.basic_info.out.write_time > finfo3.basic_info.out.write_time) {
1316                         double diff = timeval_elapsed(&start);
1317                         torture_comment(tctx, "Server updated write_time after %.2f seconds "
1318                                         "(1sec == %.2f) (wrong!)\n",
1319                                         diff, sec);
1320                         ret = false;
1321                         break;
1322                 }
1323                 msleep(2 * msec);
1324         }
1325
1326         GET_INFO_BOTH(finfo4,pinfo4);
1327         COMPARE_WRITE_TIME_EQUAL(finfo4, finfo3);
1328         if (finfo4.basic_info.out.write_time == finfo3.basic_info.out.write_time) {
1329                 torture_comment(tctx, "Server did not update write_time (correct)\n");
1330         }
1331
1332         /* sleep */
1333         msleep(5 * msec);
1334
1335         GET_INFO_BOTH(finfo5,pinfo5);
1336         COMPARE_WRITE_TIME_EQUAL(finfo5, finfo4);
1337
1338         /*
1339          * the close updates the write time to the time of the close
1340          * as the write time was set on the 2nd handle
1341          */
1342         torture_comment(tctx, "Close the file handle\n");
1343         smbcli_close(cli->tree, fnum1);
1344         fnum1 = -1;
1345
1346         GET_INFO_PATH(pinfo6);
1347         COMPARE_WRITE_TIME_GREATER(pinfo6, pinfo5);
1348
1349         if (pinfo6.basic_info.out.write_time > pinfo5.basic_info.out.write_time) {
1350                 torture_comment(tctx, "Server updated the write_time on close (correct)\n");
1351         }
1352
1353         /* keep the 2nd handle open and rerun tests */
1354         if (first) {
1355                 first = false;
1356                 goto again;
1357         }
1358
1359         /*
1360          * closing the 2nd handle will cause no write time update
1361          * as the write time was explicit set on this handle
1362          */
1363         torture_comment(tctx, "Close the 2nd file handle\n");
1364         smbcli_close(cli2->tree, fnum2);
1365         fnum2 = -1;
1366
1367         GET_INFO_PATH(pinfo7);
1368         COMPARE_WRITE_TIME_EQUAL(pinfo7, pinfo6);
1369
1370         if (pinfo7.basic_info.out.write_time == pinfo6.basic_info.out.write_time) {
1371                 torture_comment(tctx, "Server did not update the write_time on close (correct)\n");
1372         }
1373
1374  done:
1375         if (fnum1 != -1)
1376                 smbcli_close(cli->tree, fnum1);
1377         if (fnum2 != -1)
1378                 smbcli_close(cli2->tree, fnum2);
1379         smbcli_unlink(cli->tree, fname);
1380         smbcli_deltree(cli->tree, BASEDIR);
1381
1382         return ret;
1383 }
1384
1385
1386 /*
1387    testing of delayed update of write_time
1388 */
1389 struct torture_suite *torture_delay_write(void)
1390 {
1391         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "DELAYWRITE");
1392
1393         torture_suite_add_2smb_test(suite, "finfo update on close", test_finfo_after_write);
1394         torture_suite_add_1smb_test(suite, "delayed update of write time", test_delayed_write_update);
1395         torture_suite_add_2smb_test(suite, "delayed update of write time using 2 connections", test_delayed_write_update2);
1396         torture_suite_add_2smb_test(suite, "delayed update of write time 3", test_delayed_write_update3);
1397         torture_suite_add_2smb_test(suite, "delayed update of write time 4", test_delayed_write_update4);
1398         torture_suite_add_2smb_test(suite, "delayed update of write time 5", test_delayed_write_update5);
1399         torture_suite_add_2smb_test(suite, "delayed update of write time 6", test_delayed_write_update6);
1400
1401         return suite;
1402 }