source4/torture/smb2/compound.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    test suite for SMB2 compounded requests
   5
   6    Copyright (C) Stefan Metzmacher 2009
   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/smb2/smb2.h"
  24 #include "libcli/smb2/smb2_calls.h"
  25 #include "torture/torture.h"
  26 #include "torture/smb2/proto.h"
  27
  28 #define CHECK_STATUS(status, correct) do { \
  29         if (!NT_STATUS_EQUAL(status, correct)) { \
  30                 torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
  31                        nt_errstr(status), nt_errstr(correct)); \
  32                 ret = false; \
  33                 goto done; \
  34         }} while (0)
  35
  36 #define TARGET_IS_W2K8(_tctx) (torture_setting_bool(_tctx, "w2k8", false))
  37 #define TARGET_IS_WIN7(_tctx) (torture_setting_bool(_tctx, "win7", false))
  38
  39 static bool test_compound_related1(struct torture_context *tctx,
  40                                    struct smb2_tree *tree)
  41 {
  42         struct smb2_handle hd;
  43         struct smb2_create cr;
  44         NTSTATUS status;
  45         const char *fname = "compound_related1.dat";
  46         struct smb2_close cl;
  47         bool ret = true;
  48         struct smb2_request *req[2];
  49
  50         smb2_transport_credits_ask_num(tree->session->transport, 2);
  51
  52         smb2_util_unlink(tree, fname);
  53
  54         smb2_transport_credits_ask_num(tree->session->transport, 1);
  55
  56         ZERO_STRUCT(cr);
  57         cr.in.security_flags            = 0x00;
  58         cr.in.oplock_level              = 0;
  59         cr.in.impersonation_level       = NTCREATEX_IMPERSONATION_IMPERSONATION;
  60         cr.in.create_flags              = 0x00000000;
  61         cr.in.reserved                  = 0x00000000;
  62         cr.in.desired_access            = SEC_RIGHTS_FILE_ALL;
  63         cr.in.file_attributes           = FILE_ATTRIBUTE_NORMAL;
  64         cr.in.share_access              = NTCREATEX_SHARE_ACCESS_READ |
  65                                           NTCREATEX_SHARE_ACCESS_WRITE |
  66                                           NTCREATEX_SHARE_ACCESS_DELETE;
  67         cr.in.create_disposition        = NTCREATEX_DISP_OPEN_IF;
  68         cr.in.create_options            = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
  69                                           NTCREATEX_OPTIONS_ASYNC_ALERT |
  70                                           NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
  71                                           0x00200000;
  72         cr.in.fname                     = fname;
  73
  74         smb2_transport_compound_start(tree->session->transport, 2);
  75
  76         req[0] = smb2_create_send(tree, &cr);
  77
  78         smb2_transport_compound_set_related(tree->session->transport, true);
  79
  80         hd.data[0] = UINT64_MAX;
  81         hd.data[1] = UINT64_MAX;
  82
  83         ZERO_STRUCT(cl);
  84         cl.in.file.handle = hd;
  85         req[1] = smb2_close_send(tree, &cl);
  86
  87         status = smb2_create_recv(req[0], tree, &cr);
  88         CHECK_STATUS(status, NT_STATUS_OK);
  89         status = smb2_close_recv(req[1], &cl);
  90         CHECK_STATUS(status, NT_STATUS_OK);
  91
  92         smb2_util_unlink(tree, fname);
  93 done:
  94         return ret;
  95 }
  96
  97 static bool test_compound_related2(struct torture_context *tctx,
  98                                    struct smb2_tree *tree)
  99 {
 100         struct smb2_handle hd;
 101         struct smb2_create cr;
 102         NTSTATUS status;
 103         const char *fname = "compound_related2.dat";
 104         struct smb2_close cl;
 105         bool ret = true;
 106         struct smb2_request *req[5];
 107
 108         smb2_transport_credits_ask_num(tree->session->transport, 5);
 109
 110         smb2_util_unlink(tree, fname);
 111
 112         smb2_transport_credits_ask_num(tree->session->transport, 1);
 113
 114         ZERO_STRUCT(cr);
 115         cr.in.security_flags            = 0x00;
 116         cr.in.oplock_level              = 0;
 117         cr.in.impersonation_level       = NTCREATEX_IMPERSONATION_IMPERSONATION;
 118         cr.in.create_flags              = 0x00000000;
 119         cr.in.reserved                  = 0x00000000;
 120         cr.in.desired_access            = SEC_RIGHTS_FILE_ALL;
 121         cr.in.file_attributes           = FILE_ATTRIBUTE_NORMAL;
 122         cr.in.share_access              = NTCREATEX_SHARE_ACCESS_READ |
 123                                           NTCREATEX_SHARE_ACCESS_WRITE |
 124                                           NTCREATEX_SHARE_ACCESS_DELETE;
 125         cr.in.create_disposition        = NTCREATEX_DISP_OPEN_IF;
 126         cr.in.create_options            = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
 127                                           NTCREATEX_OPTIONS_ASYNC_ALERT |
 128                                           NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
 129                                           0x00200000;
 130         cr.in.fname                     = fname;
 131
 132         smb2_transport_compound_start(tree->session->transport, 5);
 133
 134         req[0] = smb2_create_send(tree, &cr);
 135
 136         hd.data[0] = UINT64_MAX;
 137         hd.data[1] = UINT64_MAX;
 138
 139         smb2_transport_compound_set_related(tree->session->transport, true);
 140
 141         ZERO_STRUCT(cl);
 142         cl.in.file.handle = hd;
 143         req[1] = smb2_close_send(tree, &cl);
 144         req[2] = smb2_close_send(tree, &cl);
 145         req[3] = smb2_close_send(tree, &cl);
 146         req[4] = smb2_close_send(tree, &cl);
 147
 148         status = smb2_create_recv(req[0], tree, &cr);
 149         CHECK_STATUS(status, NT_STATUS_OK);
 150         status = smb2_close_recv(req[1], &cl);
 151         CHECK_STATUS(status, NT_STATUS_OK);
 152         status = smb2_close_recv(req[2], &cl);
 153         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 154         status = smb2_close_recv(req[3], &cl);
 155         CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
 156         status = smb2_close_recv(req[4], &cl);
 157         CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
 158
 159         smb2_util_unlink(tree, fname);
 160 done:
 161         return ret;
 162 }
 163
 164 static bool test_compound_unrelated1(struct torture_context *tctx,
 165                                      struct smb2_tree *tree)
 166 {
 167         struct smb2_handle hd;
 168         struct smb2_create cr;
 169         NTSTATUS status;
 170         const char *fname = "compound_unrelated1.dat";
 171         struct smb2_close cl;
 172         bool ret = true;
 173         struct smb2_request *req[5];
 174
 175         smb2_transport_credits_ask_num(tree->session->transport, 5);
 176
 177         smb2_util_unlink(tree, fname);
 178
 179         smb2_transport_credits_ask_num(tree->session->transport, 1);
 180
 181         ZERO_STRUCT(cr);
 182         cr.in.security_flags            = 0x00;
 183         cr.in.oplock_level              = 0;
 184         cr.in.impersonation_level       = NTCREATEX_IMPERSONATION_IMPERSONATION;
 185         cr.in.create_flags              = 0x00000000;
 186         cr.in.reserved                  = 0x00000000;
 187         cr.in.desired_access            = SEC_RIGHTS_FILE_ALL;
 188         cr.in.file_attributes           = FILE_ATTRIBUTE_NORMAL;
 189         cr.in.share_access              = NTCREATEX_SHARE_ACCESS_READ |
 190                                           NTCREATEX_SHARE_ACCESS_WRITE |
 191                                           NTCREATEX_SHARE_ACCESS_DELETE;
 192         cr.in.create_disposition        = NTCREATEX_DISP_OPEN_IF;
 193         cr.in.create_options            = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
 194                                           NTCREATEX_OPTIONS_ASYNC_ALERT |
 195                                           NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
 196                                           0x00200000;
 197         cr.in.fname                     = fname;
 198
 199         smb2_transport_compound_start(tree->session->transport, 5);
 200
 201         req[0] = smb2_create_send(tree, &cr);
 202
 203         hd.data[0] = UINT64_MAX;
 204         hd.data[1] = UINT64_MAX;
 205
 206         ZERO_STRUCT(cl);
 207         cl.in.file.handle = hd;
 208         req[1] = smb2_close_send(tree, &cl);
 209         req[2] = smb2_close_send(tree, &cl);
 210         req[3] = smb2_close_send(tree, &cl);
 211         req[4] = smb2_close_send(tree, &cl);
 212
 213         status = smb2_create_recv(req[0], tree, &cr);
 214         CHECK_STATUS(status, NT_STATUS_OK);
 215         status = smb2_close_recv(req[1], &cl);
 216         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 217         status = smb2_close_recv(req[2], &cl);
 218         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 219         status = smb2_close_recv(req[3], &cl);
 220         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 221         status = smb2_close_recv(req[4], &cl);
 222         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 223
 224         smb2_util_unlink(tree, fname);
 225 done:
 226         return ret;
 227 }
 228
 229 static bool test_compound_invalid1(struct torture_context *tctx,
 230                                    struct smb2_tree *tree)
 231 {
 232         struct smb2_handle hd;
 233         struct smb2_create cr;
 234         NTSTATUS status;
 235         const char *fname = "compound_invalid1.dat";
 236         struct smb2_close cl;
 237         bool ret = true;
 238         struct smb2_request *req[2];
 239
 240         smb2_transport_credits_ask_num(tree->session->transport, 2);
 241
 242         smb2_util_unlink(tree, fname);
 243
 244         smb2_transport_credits_ask_num(tree->session->transport, 1);
 245
 246         ZERO_STRUCT(cr);
 247         cr.in.security_flags            = 0x00;
 248         cr.in.oplock_level              = 0;
 249         cr.in.impersonation_level       = NTCREATEX_IMPERSONATION_IMPERSONATION;
 250         cr.in.create_flags              = 0x00000000;
 251         cr.in.reserved                  = 0x00000000;
 252         cr.in.desired_access            = SEC_RIGHTS_FILE_ALL;
 253         cr.in.file_attributes           = FILE_ATTRIBUTE_NORMAL;
 254         cr.in.share_access              = NTCREATEX_SHARE_ACCESS_READ |
 255                                           NTCREATEX_SHARE_ACCESS_WRITE |
 256                                           NTCREATEX_SHARE_ACCESS_DELETE;
 257         cr.in.create_disposition        = NTCREATEX_DISP_OPEN_IF;
 258         cr.in.create_options            = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
 259                                           NTCREATEX_OPTIONS_ASYNC_ALERT |
 260                                           NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
 261                                           0x00200000;
 262         cr.in.fname                     = fname;
 263
 264         smb2_transport_compound_start(tree->session->transport, 2);
 265
 266         /* passing the first request with the related flag is invalid */
 267         smb2_transport_compound_set_related(tree->session->transport, true);
 268
 269         req[0] = smb2_create_send(tree, &cr);
 270
 271         hd.data[0] = UINT64_MAX;
 272         hd.data[1] = UINT64_MAX;
 273
 274         ZERO_STRUCT(cl);
 275         cl.in.file.handle = hd;
 276         req[1] = smb2_close_send(tree, &cl);
 277
 278         status = smb2_create_recv(req[0], tree, &cr);
 279         /* TODO: check why this fails with --signing=required */
 280         CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
 281         status = smb2_close_recv(req[1], &cl);
 282         CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
 283
 284         smb2_util_unlink(tree, fname);
 285 done:
 286         return ret;
 287 }
 288
 289 static bool test_compound_invalid2(struct torture_context *tctx,
 290                                    struct smb2_tree *tree)
 291 {
 292         struct smb2_handle hd;
 293         struct smb2_create cr;
 294         NTSTATUS status;
 295         const char *fname = "compound_invalid2.dat";
 296         struct smb2_close cl;
 297         bool ret = true;
 298         struct smb2_request *req[5];
 299
 300         smb2_transport_credits_ask_num(tree->session->transport, 5);
 301
 302         smb2_util_unlink(tree, fname);
 303
 304         smb2_transport_credits_ask_num(tree->session->transport, 1);
 305
 306         ZERO_STRUCT(cr);
 307         cr.in.security_flags            = 0x00;
 308         cr.in.oplock_level              = 0;
 309         cr.in.impersonation_level       = NTCREATEX_IMPERSONATION_IMPERSONATION;
 310         cr.in.create_flags              = 0x00000000;
 311         cr.in.reserved                  = 0x00000000;
 312         cr.in.desired_access            = SEC_RIGHTS_FILE_ALL;
 313         cr.in.file_attributes           = FILE_ATTRIBUTE_NORMAL;
 314         cr.in.share_access              = NTCREATEX_SHARE_ACCESS_READ |
 315                                           NTCREATEX_SHARE_ACCESS_WRITE |
 316                                           NTCREATEX_SHARE_ACCESS_DELETE;
 317         cr.in.create_disposition        = NTCREATEX_DISP_OPEN_IF;
 318         cr.in.create_options            = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
 319                                           NTCREATEX_OPTIONS_ASYNC_ALERT |
 320                                           NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
 321                                           0x00200000;
 322         cr.in.fname                     = fname;
 323
 324         smb2_transport_compound_start(tree->session->transport, 5);
 325
 326         req[0] = smb2_create_send(tree, &cr);
 327
 328         hd.data[0] = UINT64_MAX;
 329         hd.data[1] = UINT64_MAX;
 330
 331         smb2_transport_compound_set_related(tree->session->transport, true);
 332
 333         ZERO_STRUCT(cl);
 334         cl.in.file.handle = hd;
 335         req[1] = smb2_close_send(tree, &cl);
 336         /* strange that this is not generating invalid parameter */
 337         smb2_transport_compound_set_related(tree->session->transport, false);
 338         req[2] = smb2_close_send(tree, &cl);
 339         req[3] = smb2_close_send(tree, &cl);
 340         smb2_transport_compound_set_related(tree->session->transport, true);
 341         req[4] = smb2_close_send(tree, &cl);
 342
 343         status = smb2_create_recv(req[0], tree, &cr);
 344         CHECK_STATUS(status, NT_STATUS_OK);
 345         status = smb2_close_recv(req[1], &cl);
 346         CHECK_STATUS(status, NT_STATUS_OK);
 347         status = smb2_close_recv(req[2], &cl);
 348         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 349         status = smb2_close_recv(req[3], &cl);
 350         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 351         status = smb2_close_recv(req[4], &cl);
 352         CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
 353
 354         smb2_util_unlink(tree, fname);
 355 done:
 356         return ret;
 357 }
 358
 359 static bool test_compound_invalid3(struct torture_context *tctx,
 360                                    struct smb2_tree *tree)
 361 {
 362         struct smb2_handle hd;
 363         struct smb2_create cr;
 364         NTSTATUS status;
 365         const char *fname = "compound_invalid3.dat";
 366         struct smb2_close cl;
 367         bool ret = true;
 368         struct smb2_request *req[5];
 369
 370         smb2_transport_credits_ask_num(tree->session->transport, 5);
 371
 372         smb2_util_unlink(tree, fname);
 373
 374         smb2_transport_credits_ask_num(tree->session->transport, 1);
 375
 376         ZERO_STRUCT(cr);
 377         cr.in.security_flags            = 0x00;
 378         cr.in.oplock_level              = 0;
 379         cr.in.impersonation_level       = NTCREATEX_IMPERSONATION_IMPERSONATION;
 380         cr.in.create_flags              = 0x00000000;
 381         cr.in.reserved                  = 0x00000000;
 382         cr.in.desired_access            = SEC_RIGHTS_FILE_ALL;
 383         cr.in.file_attributes           = FILE_ATTRIBUTE_NORMAL;
 384         cr.in.share_access              = NTCREATEX_SHARE_ACCESS_READ |
 385                                           NTCREATEX_SHARE_ACCESS_WRITE |
 386                                           NTCREATEX_SHARE_ACCESS_DELETE;
 387         cr.in.create_disposition        = NTCREATEX_DISP_OPEN_IF;
 388         cr.in.create_options            = NTCREATEX_OPTIONS_SEQUENTIAL_ONLY |
 389                                           NTCREATEX_OPTIONS_ASYNC_ALERT |
 390                                           NTCREATEX_OPTIONS_NON_DIRECTORY_FILE |
 391                                           0x00200000;
 392         cr.in.fname                     = fname;
 393
 394         smb2_transport_compound_start(tree->session->transport, 5);
 395
 396         req[0] = smb2_create_send(tree, &cr);
 397
 398         hd.data[0] = UINT64_MAX;
 399         hd.data[1] = UINT64_MAX;
 400
 401         ZERO_STRUCT(cl);
 402         cl.in.file.handle = hd;
 403         req[1] = smb2_close_send(tree, &cl);
 404         req[2] = smb2_close_send(tree, &cl);
 405         /* flipping the related flag is invalid */
 406         smb2_transport_compound_set_related(tree->session->transport, true);
 407         req[3] = smb2_close_send(tree, &cl);
 408         req[4] = smb2_close_send(tree, &cl);
 409
 410         status = smb2_create_recv(req[0], tree, &cr);
 411         CHECK_STATUS(status, NT_STATUS_OK);
 412         status = smb2_close_recv(req[1], &cl);
 413         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 414         status = smb2_close_recv(req[2], &cl);
 415         CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
 416         status = smb2_close_recv(req[3], &cl);
 417         CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
 418         status = smb2_close_recv(req[4], &cl);
 419         CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
 420
 421         smb2_util_unlink(tree, fname);
 422 done:
 423         return ret;
 424 }
 425
 426 /* Send a compound request where we expect the last request (Create, Notify)
 427  * to go asynchronous. This works against a Win7 server and the reply is
 428  * sent in two different packets. */
 429 static bool test_compound_interim1(struct torture_context *tctx,
 430                                    struct smb2_tree *tree)
 431 {
 432     struct smb2_handle hd;
 433     struct smb2_create cr;
 434     NTSTATUS status = NT_STATUS_OK;
 435     const char *dname = "compound_interim_dir";
 436     struct smb2_notify nt;
 437     bool ret = true;
 438     struct smb2_request *req[2];
 439
 440     /* Win7 compound request implementation deviates substantially from the
 441      * SMB2 spec as noted in MS-SMB2 <159>, <162>.  This, test currently
 442      * verifies the Windows behavior, not the general spec behavior. */
 443     if (!TARGET_IS_WIN7(tctx) && !TARGET_IS_W2K8(tctx)) {
 444             torture_skip(tctx, "Interim test is specific to Windows server "
 445                                "behavior.\n");
 446     }
 447
 448     smb2_transport_credits_ask_num(tree->session->transport, 5);
 449
 450     smb2_deltree(tree, dname);
 451
 452     smb2_transport_credits_ask_num(tree->session->transport, 1);
 453
 454     ZERO_STRUCT(cr);
 455     cr.in.desired_access        = SEC_RIGHTS_FILE_ALL;
 456     cr.in.create_options        = NTCREATEX_OPTIONS_DIRECTORY;
 457     cr.in.file_attributes       = FILE_ATTRIBUTE_DIRECTORY;
 458     cr.in.share_access          = NTCREATEX_SHARE_ACCESS_READ |
 459                                   NTCREATEX_SHARE_ACCESS_WRITE |
 460                                   NTCREATEX_SHARE_ACCESS_DELETE;
 461     cr.in.create_disposition    = NTCREATEX_DISP_CREATE;
 462     cr.in.fname                 = dname;
 463
 464     smb2_transport_compound_start(tree->session->transport, 2);
 465
 466     req[0] = smb2_create_send(tree, &cr);
 467
 468     smb2_transport_compound_set_related(tree->session->transport, true);
 469
 470     hd.data[0] = UINT64_MAX;
 471     hd.data[1] = UINT64_MAX;
 472
 473     ZERO_STRUCT(nt);
 474     nt.in.recursive          = true;
 475     nt.in.buffer_size        = 0x1000;
 476     nt.in.file.handle        = hd;
 477     nt.in.completion_filter  = FILE_NOTIFY_CHANGE_NAME;
 478     nt.in.unknown            = 0x00000000;
 479
 480     req[1] = smb2_notify_send(tree, &nt);
 481
 482     status = smb2_create_recv(req[0], tree, &cr);
 483     CHECK_STATUS(status, NT_STATUS_OK);
 484
 485     smb2_cancel(req[1]);
 486     status = smb2_notify_recv(req[1], tree, &nt);
 487     CHECK_STATUS(status, NT_STATUS_CANCELLED);
 488
 489     smb2_util_close(tree, cr.out.file.handle);
 490
 491     smb2_deltree(tree, dname);
 492 done:
 493     return ret;
 494 }
 495
 496 /* Send a compound request where we expect the middle request (Create, Notify,
 497  * GetInfo) to go asynchronous. Against Win7 the sync request succeed while
 498  * the async fails. All are returned in the same compound response. */
 499 static bool test_compound_interim2(struct torture_context *tctx,
 500                                    struct smb2_tree *tree)
 501 {
 502     struct smb2_handle hd;
 503     struct smb2_create cr;
 504     NTSTATUS status = NT_STATUS_OK;
 505     const char *dname = "compound_interim_dir";
 506     struct smb2_getinfo gf;
 507     struct smb2_notify  nt;
 508     bool ret = true;
 509     struct smb2_request *req[3];
 510
 511     /* Win7 compound request implementation deviates substantially from the
 512      * SMB2 spec as noted in MS-SMB2 <159>, <162>.  This, test currently
 513      * verifies the Windows behavior, not the general spec behavior. */
 514     if (!TARGET_IS_WIN7(tctx) && !TARGET_IS_W2K8(tctx)) {
 515             torture_skip(tctx, "Interim test is specific to Windows server "
 516                                "behavior.\n");
 517     }
 518
 519     smb2_transport_credits_ask_num(tree->session->transport, 5);
 520
 521     smb2_deltree(tree, dname);
 522
 523     smb2_transport_credits_ask_num(tree->session->transport, 1);
 524
 525     ZERO_STRUCT(cr);
 526     cr.in.desired_access        = SEC_RIGHTS_FILE_ALL;
 527     cr.in.create_options        = NTCREATEX_OPTIONS_DIRECTORY;
 528     cr.in.file_attributes       = FILE_ATTRIBUTE_DIRECTORY;
 529     cr.in.share_access      = NTCREATEX_SHARE_ACCESS_READ |
 530                       NTCREATEX_SHARE_ACCESS_WRITE |
 531                       NTCREATEX_SHARE_ACCESS_DELETE;
 532     cr.in.create_disposition    = NTCREATEX_DISP_CREATE;
 533     cr.in.fname         = dname;
 534
 535     smb2_transport_compound_start(tree->session->transport, 3);
 536
 537     req[0] = smb2_create_send(tree, &cr);
 538
 539     smb2_transport_compound_set_related(tree->session->transport, true);
 540
 541     hd.data[0] = UINT64_MAX;
 542     hd.data[1] = UINT64_MAX;
 543
 544     ZERO_STRUCT(nt);
 545     nt.in.recursive          = true;
 546     nt.in.buffer_size        = 0x1000;
 547     nt.in.file.handle        = hd;
 548     nt.in.completion_filter  = FILE_NOTIFY_CHANGE_NAME;
 549     nt.in.unknown            = 0x00000000;
 550
 551     req[1] = smb2_notify_send(tree, &nt);
 552
 553     ZERO_STRUCT(gf);
 554     gf.in.file.handle = hd;
 555     gf.in.info_type   = SMB2_GETINFO_FILE;
 556     gf.in.info_class  = 0x04; // FILE_BASIC_INFORMATION
 557     gf.in.output_buffer_length = 0x1000;
 558     gf.in.input_buffer_length = 0;
 559
 560     req[2] = smb2_getinfo_send(tree, &gf);
 561
 562     status = smb2_create_recv(req[0], tree, &cr);
 563     CHECK_STATUS(status, NT_STATUS_OK);
 564
 565     status = smb2_notify_recv(req[1], tree, &nt);
 566     CHECK_STATUS(status, NT_STATUS_INTERNAL_ERROR);
 567
 568     status = smb2_getinfo_recv(req[2], tree, &gf);
 569     CHECK_STATUS(status, NT_STATUS_OK);
 570
 571     smb2_util_close(tree, cr.out.file.handle);
 572
 573     smb2_deltree(tree, dname);
 574 done:
 575     return ret;
 576 }
 577
 578 struct torture_suite *torture_smb2_compound_init(void)
 579 {
 580         struct torture_suite *suite =
 581             torture_suite_create(talloc_autofree_context(), "COMPOUND");
 582
 583         torture_suite_add_1smb2_test(suite, "RELATED1", test_compound_related1);
 584         torture_suite_add_1smb2_test(suite, "RELATED2", test_compound_related2);
 585         torture_suite_add_1smb2_test(suite, "UNRELATED1", test_compound_unrelated1);
 586         torture_suite_add_1smb2_test(suite, "INVALID1", test_compound_invalid1);
 587         torture_suite_add_1smb2_test(suite, "INVALID2", test_compound_invalid2);
 588         torture_suite_add_1smb2_test(suite, "INVALID3", test_compound_invalid3);
 589         torture_suite_add_1smb2_test(suite, "INTERIM1",  test_compound_interim1);
 590         torture_suite_add_1smb2_test(suite, "INTERIM2",  test_compound_interim2);
 591
 592         suite->description = talloc_strdup(suite, "SMB2-COMPOUND tests");
 593
 594         return suite;
 595 }