source4/torture/basic/delete.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    delete on close testing
   5
   6    Copyright (C) Andrew Tridgell 2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "libcli/libcli.h"
  24 #include "torture/util.h"
  25 #include "system/filesys.h"
  26 #include "libcli/raw/raw_proto.h"
  27
  28 #include "torture/raw/proto.h"
  29 #include "torture/basic/proto.h"
  30
  31 static bool check_delete_on_close(struct torture_context *tctx,
  32                                                                   struct smbcli_state *cli, int fnum,
  33                                                                   const char *fname, bool expect_it,
  34                                                                   const char *where)
  35 {
  36         union smb_search_data data;
  37         NTSTATUS status;
  38
  39         time_t c_time, a_time, m_time;
  40         size_t size;
  41         uint16_t mode;
  42
  43         status = torture_single_search(cli, tctx,
  44                                        fname,
  45                                        RAW_SEARCH_TRANS2,
  46                                        RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,
  47                                        FILE_ATTRIBUTE_DIRECTORY,
  48                                        &data);
  49         torture_assert_ntstatus_ok(tctx, status,
  50                 talloc_asprintf(tctx, "single_search failed (%s)", where));
  51
  52         if (fnum != -1) {
  53                 union smb_fileinfo io;
  54                 int nlink = expect_it ? 0 : 1;
  55
  56                 io.all_info.level = RAW_FILEINFO_ALL_INFO;
  57                 io.all_info.in.file.fnum = fnum;
  58
  59                 status = smb_raw_fileinfo(cli->tree, tctx, &io);
  60                 torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx,
  61                                         "qfileinfo failed (%s)", where));
  62
  63                 torture_assert(tctx, expect_it == io.all_info.out.delete_pending,
  64                         talloc_asprintf(tctx,
  65                         "%s - Expected del_on_close flag %d, qfileinfo/all_info gave %d",
  66                                where, expect_it, io.all_info.out.delete_pending));
  67
  68                 torture_assert(tctx, nlink == io.all_info.out.nlink,
  69                         talloc_asprintf(tctx,
  70                                 "%s - Expected nlink %d, qfileinfo/all_info gave %d",
  71                                where, nlink, io.all_info.out.nlink));
  72
  73                 io.standard_info.level = RAW_FILEINFO_STANDARD_INFO;
  74                 io.standard_info.in.file.fnum = fnum;
  75
  76                 status = smb_raw_fileinfo(cli->tree, tctx, &io);
  77                 torture_assert_ntstatus_ok(tctx, status, talloc_asprintf(tctx, "qpathinfo failed (%s)", where));
  78
  79                 torture_assert(tctx, expect_it == io.standard_info.out.delete_pending,
  80                         talloc_asprintf(tctx, "%s - Expected del_on_close flag %d, qfileinfo/standard_info gave %d\n",
  81                                where, expect_it, io.standard_info.out.delete_pending));
  82
  83                 torture_assert(tctx, nlink == io.standard_info.out.nlink,
  84                         talloc_asprintf(tctx, "%s - Expected nlink %d, qfileinfo/standard_info gave %d",
  85                                where, nlink, io.all_info.out.nlink));
  86         }
  87
  88         status = smbcli_qpathinfo(cli->tree, fname,
  89                                   &c_time, &a_time, &m_time,
  90                                   &size, &mode);
  91
  92         if (expect_it) {
  93                 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_DELETE_PENDING,
  94                         "qpathinfo did not give correct error code");
  95         } else {
  96                 torture_assert_ntstatus_ok(tctx, status,
  97                         talloc_asprintf(tctx, "qpathinfo failed (%s)", where));
  98         }
  99
 100         return true;
 101 }
 102
 103 #define CHECK_STATUS(_cli, _expected) \
 104         torture_assert_ntstatus_equal(tctx, _cli->tree->session->transport->error.e.nt_status, _expected, \
 105                  "Incorrect status")
 106
 107 static const char *fname = "\\delete.file";
 108 static const char *fname_new = "\\delete.new";
 109 static const char *dname = "\\delete.dir";
 110
 111 static void del_clean_area(struct smbcli_state *cli1, struct smbcli_state *cli2)
 112 {
 113         smb_raw_exit(cli1->session);
 114         smb_raw_exit(cli2->session);
 115
 116         smbcli_deltree(cli1->tree, dname);
 117         smbcli_setatr(cli1->tree, fname, 0, 0);
 118         smbcli_unlink(cli1->tree, fname);
 119         smbcli_setatr(cli1->tree, fname_new, 0, 0);
 120         smbcli_unlink(cli1->tree, fname_new);
 121 }
 122
 123 /* Test 1 - this should delete the file on close. */
 124
 125 static bool deltest1(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 126 {
 127         int fnum1 = -1;
 128
 129         del_clean_area(cli1, cli2);
 130
 131         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 132                                       SEC_RIGHTS_FILE_ALL,
 133                                       FILE_ATTRIBUTE_NORMAL,
 134                                       NTCREATEX_SHARE_ACCESS_DELETE, NTCREATEX_DISP_OVERWRITE_IF,
 135                                       NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
 136
 137         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
 138                        fname, smbcli_errstr(cli1->tree)));
 139
 140         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 141                 talloc_asprintf(tctx, "close failed (%s)", smbcli_errstr(cli1->tree)));
 142
 143         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 144         torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail)",
 145                        fname));
 146
 147         return true;
 148 }
 149
 150 /* Test 2 - this should delete the file on close. */
 151 static bool deltest2(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 152 {
 153         int fnum1 = -1;
 154
 155         del_clean_area(cli1, cli2);
 156
 157         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 158                                       SEC_RIGHTS_FILE_ALL,
 159                                       FILE_ATTRIBUTE_NORMAL, NTCREATEX_SHARE_ACCESS_NONE,
 160                                       NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
 161
 162         torture_assert(tctx, fnum1 != -1,
 163                 talloc_asprintf(tctx, "open of %s failed (%s)",
 164                        fname, smbcli_errstr(cli1->tree)));
 165
 166         torture_assert_ntstatus_ok(tctx, smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
 167                 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
 168                        smbcli_errstr(cli1->tree)));
 169
 170         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 171                 talloc_asprintf(tctx, "close failed (%s)",
 172                        smbcli_errstr(cli1->tree)));
 173
 174         fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
 175         if (fnum1 != -1) {
 176                 printf("(%s) open of %s succeeded should have been deleted on close !\n",
 177                        __location__, fname);
 178                 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
 179                         printf("(%s) close failed (%s)\n",
 180                                __location__, smbcli_errstr(cli1->tree));
 181                         return false;
 182                 }
 183                 smbcli_unlink(cli1->tree, fname);
 184         }
 185         return true;
 186 }
 187
 188 /* Test 3 - ... */
 189 static bool deltest3(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 190 {
 191         int fnum1 = -1;
 192         int fnum2 = -1;
 193
 194         del_clean_area(cli1, cli2);
 195
 196         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 197                                       SEC_RIGHTS_FILE_ALL,
 198                                       FILE_ATTRIBUTE_NORMAL,
 199                                       NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
 200                                       NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
 201
 202         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 203                         fname, smbcli_errstr(cli1->tree)));
 204
 205         /* This should fail with a sharing violation - open for delete is only compatible
 206            with SHARE_DELETE. */
 207
 208         fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
 209                                       SEC_RIGHTS_FILE_READ,
 210                                       FILE_ATTRIBUTE_NORMAL,
 211                                       NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
 212                                       NTCREATEX_DISP_OPEN, 0, 0);
 213
 214         torture_assert(tctx, fnum2 == -1,
 215                 talloc_asprintf(tctx, "open  - 2 of %s succeeded - should have failed.",
 216                        fname));
 217
 218         /* This should succeed. */
 219
 220         fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
 221                                       SEC_RIGHTS_FILE_READ,
 222                                       FILE_ATTRIBUTE_NORMAL,
 223                                       NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
 224                                       NTCREATEX_DISP_OPEN, 0, 0);
 225
 226         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open  - 2 of %s failed (%s)",
 227                        fname, smbcli_errstr(cli1->tree)));
 228
 229         torture_assert_ntstatus_ok(tctx,
 230                                                            smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
 231                                                            talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
 232                                                    smbcli_errstr(cli1->tree)));
 233
 234         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 235                 talloc_asprintf(tctx, "close 1 failed (%s)",
 236                        smbcli_errstr(cli1->tree)));
 237
 238         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum2),
 239                 talloc_asprintf(tctx, "close 2 failed (%s)",
 240                        smbcli_errstr(cli1->tree)));
 241
 242         /* This should fail - file should no longer be there. */
 243
 244         fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
 245         if (fnum1 != -1) {
 246                 printf("(%s) open of %s succeeded should have been deleted on close !\n",
 247                        __location__, fname);
 248                 if (NT_STATUS_IS_ERR(smbcli_close(cli1->tree, fnum1))) {
 249                         printf("(%s) close failed (%s)\n",
 250                                __location__, smbcli_errstr(cli1->tree));
 251                 }
 252                 smbcli_unlink(cli1->tree, fname);
 253                 return false;
 254         }
 255         return true;
 256 }
 257
 258 /* Test 4 ... */
 259 static bool deltest4(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 260 {
 261         int fnum1 = -1;
 262         int fnum2 = -1;
 263         bool correct = true;
 264
 265         del_clean_area(cli1, cli2);
 266
 267         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 268                                       SEC_FILE_READ_DATA  |
 269                                       SEC_FILE_WRITE_DATA |
 270                                       SEC_STD_DELETE,
 271                                       FILE_ATTRIBUTE_NORMAL,
 272                                       NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE,
 273                                       NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
 274
 275         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
 276                        fname, smbcli_errstr(cli1->tree)));
 277
 278         /* This should succeed. */
 279         fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
 280                                       SEC_RIGHTS_FILE_READ,
 281                                       FILE_ATTRIBUTE_NORMAL,
 282                                       NTCREATEX_SHARE_ACCESS_READ  |
 283                                       NTCREATEX_SHARE_ACCESS_WRITE |
 284                                       NTCREATEX_SHARE_ACCESS_DELETE,
 285                                       NTCREATEX_DISP_OPEN, 0, 0);
 286         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open  - 2 of %s failed (%s)",
 287                        fname, smbcli_errstr(cli1->tree)));
 288
 289         torture_assert_ntstatus_ok(tctx,
 290                                         smbcli_close(cli1->tree, fnum2),
 291                                         talloc_asprintf(tctx, "close - 1 failed (%s)",
 292                                         smbcli_errstr(cli1->tree)));
 293
 294         torture_assert_ntstatus_ok(tctx,
 295                                 smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
 296                                 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
 297                         smbcli_errstr(cli1->tree)));
 298
 299         /* This should fail - no more opens once delete on close set. */
 300         fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
 301                                       SEC_RIGHTS_FILE_READ,
 302                                       FILE_ATTRIBUTE_NORMAL,
 303                                       NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
 304                                       NTCREATEX_DISP_OPEN, 0, 0);
 305         torture_assert(tctx, fnum2 == -1,
 306                  talloc_asprintf(tctx, "open  - 3 of %s succeeded ! Should have failed.",
 307                        fname ));
 308
 309         CHECK_STATUS(cli1, NT_STATUS_DELETE_PENDING);
 310
 311         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 312                  talloc_asprintf(tctx, "close - 2 failed (%s)",
 313                        smbcli_errstr(cli1->tree)));
 314
 315         return correct;
 316 }
 317
 318 /* Test 5 ... */
 319 static bool deltest5(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 320 {
 321         int fnum1 = -1;
 322
 323         del_clean_area(cli1, cli2);
 324
 325         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR|O_CREAT, DENY_NONE);
 326         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
 327                        fname, smbcli_errstr(cli1->tree)));
 328
 329         /* This should fail - only allowed on NT opens with DELETE access. */
 330
 331         torture_assert(tctx, !NT_STATUS_IS_OK(smbcli_nt_delete_on_close(cli1->tree, fnum1, true)),
 332                  "setting delete_on_close on OpenX file succeeded - should fail !");
 333
 334         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 335                 talloc_asprintf(tctx, "close - 2 failed (%s)", smbcli_errstr(cli1->tree)));
 336
 337         return true;
 338 }
 339
 340 /* Test 6 ... */
 341 static bool deltest6(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 342 {
 343         int fnum1 = -1;
 344
 345         del_clean_area(cli1, cli2);
 346
 347         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 348                                    SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
 349                                    FILE_ATTRIBUTE_NORMAL,
 350                                    NTCREATEX_SHARE_ACCESS_READ  |
 351                                    NTCREATEX_SHARE_ACCESS_WRITE |
 352                                    NTCREATEX_SHARE_ACCESS_DELETE,
 353                                    NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
 354
 355         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
 356                        fname, smbcli_errstr(cli1->tree)));
 357
 358         /* This should fail - only allowed on NT opens with DELETE access. */
 359
 360         torture_assert(tctx,
 361                 !NT_STATUS_IS_OK(smbcli_nt_delete_on_close(cli1->tree, fnum1, true)),
 362                 "setting delete_on_close on file with no delete access succeeded - should fail !");
 363
 364         torture_assert_ntstatus_ok(tctx,
 365                                                            smbcli_close(cli1->tree, fnum1),
 366                 talloc_asprintf(tctx, "close - 2 failed (%s)",
 367                        smbcli_errstr(cli1->tree)));
 368
 369         return true;
 370 }
 371
 372 /* Test 7 ... */
 373 static bool deltest7(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 374 {
 375         int fnum1 = -1;
 376         bool correct = true;
 377
 378         del_clean_area(cli1, cli2);
 379
 380         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 381                                       SEC_FILE_READ_DATA  |
 382                                       SEC_FILE_WRITE_DATA |
 383                                       SEC_STD_DELETE,
 384                                       FILE_ATTRIBUTE_NORMAL, 0,
 385                                       NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
 386
 387         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
 388                        fname, smbcli_errstr(cli1->tree)));
 389
 390         torture_assert_ntstatus_ok(tctx, smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
 391                         "setting delete_on_close on file failed !");
 392
 393         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
 394
 395         torture_assert_ntstatus_ok(tctx,
 396                                         smbcli_nt_delete_on_close(cli1->tree, fnum1, false),
 397                                         "unsetting delete_on_close on file failed !");
 398
 399         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
 400
 401         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 402                 talloc_asprintf(tctx, "close - 2 failed (%s)", smbcli_errstr(cli1->tree)));
 403
 404         /* This next open should succeed - we reset the flag. */
 405
 406         fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
 407         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
 408                        fname, smbcli_errstr(cli1->tree)));
 409
 410         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 411                                                        talloc_asprintf(tctx, "close - 2 failed (%s)",
 412                                                    smbcli_errstr(cli1->tree)));
 413
 414         return correct;
 415 }
 416
 417 /* Test 8 ... */
 418 static bool deltest8(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 419 {
 420         int fnum1 = -1;
 421         int fnum2 = -1;
 422         bool correct = true;
 423
 424         del_clean_area(cli1, cli2);
 425
 426         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 427                                       SEC_FILE_READ_DATA|
 428                                       SEC_FILE_WRITE_DATA|
 429                                       SEC_STD_DELETE,
 430                                       FILE_ATTRIBUTE_NORMAL,
 431                                       NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
 432                                       NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
 433
 434         torture_assert(tctx, fnum1 != -1,
 435                 talloc_asprintf(tctx, "open of %s failed (%s)",
 436                        fname, smbcli_errstr(cli1->tree)));
 437
 438         fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
 439                                       SEC_FILE_READ_DATA|
 440                                       SEC_FILE_WRITE_DATA|
 441                                       SEC_STD_DELETE,
 442                                       FILE_ATTRIBUTE_NORMAL,
 443                                       NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
 444                                       NTCREATEX_DISP_OPEN, 0, 0);
 445
 446         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
 447                        fname, smbcli_errstr(cli1->tree)));
 448
 449         torture_assert_ntstatus_ok(tctx,
 450                                         smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
 451                 "setting delete_on_close on file failed !");
 452
 453         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
 454         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, true, __location__);
 455
 456         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 457                 talloc_asprintf(tctx, "close - 1 failed (%s)",
 458                        smbcli_errstr(cli1->tree)));
 459
 460         correct &= check_delete_on_close(tctx, cli1, -1, fname, true, __location__);
 461         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, true, __location__);
 462
 463         torture_assert_ntstatus_ok(tctx, smbcli_close(cli2->tree, fnum2),
 464                 talloc_asprintf(tctx, "close - 2 failed (%s)", smbcli_errstr(cli2->tree)));
 465
 466         /* This should fail.. */
 467         fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
 468         torture_assert(tctx, fnum1 == -1,
 469                 talloc_asprintf(tctx, "open of %s succeeded should have been deleted on close !\n", fname));
 470
 471         return correct;
 472 }
 473
 474 /* Test 9 ... */
 475 static bool deltest9(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 476 {
 477         int fnum1 = -1;
 478
 479         del_clean_area(cli1, cli2);
 480
 481         /* This should fail - we need to set DELETE_ACCESS. */
 482         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 483                                       SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA,
 484                                       FILE_ATTRIBUTE_NORMAL,
 485                                       NTCREATEX_SHARE_ACCESS_NONE,
 486                                       NTCREATEX_DISP_OVERWRITE_IF,
 487                                       NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
 488
 489         torture_assert(tctx, fnum1 == -1,
 490                                    talloc_asprintf(tctx, "open of %s succeeded should have failed!",
 491                        fname));
 492
 493         return true;
 494 }
 495
 496 /* Test 10 ... */
 497 static bool deltest10(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 498 {
 499         int fnum1 = -1;
 500
 501         del_clean_area(cli1, cli2);
 502
 503         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 504                                       SEC_FILE_READ_DATA|
 505                                       SEC_FILE_WRITE_DATA|
 506                                       SEC_STD_DELETE,
 507                                       FILE_ATTRIBUTE_NORMAL,
 508                                       NTCREATEX_SHARE_ACCESS_NONE,
 509                                       NTCREATEX_DISP_OVERWRITE_IF,
 510                                       NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
 511         torture_assert(tctx, fnum1 != -1,
 512                 talloc_asprintf(tctx, "open of %s failed (%s)",
 513                        fname, smbcli_errstr(cli1->tree)));
 514
 515         /* This should delete the file. */
 516         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 517                 talloc_asprintf(tctx, "close failed (%s)",
 518                        smbcli_errstr(cli1->tree)));
 519
 520         /* This should fail.. */
 521         fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
 522         torture_assert(tctx, fnum1 == -1,
 523                                 talloc_asprintf(tctx, "open of %s succeeded should have been deleted on close !",
 524                        fname));
 525         return true;
 526 }
 527
 528 /* Test 11 ... */
 529 static bool deltest11(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 530 {
 531         int fnum1 = -1;
 532         NTSTATUS status;
 533
 534         del_clean_area(cli1, cli2);
 535
 536         /* test 11 - does having read only attribute still allow delete on close. */
 537
 538         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 539                                       SEC_RIGHTS_FILE_ALL,
 540                                       FILE_ATTRIBUTE_READONLY,
 541                                       NTCREATEX_SHARE_ACCESS_NONE,
 542                                       NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
 543
 544         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
 545                        fname, smbcli_errstr(cli1->tree)));
 546
 547         status = smbcli_nt_delete_on_close(cli1->tree, fnum1, true);
 548
 549         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_CANNOT_DELETE,
 550                 talloc_asprintf(tctx, "setting delete_on_close should fail with NT_STATUS_CANNOT_DELETE. Got %s instead)", smbcli_errstr(cli1->tree)));
 551
 552         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 553                 talloc_asprintf(tctx, "close failed (%s)",
 554                        smbcli_errstr(cli1->tree)));
 555
 556         return true;
 557 }
 558
 559 /* Test 12 ... */
 560 static bool deltest12(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 561 {
 562         int fnum1 = -1;
 563         NTSTATUS status;
 564
 565         del_clean_area(cli1, cli2);
 566
 567         /* test 12 - does having read only attribute still allow delete on
 568          * close at time of open. */
 569
 570         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 571                                       SEC_RIGHTS_FILE_ALL,
 572                                       FILE_ATTRIBUTE_READONLY,
 573                                       NTCREATEX_SHARE_ACCESS_DELETE,
 574                                       NTCREATEX_DISP_OVERWRITE_IF,
 575                                       NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
 576
 577         torture_assert(tctx, fnum1 == -1,
 578                  talloc_asprintf(tctx, "open of %s succeeded. Should fail with "
 579                        "NT_STATUS_CANNOT_DELETE.\n", fname));
 580
 581         status = smbcli_nt_error(cli1->tree);
 582         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_CANNOT_DELETE,
 583                          talloc_asprintf(tctx, "setting delete_on_close on open should "
 584                                "fail with NT_STATUS_CANNOT_DELETE. Got %s "
 585                                "instead)",
 586                                smbcli_errstr(cli1->tree)));
 587
 588         return true;
 589 }
 590
 591 /* Test 13 ... */
 592 static bool deltest13(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 593 {
 594         int fnum1 = -1;
 595         int fnum2 = -1;
 596         bool correct = true;
 597
 598         del_clean_area(cli1, cli2);
 599
 600         /* Test 13: Does resetting the delete on close flag affect a second
 601          * fd? */
 602
 603         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 604                                       SEC_FILE_READ_DATA|
 605                                       SEC_FILE_WRITE_DATA|
 606                                       SEC_STD_DELETE,
 607                                       FILE_ATTRIBUTE_NORMAL,
 608                                       NTCREATEX_SHARE_ACCESS_READ|
 609                                       NTCREATEX_SHARE_ACCESS_WRITE|
 610                                       NTCREATEX_SHARE_ACCESS_DELETE,
 611                                       NTCREATEX_DISP_OVERWRITE_IF,
 612                                       0, 0);
 613
 614         torture_assert(tctx, fnum1 != -1,
 615                 talloc_asprintf(tctx, "open of %s failed (%s)",
 616                        fname, smbcli_errstr(cli1->tree)));
 617
 618         fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
 619                                       SEC_FILE_READ_DATA|
 620                                       SEC_FILE_WRITE_DATA|
 621                                       SEC_STD_DELETE,
 622                                       FILE_ATTRIBUTE_NORMAL,
 623                                       NTCREATEX_SHARE_ACCESS_READ|
 624                                       NTCREATEX_SHARE_ACCESS_WRITE|
 625                                       NTCREATEX_SHARE_ACCESS_DELETE,
 626                                       NTCREATEX_DISP_OPEN, 0, 0);
 627
 628         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx,
 629                                 "open of %s failed (%s)",
 630                        fname, smbcli_errstr(cli2->tree)));
 631
 632         torture_assert_ntstatus_ok(tctx,
 633                                                 smbcli_nt_delete_on_close(cli1->tree, fnum1,
 634                                                        true),
 635                  "setting delete_on_close on file failed !");
 636
 637         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
 638         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, true, __location__);
 639
 640         torture_assert_ntstatus_ok(tctx, smbcli_nt_delete_on_close(cli2->tree, fnum2,
 641                                                        false),
 642                  "setting delete_on_close on file failed !");
 643
 644         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
 645         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
 646
 647         torture_assert_ntstatus_ok(tctx, smbcli_close(cli1->tree, fnum1),
 648                 talloc_asprintf(tctx, "close - 1 failed (%s)",
 649                        smbcli_errstr(cli1->tree)));
 650
 651         torture_assert_ntstatus_ok(tctx, smbcli_close(cli2->tree, fnum2),
 652                         talloc_asprintf(tctx, "close - 2 failed (%s)",
 653                        smbcli_errstr(cli2->tree)));
 654
 655         fnum1 = smbcli_open(cli1->tree, fname, O_RDONLY, DENY_NONE);
 656
 657         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed!",
 658                        fname));
 659
 660         smbcli_close(cli1->tree, fnum1);
 661
 662         return correct;
 663 }
 664
 665 /* Test 14 ... */
 666 static bool deltest14(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 667 {
 668         int dnum1 = -1;
 669         bool correct = true;
 670
 671         del_clean_area(cli1, cli2);
 672
 673         /* Test 14 -- directory */
 674
 675         dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
 676                                       SEC_FILE_READ_DATA|
 677                                       SEC_FILE_WRITE_DATA|
 678                                       SEC_STD_DELETE,
 679                                       FILE_ATTRIBUTE_DIRECTORY,
 680                                       NTCREATEX_SHARE_ACCESS_READ|
 681                                       NTCREATEX_SHARE_ACCESS_WRITE|
 682                                       NTCREATEX_SHARE_ACCESS_DELETE,
 683                                       NTCREATEX_DISP_CREATE, 0, 0);
 684         torture_assert(tctx, dnum1 != -1, talloc_asprintf(tctx, "open of %s failed: %s!",
 685                        dname, smbcli_errstr(cli1->tree)));
 686
 687         correct &= check_delete_on_close(tctx, cli1, dnum1, dname, false, __location__);
 688         torture_assert_ntstatus_ok(tctx, smbcli_nt_delete_on_close(cli1->tree, dnum1, true),
 689                         "setting delete_on_close on file failed !");
 690         correct &= check_delete_on_close(tctx, cli1, dnum1, dname, true, __location__);
 691         smbcli_close(cli1->tree, dnum1);
 692
 693         /* Now it should be gone... */
 694
 695         dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
 696                                       SEC_FILE_READ_DATA|
 697                                       SEC_FILE_WRITE_DATA|
 698                                       SEC_STD_DELETE,
 699                                       FILE_ATTRIBUTE_DIRECTORY,
 700                                       NTCREATEX_SHARE_ACCESS_READ|
 701                                       NTCREATEX_SHARE_ACCESS_WRITE|
 702                                       NTCREATEX_SHARE_ACCESS_DELETE,
 703                                       NTCREATEX_DISP_OPEN, 0, 0);
 704         torture_assert(tctx, dnum1 == -1, "setting delete_on_close on file succeeded !");
 705
 706         return correct;
 707 }
 708
 709 /* Test 15 ... */
 710 static bool deltest15(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 711 {
 712         int fnum1 = -1;
 713         bool correct = true;
 714         int fnum2 = -1;
 715         NTSTATUS status;
 716
 717         del_clean_area(cli1, cli2);
 718
 719         /* Test 15: delete on close under rename */
 720
 721         smbcli_setatr(cli1->tree, fname, 0, 0);
 722         smbcli_unlink(cli1->tree, fname);
 723         smbcli_unlink(cli1->tree, fname_new);
 724
 725         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 726                                       SEC_FILE_READ_DATA,
 727                                       FILE_ATTRIBUTE_NORMAL,
 728                                       NTCREATEX_SHARE_ACCESS_READ|
 729                                       NTCREATEX_SHARE_ACCESS_WRITE|
 730                                       NTCREATEX_SHARE_ACCESS_DELETE,
 731                                       NTCREATEX_DISP_OVERWRITE_IF,
 732                                       0, 0);
 733
 734         torture_assert(tctx, fnum1 != -1,
 735                 talloc_asprintf(tctx, "open - 1 of %s failed (%s)", fname, smbcli_errstr(cli1->tree)));
 736
 737         status = smbcli_rename(cli2->tree, fname, fname_new);
 738
 739         torture_assert_ntstatus_ok(tctx, status, "renaming failed!");
 740
 741         fnum2 = smbcli_nt_create_full(cli2->tree, fname_new, 0,
 742                                       SEC_GENERIC_ALL,
 743                                       FILE_ATTRIBUTE_NORMAL,
 744                                       NTCREATEX_SHARE_ACCESS_READ|
 745                                       NTCREATEX_SHARE_ACCESS_WRITE|
 746                                       NTCREATEX_SHARE_ACCESS_DELETE,
 747                                       NTCREATEX_DISP_OVERWRITE_IF,
 748                                       0, 0);
 749
 750         torture_assert(tctx, fnum2 != -1,
 751                 talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 752                        fname_new, smbcli_errstr(cli1->tree)));
 753
 754         status = smbcli_nt_delete_on_close(cli2->tree, fnum2, true);
 755
 756         torture_assert_ntstatus_ok(tctx, status,
 757                 "setting delete_on_close on file failed !");
 758
 759         smbcli_close(cli2->tree, fnum2);
 760
 761         /* The file should be around under the new name, there's a second
 762          * handle open */
 763
 764         correct &= check_delete_on_close(tctx, cli1, fnum1, fname_new, true, __location__);
 765
 766         fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
 767                                       SEC_GENERIC_ALL,
 768                                       FILE_ATTRIBUTE_NORMAL,
 769                                       NTCREATEX_SHARE_ACCESS_READ|
 770                                       NTCREATEX_SHARE_ACCESS_WRITE|
 771                                       NTCREATEX_SHARE_ACCESS_DELETE,
 772                                       NTCREATEX_DISP_OVERWRITE_IF,
 773                                       0, 0);
 774
 775         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 776                        fname, smbcli_errstr(cli1->tree)));
 777
 778         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
 779
 780         smbcli_close(cli2->tree, fnum2);
 781         smbcli_close(cli1->tree, fnum1);
 782
 783         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 784                                       SEC_FILE_READ_EA,
 785                                       FILE_ATTRIBUTE_NORMAL,
 786                                       NTCREATEX_SHARE_ACCESS_READ|
 787                                       NTCREATEX_SHARE_ACCESS_WRITE|
 788                                       NTCREATEX_SHARE_ACCESS_DELETE,
 789                                       NTCREATEX_DISP_OPEN,
 790                                       0, 0);
 791
 792         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 793                        fname, smbcli_errstr(cli1->tree)));
 794
 795         smbcli_close(cli1->tree, fnum1);
 796
 797         fnum1 = smbcli_nt_create_full(cli1->tree, fname_new, 0,
 798                                       SEC_FILE_READ_EA,
 799                                       FILE_ATTRIBUTE_NORMAL,
 800                                       NTCREATEX_SHARE_ACCESS_READ|
 801                                       NTCREATEX_SHARE_ACCESS_WRITE|
 802                                       NTCREATEX_SHARE_ACCESS_DELETE,
 803                                       NTCREATEX_DISP_OPEN,
 804                                       0, 0);
 805
 806         torture_assert(tctx, fnum1 == -1,
 807                 "smbcli_open succeeded, should have "
 808                        "failed");
 809
 810         return correct;
 811 }
 812
 813 /* Test 16 ... */
 814 static bool deltest16(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 815 {
 816         int fnum1 = -1;
 817         int fnum2 = -1;
 818         bool correct = true;
 819
 820         del_clean_area(cli1, cli2);
 821
 822         /* Test 16. */
 823
 824         /* Ensure the file doesn't already exist. */
 825         smbcli_close(cli1->tree, fnum1);
 826         smbcli_close(cli1->tree, fnum2);
 827         smbcli_setatr(cli1->tree, fname, 0, 0);
 828         smbcli_unlink(cli1->tree, fname);
 829
 830         /* Firstly create with all access, but delete on close. */
 831         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 832                                       SEC_RIGHTS_FILE_ALL,
 833                                       FILE_ATTRIBUTE_NORMAL,
 834                                       NTCREATEX_SHARE_ACCESS_READ|
 835                                       NTCREATEX_SHARE_ACCESS_WRITE|
 836                                       NTCREATEX_SHARE_ACCESS_DELETE,
 837                                       NTCREATEX_DISP_CREATE,
 838                                       NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
 839
 840         torture_assert (tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)", fname, smbcli_errstr(cli1->tree)));
 841
 842         /* The delete on close bit is *not* reported as being set. */
 843         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
 844
 845         /* The delete on close bit is *not* reported as being set. */
 846         correct &= check_delete_on_close(tctx, cli1, -1, fname, false, __location__);
 847         correct &= check_delete_on_close(tctx, cli2, -1, fname, false, __location__);
 848
 849         /* Now try opening again for read-only. */
 850         fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
 851                                       SEC_RIGHTS_FILE_READ,
 852                                       FILE_ATTRIBUTE_NORMAL,
 853                                       NTCREATEX_SHARE_ACCESS_READ|
 854                                       NTCREATEX_SHARE_ACCESS_WRITE|
 855                                       NTCREATEX_SHARE_ACCESS_DELETE,
 856                                       NTCREATEX_DISP_OPEN,
 857                                       0, 0);
 858
 859         /* Should work. */
 860         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 861                       fname, smbcli_errstr(cli1->tree)));
 862
 863         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
 864         correct &= check_delete_on_close(tctx, cli1, -1, fname, false, __location__);
 865         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
 866         correct &= check_delete_on_close(tctx, cli2, -1, fname, false, __location__);
 867
 868         smbcli_close(cli1->tree, fnum1);
 869
 870         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, true, __location__);
 871         correct &= check_delete_on_close(tctx, cli2, -1, fname, true, __location__);
 872
 873         smbcli_close(cli2->tree, fnum2);
 874
 875         /* And the file should be deleted ! */
 876         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 877         torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail)",
 878                        fname));
 879
 880         return correct;
 881 }
 882
 883 /* Test 17 ... */
 884 static bool deltest17(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 885 {
 886         int fnum1 = -1;
 887         int fnum2 = -1;
 888         bool correct = true;
 889
 890         del_clean_area(cli1, cli2);
 891
 892         /* Test 17. */
 893
 894         /* Ensure the file doesn't already exist. */
 895         smbcli_close(cli1->tree, fnum1);
 896         smbcli_close(cli1->tree, fnum2);
 897         smbcli_setatr(cli1->tree, fname, 0, 0);
 898         smbcli_unlink(cli1->tree, fname);
 899
 900         /* Firstly open and create with all access */
 901         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 902                                       SEC_RIGHTS_FILE_ALL,
 903                                       FILE_ATTRIBUTE_NORMAL,
 904                                       NTCREATEX_SHARE_ACCESS_READ|
 905                                       NTCREATEX_SHARE_ACCESS_WRITE|
 906                                       NTCREATEX_SHARE_ACCESS_DELETE,
 907                                       NTCREATEX_DISP_CREATE,
 908                                       0, 0);
 909         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 910                        fname, smbcli_errstr(cli1->tree)));
 911
 912         /* And close - just to create the file. */
 913         smbcli_close(cli1->tree, fnum1);
 914
 915         /* Next open with all access, but add delete on close. */
 916         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
 917                                       SEC_RIGHTS_FILE_ALL,
 918                                       FILE_ATTRIBUTE_NORMAL,
 919                                       NTCREATEX_SHARE_ACCESS_READ|
 920                                       NTCREATEX_SHARE_ACCESS_WRITE|
 921                                       NTCREATEX_SHARE_ACCESS_DELETE,
 922                                       NTCREATEX_DISP_OPEN,
 923                                       NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
 924
 925         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 926                        fname, smbcli_errstr(cli1->tree)));
 927
 928         /* The delete on close bit is *not* reported as being set. */
 929         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
 930
 931         /* Now try opening again for read-only. */
 932         fnum2 = smbcli_nt_create_full(cli1->tree, fname, 0,
 933                                       SEC_RIGHTS_FILE_READ|
 934                                       SEC_STD_DELETE,
 935                                       FILE_ATTRIBUTE_NORMAL,
 936                                       NTCREATEX_SHARE_ACCESS_READ|
 937                                       NTCREATEX_SHARE_ACCESS_WRITE|
 938                                       NTCREATEX_SHARE_ACCESS_DELETE,
 939                                       NTCREATEX_DISP_OPEN,
 940                                       0, 0);
 941
 942         /* Should work. */
 943         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 944                        fname, smbcli_errstr(cli1->tree)));
 945
 946         /* still not reported as being set on either */
 947         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
 948         correct &= check_delete_on_close(tctx, cli1, fnum2, fname, false, __location__);
 949
 950         smbcli_close(cli1->tree, fnum1);
 951
 952         /* After the first close, the files has the delete on close bit set. */
 953         correct &= check_delete_on_close(tctx, cli1, fnum2, fname, true, __location__);
 954
 955         smbcli_close(cli1->tree, fnum2);
 956
 957         /* Make sure the file has been deleted */
 958         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
 959         torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s failed (should succeed) - %s",
 960                        fname, smbcli_errstr(cli1->tree)));
 961
 962         CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
 963
 964         return correct;
 965 }
 966
 967 /* Test 18 ... */
 968 static bool deltest18(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 969 {
 970         int fnum1 = -1;
 971         int fnum2 = -1;
 972         bool correct = true;
 973
 974         del_clean_area(cli1, cli2);
 975
 976         /* Test 18. With directories. */
 977
 978         /* Ensure the file doesn't already exist. */
 979         smbcli_close(cli1->tree, fnum1);
 980         smbcli_close(cli1->tree, fnum2);
 981
 982         smbcli_deltree(cli1->tree, dname);
 983
 984         /* Firstly create with all access, but delete on close. */
 985         fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
 986                                       SEC_FILE_READ_DATA|
 987                                       SEC_FILE_WRITE_DATA|
 988                                       SEC_STD_DELETE,
 989                                       FILE_ATTRIBUTE_DIRECTORY,
 990                                       NTCREATEX_SHARE_ACCESS_READ|
 991                                       NTCREATEX_SHARE_ACCESS_WRITE|
 992                                       NTCREATEX_SHARE_ACCESS_DELETE,
 993                                       NTCREATEX_DISP_CREATE,
 994                                       NTCREATEX_OPTIONS_DIRECTORY|NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
 995
 996         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
 997                        dname, smbcli_errstr(cli1->tree)));
 998
 999         /*
1000          * The delete on close bit is *not* reported as being set.
1001          * Win2k3/win2k8 should pass this check, but WinXPsp2 reports delete on
1002          * close as being set.  This causes the subsequent create to fail with
1003          * NT_STATUS_DELETE_PENDING.
1004          */
1005         correct &= check_delete_on_close(tctx, cli1, fnum1, dname, false, __location__);
1006
1007         /* Now try opening again for read-only. */
1008         fnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
1009                                       SEC_RIGHTS_FILE_READ,
1010                                       FILE_ATTRIBUTE_DIRECTORY,
1011                                       NTCREATEX_SHARE_ACCESS_READ|
1012                                       NTCREATEX_SHARE_ACCESS_WRITE|
1013                                       NTCREATEX_SHARE_ACCESS_DELETE,
1014                                       NTCREATEX_DISP_OPEN,
1015                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1016
1017
1018         /* Should work. */
1019         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1020                        dname, smbcli_errstr(cli1->tree)));
1021
1022         correct &= check_delete_on_close(tctx, cli1, fnum1, dname, false, __location__);
1023         correct &= check_delete_on_close(tctx, cli1, fnum2, dname, false, __location__);
1024
1025         smbcli_close(cli1->tree, fnum1);
1026
1027         correct &= check_delete_on_close(tctx, cli1, fnum2, dname, true, __location__);
1028
1029         smbcli_close(cli1->tree, fnum2);
1030
1031         /* And the directory should be deleted ! */
1032         fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1033                                       SEC_RIGHTS_FILE_READ,
1034                                       FILE_ATTRIBUTE_DIRECTORY,
1035                                       NTCREATEX_SHARE_ACCESS_READ|
1036                                       NTCREATEX_SHARE_ACCESS_WRITE|
1037                                       NTCREATEX_SHARE_ACCESS_DELETE,
1038                                       NTCREATEX_DISP_OPEN,
1039                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1040         torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail)",
1041                        dname));
1042
1043         return correct;
1044 }
1045
1046 /* Test 19 ... */
1047 static bool deltest19(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1048 {
1049         int fnum1 = -1;
1050         int fnum2 = -1;
1051         bool correct = true;
1052
1053         del_clean_area(cli1, cli2);
1054
1055         /* Test 19. */
1056
1057         smbcli_deltree(cli1->tree, dname);
1058
1059         /* Firstly open and create with all access */
1060         fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1061                                       SEC_FILE_READ_DATA|
1062                                       SEC_FILE_WRITE_DATA|
1063                                       SEC_STD_DELETE,
1064                                       FILE_ATTRIBUTE_DIRECTORY,
1065                                       NTCREATEX_SHARE_ACCESS_READ|
1066                                       NTCREATEX_SHARE_ACCESS_WRITE|
1067                                       NTCREATEX_SHARE_ACCESS_DELETE,
1068                                       NTCREATEX_DISP_CREATE,
1069                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1070
1071         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1072                        dname, smbcli_errstr(cli1->tree)));
1073
1074         /* And close - just to create the directory. */
1075         smbcli_close(cli1->tree, fnum1);
1076
1077         /* Next open with all access, but add delete on close. */
1078         fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1079                                       SEC_FILE_READ_DATA|
1080                                       SEC_FILE_WRITE_DATA|
1081                                       SEC_STD_DELETE,
1082                                       FILE_ATTRIBUTE_DIRECTORY,
1083                                       NTCREATEX_SHARE_ACCESS_READ|
1084                                       NTCREATEX_SHARE_ACCESS_WRITE|
1085                                       NTCREATEX_SHARE_ACCESS_DELETE,
1086                                       NTCREATEX_DISP_OPEN,
1087                                       NTCREATEX_OPTIONS_DIRECTORY|NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1088
1089         torture_assert(tctx, fnum1 != -1,
1090                 talloc_asprintf(tctx, "open - 1 of %s failed (%s)", fname, smbcli_errstr(cli1->tree)));
1091
1092         /*
1093          * The delete on close bit is *not* reported as being set.
1094          * Win2k3/win2k8 should pass this check, but WinXPsp2 reports delete on
1095          * close as being set.  This causes the subsequent create to fail with
1096          * NT_STATUS_DELETE_PENDING.
1097          */
1098         correct &= check_delete_on_close(tctx, cli1, fnum1, dname, false, __location__);
1099
1100         /* Now try opening again for read-only. */
1101         fnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
1102                                       SEC_RIGHTS_FILE_READ,
1103                                       FILE_ATTRIBUTE_DIRECTORY,
1104                                       NTCREATEX_SHARE_ACCESS_READ|
1105                                       NTCREATEX_SHARE_ACCESS_WRITE|
1106                                       NTCREATEX_SHARE_ACCESS_DELETE,
1107                                       NTCREATEX_DISP_OPEN,
1108                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1109
1110         /* Should work. */
1111         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1112                        dname, smbcli_errstr(cli1->tree)));
1113
1114         smbcli_close(cli1->tree, fnum1);
1115
1116         correct &= check_delete_on_close(tctx, cli1, fnum2, dname, true, __location__);
1117
1118         smbcli_close(cli1->tree, fnum2);
1119
1120         /* See if the file is deleted - for a directory this seems to be true ! */
1121         fnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1122                                       SEC_RIGHTS_FILE_READ,
1123                                       FILE_ATTRIBUTE_DIRECTORY,
1124                                       NTCREATEX_SHARE_ACCESS_READ|
1125                                       NTCREATEX_SHARE_ACCESS_WRITE|
1126                                       NTCREATEX_SHARE_ACCESS_DELETE,
1127                                       NTCREATEX_DISP_OPEN,
1128                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1129
1130         CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1131
1132         torture_assert(tctx, fnum1 == -1,
1133                 talloc_asprintf(tctx, "open of %s succeeded (should fail)", dname));
1134
1135         return correct;
1136 }
1137
1138 /* Test 20 ... */
1139 static bool deltest20(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1140 {
1141         int fnum1 = -1;
1142         int dnum1 = -1;
1143         bool correct = true;
1144         NTSTATUS status;
1145
1146         del_clean_area(cli1, cli2);
1147
1148         /* Test 20 -- non-empty directory hardest to get right... */
1149
1150         if (torture_setting_bool(tctx, "samba3", false)) {
1151                 return true;
1152         }
1153
1154         smbcli_deltree(cli1->tree, dname);
1155
1156         dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1157                                       SEC_FILE_READ_DATA|
1158                                       SEC_FILE_WRITE_DATA|
1159                                       SEC_STD_DELETE,
1160                                       FILE_ATTRIBUTE_DIRECTORY,
1161                                       NTCREATEX_SHARE_ACCESS_READ|
1162                                       NTCREATEX_SHARE_ACCESS_WRITE|
1163                                       NTCREATEX_SHARE_ACCESS_DELETE,
1164                                       NTCREATEX_DISP_CREATE,
1165                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1166         torture_assert(tctx, dnum1 != -1, talloc_asprintf(tctx, "open of %s failed: %s!",
1167                        dname, smbcli_errstr(cli1->tree)));
1168
1169         correct &= check_delete_on_close(tctx, cli1, dnum1, dname, false, __location__);
1170         status = smbcli_nt_delete_on_close(cli1->tree, dnum1, true);
1171
1172         {
1173                 char *fullname;
1174                 asprintf(&fullname, "\\%s%s", dname, fname);
1175                 fnum1 = smbcli_open(cli1->tree, fullname, O_CREAT|O_RDWR,
1176                                     DENY_NONE);
1177                 torture_assert(tctx, fnum1 == -1,
1178                                 "smbcli_open succeeded, should have "
1179                                "failed with NT_STATUS_DELETE_PENDING"
1180                                );
1181
1182                 torture_assert_ntstatus_equal(tctx,
1183                                          smbcli_nt_error(cli1->tree),
1184                                      NT_STATUS_DELETE_PENDING,
1185                                         "smbcli_open failed");
1186         }
1187
1188         status = smbcli_nt_delete_on_close(cli1->tree, dnum1, false);
1189         torture_assert_ntstatus_ok(tctx, status,
1190                                         "setting delete_on_close on file failed !");
1191
1192         {
1193                 char *fullname;
1194                 asprintf(&fullname, "\\%s%s", dname, fname);
1195                 fnum1 = smbcli_open(cli1->tree, fullname, O_CREAT|O_RDWR,
1196                                     DENY_NONE);
1197                 torture_assert(tctx, fnum1 != -1,
1198                                 talloc_asprintf(tctx, "smbcli_open failed: %s\n",
1199                                smbcli_errstr(cli1->tree)));
1200                 smbcli_close(cli1->tree, fnum1);
1201         }
1202
1203         status = smbcli_nt_delete_on_close(cli1->tree, dnum1, true);
1204
1205         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_DIRECTORY_NOT_EMPTY,
1206                  "setting delete_on_close failed");
1207         smbcli_close(cli1->tree, dnum1);
1208
1209         return correct;
1210 }
1211
1212 /* Test 20a ... */
1213 static bool deltest20a(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1214 {
1215         int fnum1 = -1;
1216         int fnum2 = -1;
1217         bool correct = true;
1218
1219         del_clean_area(cli1, cli2);
1220
1221         /* Test 20a. */
1222
1223         /* Ensure the file doesn't already exist. */
1224         smbcli_close(cli1->tree, fnum1);
1225         smbcli_close(cli1->tree, fnum2);
1226         smbcli_setatr(cli1->tree, fname, 0, 0);
1227         smbcli_unlink(cli1->tree, fname);
1228
1229         /* Firstly open and create with all access */
1230         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1231                                       SEC_RIGHTS_FILE_ALL,
1232                                       FILE_ATTRIBUTE_NORMAL,
1233                                       NTCREATEX_SHARE_ACCESS_READ|
1234                                       NTCREATEX_SHARE_ACCESS_WRITE|
1235                                       NTCREATEX_SHARE_ACCESS_DELETE,
1236                                       NTCREATEX_DISP_CREATE,
1237                                       0, 0);
1238         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1239                        fname, smbcli_errstr(cli1->tree)));
1240
1241         /* Next open with all access, but add delete on close. */
1242         fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
1243                                       SEC_RIGHTS_FILE_ALL,
1244                                       FILE_ATTRIBUTE_NORMAL,
1245                                       NTCREATEX_SHARE_ACCESS_READ|
1246                                       NTCREATEX_SHARE_ACCESS_WRITE|
1247                                       NTCREATEX_SHARE_ACCESS_DELETE,
1248                                       NTCREATEX_DISP_OPEN,
1249                                       NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1250
1251         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1252                        fname, smbcli_errstr(cli2->tree)));
1253
1254         /* The delete on close bit is *not* reported as being set. */
1255         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1256         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
1257
1258         smbcli_close(cli1->tree, fnum1);
1259
1260         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
1261
1262         smbcli_close(cli2->tree, fnum2);
1263
1264         /* See if the file is deleted - should be.... */
1265         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1266         torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail) - %s",
1267                        fname, smbcli_errstr(cli1->tree)));
1268
1269         return correct;
1270 }
1271
1272 /* Test 20b ... */
1273 /* This is the delete semantics that the cifsfs client depends on when
1274  * trying to delete an open file on a Windows server. It
1275  * opens a file with initial delete on close set, renames it then closes
1276  * all open handles. The file goes away on Windows.
1277  */
1278
1279 static bool deltest20b(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1280 {
1281         int fnum1 = -1;
1282         int fnum2 = -1;
1283         bool correct = true;
1284
1285         del_clean_area(cli1, cli2);
1286
1287         /* Test 20b. */
1288
1289         /* Ensure the file doesn't already exist. */
1290         smbcli_close(cli1->tree, fnum1);
1291         smbcli_close(cli1->tree, fnum2);
1292         smbcli_setatr(cli1->tree, fname, 0, 0);
1293         smbcli_unlink(cli1->tree, fname);
1294         smbcli_setatr(cli1->tree, fname_new, 0, 0);
1295         smbcli_unlink(cli1->tree, fname_new);
1296
1297         /* Firstly open and create with all access */
1298         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1299                                       SEC_RIGHTS_FILE_ALL,
1300                                       FILE_ATTRIBUTE_NORMAL,
1301                                       NTCREATEX_SHARE_ACCESS_READ|
1302                                       NTCREATEX_SHARE_ACCESS_WRITE|
1303                                       NTCREATEX_SHARE_ACCESS_DELETE,
1304                                       NTCREATEX_DISP_CREATE,
1305                                       0, 0);
1306         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1307                        fname, smbcli_errstr(cli1->tree)));
1308
1309         /* And close - just to create the file. */
1310         smbcli_close(cli1->tree, fnum1);
1311
1312         /* Firstly open and create with all access */
1313         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1314                                       SEC_RIGHTS_FILE_ALL,
1315                                       FILE_ATTRIBUTE_NORMAL,
1316                                       NTCREATEX_SHARE_ACCESS_READ|
1317                                       NTCREATEX_SHARE_ACCESS_WRITE|
1318                                       NTCREATEX_SHARE_ACCESS_DELETE,
1319                                       NTCREATEX_DISP_OPEN,
1320                                       0, 0);
1321         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open - 1 of %s failed (%s)",
1322                        fname, smbcli_errstr(cli1->tree)));
1323
1324         /* Next open with all access, but add delete on close. */
1325         fnum2 = smbcli_nt_create_full(cli2->tree, fname, 0,
1326                                       SEC_RIGHTS_FILE_ALL,
1327                                       FILE_ATTRIBUTE_NORMAL,
1328                                       NTCREATEX_SHARE_ACCESS_READ|
1329                                       NTCREATEX_SHARE_ACCESS_WRITE|
1330                                       NTCREATEX_SHARE_ACCESS_DELETE,
1331                                       NTCREATEX_DISP_OPEN,
1332                                       NTCREATEX_OPTIONS_DELETE_ON_CLOSE, 0);
1333
1334         torture_assert(tctx, fnum2 != -1, talloc_asprintf(tctx, "open - 2 of %s failed (%s)",
1335                        fname, smbcli_errstr(cli2->tree)));
1336
1337         /* The delete on close bit is *not* reported as being set. */
1338         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, false, __location__);
1339         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
1340
1341         smbcli_close(cli1->tree, fnum1);
1342
1343         correct &= check_delete_on_close(tctx, cli2, fnum2, fname, false, __location__);
1344
1345         /* Rename the file by handle. */
1346
1347         {
1348                 union smb_setfileinfo sfinfo;
1349                 NTSTATUS status;
1350
1351                 memset(&sfinfo, '\0', sizeof(sfinfo));
1352                 sfinfo.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
1353                 sfinfo.generic.in.file.fnum = fnum2;
1354                 sfinfo.rename_information.in.root_fid  = 0;
1355                 /* Don't start the filename with '\\', we get NT_STATUS_NOT_SUPPORTED if so. */
1356                 sfinfo.rename_information.in.new_name  = fname_new + 1;
1357                 sfinfo.rename_information.in.overwrite = 1;
1358
1359                 status = smb_raw_setfileinfo(cli2->tree, &sfinfo);
1360
1361                 torture_assert_ntstatus_equal(tctx,status,NT_STATUS_OK,talloc_asprintf(tctx, "rename of %s to %s failed (%s)",
1362                         fname, fname_new, smbcli_errstr(cli2->tree)));
1363         }
1364
1365         correct &= check_delete_on_close(tctx, cli2, fnum2, fname_new, false, __location__);
1366
1367         smbcli_close(cli2->tree, fnum2);
1368
1369         /* See if the file is deleted - should be.... */
1370         fnum1 = smbcli_open(cli1->tree, fname, O_RDWR, DENY_NONE);
1371         torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail) - %s",
1372                        fname, smbcli_errstr(cli1->tree)));
1373         fnum1 = smbcli_open(cli1->tree, fname_new, O_RDWR, DENY_NONE);
1374         torture_assert(tctx, fnum1 == -1, talloc_asprintf(tctx, "open of %s succeeded (should fail) - %s",
1375                        fname_new, smbcli_errstr(cli1->tree)));
1376
1377         return correct;
1378 }
1379
1380
1381 /* Test 21 ... */
1382 static bool deltest21(struct torture_context *tctx)
1383 {
1384         int fnum1 = -1;
1385         struct smbcli_state *cli1;
1386         struct smbcli_state *cli2;
1387         bool correct = true;
1388
1389         if (!torture_open_connection(&cli1, tctx, 0))
1390                 return false;
1391
1392         if (!torture_open_connection(&cli2, tctx, 1))
1393                 return false;
1394
1395         del_clean_area(cli1, cli2);
1396
1397         /* Test 21 -- Test removal of file after socket close. */
1398
1399         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1400                                       SEC_RIGHTS_FILE_ALL,
1401                                       FILE_ATTRIBUTE_NORMAL, NTCREATEX_SHARE_ACCESS_NONE,
1402                                       NTCREATEX_DISP_OVERWRITE_IF, 0, 0);
1403
1404         torture_assert(tctx, fnum1 != -1, talloc_asprintf(tctx, "open of %s failed (%s)",
1405                        fname, smbcli_errstr(cli1->tree)));
1406
1407         torture_assert_ntstatus_ok(tctx,
1408                                 smbcli_nt_delete_on_close(cli1->tree, fnum1, true),
1409                                 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
1410                        smbcli_errstr(cli1->tree)));
1411
1412         /* Ensure delete on close is set. */
1413         correct &= check_delete_on_close(tctx, cli1, fnum1, fname, true, __location__);
1414
1415         /* Now yank the rug from under cli1. */
1416         smbcli_transport_dead(cli1->transport, NT_STATUS_LOCAL_DISCONNECT);
1417
1418         fnum1 = -1;
1419
1420         if (!torture_open_connection(&cli1, tctx, 0)) {
1421                 return false;
1422         }
1423
1424         /* On slow build farm machines it might happen that they are not fast
1425          * enogh to delete the file for this test */
1426         smb_msleep(200);
1427
1428         /* File should not be there. */
1429         fnum1 = smbcli_nt_create_full(cli1->tree, fname, 0,
1430                                       SEC_RIGHTS_FILE_READ,
1431                                       FILE_ATTRIBUTE_NORMAL,
1432                                       NTCREATEX_SHARE_ACCESS_READ|
1433                                       NTCREATEX_SHARE_ACCESS_WRITE|
1434                                       NTCREATEX_SHARE_ACCESS_DELETE,
1435                                       NTCREATEX_DISP_OPEN,
1436                                       0, 0);
1437
1438         CHECK_STATUS(cli1, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1439
1440         return correct;
1441 }
1442
1443 /* Test 22 ... */
1444
1445 /*
1446  * Test whether a second *directory* handle inhibits delete if the first has
1447  * del-on-close set and is closed
1448  */
1449 static bool deltest22(struct torture_context *tctx)
1450 {
1451         int dnum1 = -1;
1452         int dnum2 = -1;
1453         struct smbcli_state *cli1;
1454         bool correct = true;
1455
1456         if (!torture_open_connection(&cli1, tctx, 0))
1457                 return false;
1458
1459         smbcli_deltree(cli1->tree, dname);
1460
1461         torture_assert_ntstatus_ok(
1462                 tctx, smbcli_mkdir(cli1->tree, dname),
1463                 talloc_asprintf(tctx, "smbcli_mdir failed: (%s)\n",
1464                                 smbcli_errstr(cli1->tree)));
1465
1466         dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1467                                       SEC_FILE_READ_DATA|
1468                                       SEC_FILE_WRITE_DATA|
1469                                       SEC_STD_DELETE,
1470                                       FILE_ATTRIBUTE_DIRECTORY,
1471                                       NTCREATEX_SHARE_ACCESS_READ|
1472                                       NTCREATEX_SHARE_ACCESS_WRITE|
1473                                       NTCREATEX_SHARE_ACCESS_DELETE,
1474                                       NTCREATEX_DISP_OPEN,
1475                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1476
1477         torture_assert(tctx, dnum1 != -1,
1478                        talloc_asprintf(tctx, "open of %s failed: %s!",
1479                                        dname, smbcli_errstr(cli1->tree)));
1480
1481         dnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
1482                                       SEC_FILE_READ_DATA|
1483                                       SEC_FILE_WRITE_DATA,
1484                                       FILE_ATTRIBUTE_DIRECTORY,
1485                                       NTCREATEX_SHARE_ACCESS_READ|
1486                                       NTCREATEX_SHARE_ACCESS_WRITE|
1487                                       NTCREATEX_SHARE_ACCESS_DELETE,
1488                                       NTCREATEX_DISP_OPEN,
1489                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1490
1491         torture_assert(tctx, dnum2 != -1,
1492                        talloc_asprintf(tctx, "open of %s failed: %s!",
1493                                        dname, smbcli_errstr(cli1->tree)));
1494
1495         torture_assert_ntstatus_ok(
1496                 tctx, smbcli_nt_delete_on_close(cli1->tree, dnum1, true),
1497                 talloc_asprintf(tctx, "setting delete_on_close failed (%s)",
1498                                 smbcli_errstr(cli1->tree)));
1499
1500         smbcli_close(cli1->tree, dnum1);
1501
1502         dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1503                                       SEC_FILE_READ_DATA|
1504                                       SEC_FILE_WRITE_DATA|
1505                                       SEC_STD_DELETE,
1506                                       FILE_ATTRIBUTE_DIRECTORY,
1507                                       NTCREATEX_SHARE_ACCESS_READ|
1508                                       NTCREATEX_SHARE_ACCESS_WRITE|
1509                                       NTCREATEX_SHARE_ACCESS_DELETE,
1510                                       NTCREATEX_DISP_OPEN,
1511                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1512
1513         torture_assert(tctx, dnum1 == -1,
1514                        talloc_asprintf(tctx, "open of %s succeeded!\n",
1515                                        dname));
1516
1517         CHECK_STATUS(cli1, NT_STATUS_DELETE_PENDING);
1518
1519         smbcli_close(cli1->tree, dnum2);
1520         CHECK_STATUS(cli1, NT_STATUS_OK);
1521
1522         return correct;
1523 }
1524
1525 /* Test 23 - Second directory open fails when delete is pending. */
1526 static bool deltest23(struct torture_context *tctx,
1527                         struct smbcli_state *cli1,
1528                         struct smbcli_state *cli2)
1529 {
1530         int dnum1 = -1;
1531         int dnum2 = -1;
1532         bool correct = true;
1533
1534         del_clean_area(cli1, cli2);
1535
1536         /* Test 23 -- Basic delete on close for directories. */
1537
1538         /* Open a directory */
1539         dnum1 = smbcli_nt_create_full(cli1->tree, dname, 0,
1540                                       SEC_FILE_READ_DATA|
1541                                       SEC_FILE_WRITE_DATA|
1542                                       SEC_STD_DELETE,
1543                                       FILE_ATTRIBUTE_DIRECTORY,
1544                                       NTCREATEX_SHARE_ACCESS_READ|
1545                                       NTCREATEX_SHARE_ACCESS_WRITE|
1546                                       NTCREATEX_SHARE_ACCESS_DELETE,
1547                                       NTCREATEX_DISP_CREATE,
1548                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1549
1550         torture_assert(tctx, dnum1 != -1, talloc_asprintf(tctx,
1551                            "open of %s failed: %s!",
1552                            dname, smbcli_errstr(cli1->tree)));
1553
1554         correct &= check_delete_on_close(tctx, cli1, dnum1, dname, false,
1555             __location__);
1556
1557         /* Set delete on close */
1558         (void)smbcli_nt_delete_on_close(cli1->tree, dnum1, true);
1559
1560         /* Attempt opening the directory again.  It should fail. */
1561         dnum2 = smbcli_nt_create_full(cli1->tree, dname, 0,
1562                                       SEC_FILE_READ_DATA|
1563                                       SEC_FILE_WRITE_DATA|
1564                                       SEC_STD_DELETE,
1565                                       FILE_ATTRIBUTE_DIRECTORY,
1566                                       NTCREATEX_SHARE_ACCESS_READ|
1567                                       NTCREATEX_SHARE_ACCESS_WRITE|
1568                                       NTCREATEX_SHARE_ACCESS_DELETE,
1569                                       NTCREATEX_DISP_OPEN,
1570                                       NTCREATEX_OPTIONS_DIRECTORY, 0);
1571
1572         torture_assert(tctx, dnum2 == -1, talloc_asprintf(tctx,
1573                            "open of %s succeeded: %s. It should have failed "
1574                            "with NT_STATUS_DELETE_PENDING",
1575                            dname, smbcli_errstr(cli1->tree)));
1576
1577         torture_assert_ntstatus_equal(tctx, smbcli_nt_error(cli1->tree),
1578             NT_STATUS_DELETE_PENDING, "smbcli_open failed");
1579
1580         return true;
1581 }
1582
1583 /*
1584   Test delete on close semantics.
1585  */
1586 struct torture_suite *torture_test_delete(void)
1587 {
1588         struct torture_suite *suite = torture_suite_create(
1589                 talloc_autofree_context(), "delete");
1590
1591         torture_suite_add_2smb_test(suite, "deltest1", deltest1);
1592         torture_suite_add_2smb_test(suite, "deltest2", deltest2);
1593         torture_suite_add_2smb_test(suite, "deltest3", deltest3);
1594         torture_suite_add_2smb_test(suite, "deltest4", deltest4);
1595         torture_suite_add_2smb_test(suite, "deltest5", deltest5);
1596         torture_suite_add_2smb_test(suite, "deltest6", deltest6);
1597         torture_suite_add_2smb_test(suite, "deltest7", deltest7);
1598         torture_suite_add_2smb_test(suite, "deltest8", deltest8);
1599         torture_suite_add_2smb_test(suite, "deltest9", deltest9);
1600         torture_suite_add_2smb_test(suite, "deltest10", deltest10);
1601         torture_suite_add_2smb_test(suite, "deltest11", deltest11);
1602         torture_suite_add_2smb_test(suite, "deltest12", deltest12);
1603         torture_suite_add_2smb_test(suite, "deltest13", deltest13);
1604         torture_suite_add_2smb_test(suite, "deltest14", deltest14);
1605         torture_suite_add_2smb_test(suite, "deltest15", deltest15);
1606         torture_suite_add_2smb_test(suite, "deltest16", deltest16);
1607         torture_suite_add_2smb_test(suite, "deltest17", deltest17);
1608         torture_suite_add_2smb_test(suite, "deltest18", deltest18);
1609         torture_suite_add_2smb_test(suite, "deltest19", deltest19);
1610         torture_suite_add_2smb_test(suite, "deltest20", deltest20);
1611         torture_suite_add_2smb_test(suite, "deltest20a", deltest20a);
1612         torture_suite_add_2smb_test(suite, "deltest20b", deltest20b);
1613         torture_suite_add_simple_test(suite, "deltest21", deltest21);
1614         torture_suite_add_simple_test(suite, "deltest22", deltest22);
1615         torture_suite_add_2smb_test(suite, "deltest23", deltest23);
1616
1617         return suite;
1618 }