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