source4/torture/smb2/oplock.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    test suite for SMB2 oplocks
   5
   6    Copyright (C) Andrew Tridgell 2003
   7    Copyright (C) Stefan Metzmacher 2008
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24
  25 #include "libcli/smb2/smb2.h"
  26 #include "libcli/smb2/smb2_calls.h"
  27 #include "libcli/smb_composite/smb_composite.h"
  28 #include "libcli/resolve/resolve.h"
  29
  30 #include "lib/cmdline/popt_common.h"
  31 #include "lib/events/events.h"
  32
  33 #include "param/param.h"
  34 #include "system/filesys.h"
  35
  36 #include "torture/torture.h"
  37 #include "torture/smb2/proto.h"
  38
  39 #define CHECK_RANGE(v, min, max) do { \
  40         if ((v) < (min) || (v) > (max)) { \
  41                 torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s " \
  42                                "got %d - should be between %d and %d\n", \
  43                                 __location__, #v, (int)v, (int)min, (int)max); \
  44                 ret = false; \
  45         }} while (0)
  46
  47 #define CHECK_STRMATCH(v, correct) do { \
  48         if (!v || strstr((v),(correct)) == NULL) { \
  49                 torture_result(tctx, TORTURE_FAIL,  "(%s): wrong value for %s "\
  50                                "got '%s' - should be '%s'\n", \
  51                                 __location__, #v, v?v:"NULL", correct); \
  52                 ret = false; \
  53         }} while (0)
  54
  55 #define CHECK_VAL(v, correct) do { \
  56         if ((v) != (correct)) { \
  57                 torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s " \
  58                                "got 0x%x - should be 0x%x\n", \
  59                                 __location__, #v, (int)v, (int)correct); \
  60                 ret = false; \
  61         }} while (0)
  62
  63 #define BASEDIR "oplock_test"
  64
  65 static struct {
  66         struct smb2_handle handle;
  67         uint8_t level;
  68         struct smb2_break br;
  69         int count;
  70         int failures;
  71         NTSTATUS failure_status;
  72 } break_info;
  73
  74 static void torture_oplock_break_callback(struct smb2_request *req)
  75 {
  76         NTSTATUS status;
  77         struct smb2_break br;
  78
  79         ZERO_STRUCT(br);
  80         status = smb2_break_recv(req, &break_info.br);
  81         if (!NT_STATUS_IS_OK(status)) {
  82                 break_info.failures++;
  83                 break_info.failure_status = status;
  84         }
  85
  86         return;
  87 }
  88
  89 /* A general oplock break notification handler.  This should be used when a
  90  * test expects to break from batch or exclusive to a lower level. */
  91 static bool torture_oplock_handler(struct smb2_transport *transport,
  92                                    const struct smb2_handle *handle,
  93                                    uint8_t level,
  94                                    void *private_data)
  95 {
  96         struct smb2_tree *tree = private_data;
  97         const char *name;
  98         struct smb2_request *req;
  99         ZERO_STRUCT(break_info.br);
 100
 101         break_info.handle       = *handle;
 102         break_info.level        = level;
 103         break_info.count++;
 104
 105         switch (level) {
 106         case SMB2_OPLOCK_LEVEL_II:
 107                 name = "level II";
 108                 break;
 109         case SMB2_OPLOCK_LEVEL_NONE:
 110                 name = "none";
 111                 break;
 112         default:
 113                 name = "unknown";
 114                 break_info.failures++;
 115         }
 116         printf("Acking to %s [0x%02X] in oplock handler\n", name, level);
 117
 118         break_info.br.in.file.handle    = *handle;
 119         break_info.br.in.oplock_level   = level;
 120         break_info.br.in.reserved       = 0;
 121         break_info.br.in.reserved2      = 0;
 122
 123         req = smb2_break_send(tree, &break_info.br);
 124         req->async.fn = torture_oplock_break_callback;
 125         req->async.private_data = NULL;
 126         return true;
 127 }
 128
 129 /*
 130   A handler function for oplock break notifications. Send a break to none
 131   request.
 132 */
 133 static bool torture_oplock_handler_ack_to_none(struct smb2_transport *transport,
 134                                                const struct smb2_handle *handle,
 135                                                uint8_t level,
 136                                                void *private_data)
 137 {
 138         struct smb2_tree *tree = private_data;
 139         struct smb2_request *req;
 140
 141         break_info.handle = *handle;
 142         break_info.level = level;
 143         break_info.count++;
 144
 145         printf("Acking to none in oplock handler\n");
 146
 147         ZERO_STRUCT(break_info.br);
 148         break_info.br.in.file.handle    = *handle;
 149         break_info.br.in.oplock_level   = SMB2_OPLOCK_LEVEL_NONE;
 150         break_info.br.in.reserved       = 0;
 151         break_info.br.in.reserved2      = 0;
 152
 153         req = smb2_break_send(tree, &break_info.br);
 154         req->async.fn = torture_oplock_break_callback;
 155         req->async.private_data = NULL;
 156
 157         return true;
 158 }
 159
 160 /*
 161   A handler function for oplock break notifications. Break from level II to
 162   none.  SMB2 requires that the client does not send an oplock break request to
 163   the server in this case.
 164 */
 165 static bool torture_oplock_handler_level2_to_none(
 166                                                struct smb2_transport *transport,
 167                                                const struct smb2_handle *handle,
 168                                                uint8_t level,
 169                                                void *private_data)
 170 {
 171         break_info.handle = *handle;
 172         break_info.level = level;
 173         break_info.count++;
 174
 175         printf("Break from level II to none in oplock handler\n");
 176
 177         return true;
 178 }
 179
 180 /* A handler function for oplock break notifications.  This should be used when
 181  * test expects two break notifications, first to level II, then to none. */
 182 static bool torture_oplock_handler_two_notifications(
 183                                         struct smb2_transport *transport,
 184                                         const struct smb2_handle *handle,
 185                                         uint8_t level,
 186                                         void *private_data)
 187 {
 188         struct smb2_tree *tree = private_data;
 189         const char *name;
 190         struct smb2_request *req;
 191         ZERO_STRUCT(break_info.br);
 192
 193         break_info.handle       = *handle;
 194         break_info.level        = level;
 195         break_info.count++;
 196
 197         switch (level) {
 198         case SMB2_OPLOCK_LEVEL_II:
 199                 name = "level II";
 200                 break;
 201         case SMB2_OPLOCK_LEVEL_NONE:
 202                 name = "none";
 203                 break;
 204         default:
 205                 name = "unknown";
 206                 break_info.failures++;
 207         }
 208         printf("Breaking to %s [0x%02X] in oplock handler\n", name, level);
 209
 210         if (level == SMB2_OPLOCK_LEVEL_NONE)
 211                 return true;
 212
 213         break_info.br.in.file.handle    = *handle;
 214         break_info.br.in.oplock_level   = level;
 215         break_info.br.in.reserved       = 0;
 216         break_info.br.in.reserved2      = 0;
 217
 218         req = smb2_break_send(tree, &break_info.br);
 219         req->async.fn = torture_oplock_break_callback;
 220         req->async.private_data = NULL;
 221         return true;
 222 }
 223 static void torture_oplock_handler_close_recv(struct smb2_request *req)
 224 {
 225         if (!smb2_request_receive(req)) {
 226                 printf("close failed in oplock_handler_close\n");
 227                 break_info.failures++;
 228         }
 229 }
 230
 231 /*
 232   a handler function for oplock break requests - close the file
 233 */
 234 static bool torture_oplock_handler_close(struct smb2_transport *transport,
 235                                          const struct smb2_handle *handle,
 236                                          uint8_t level,
 237                                          void *private_data)
 238 {
 239         struct smb2_close io;
 240         struct smb2_tree *tree = private_data;
 241         struct smb2_request *req;
 242
 243         break_info.handle = *handle;
 244         break_info.level = level;
 245         break_info.count++;
 246
 247         ZERO_STRUCT(io);
 248         io.in.file.handle       = *handle;
 249         io.in.flags          = RAW_CLOSE_SMB2;
 250         req = smb2_close_send(tree, &io);
 251         if (req == NULL) {
 252                 printf("failed to send close in oplock_handler_close\n");
 253                 return false;
 254         }
 255
 256         req->async.fn = torture_oplock_handler_close_recv;
 257         req->async.private_data = NULL;
 258
 259         return true;
 260 }
 261
 262 /*
 263   a handler function for oplock break requests. Let it timeout
 264 */
 265 static bool torture_oplock_handler_timeout(struct smb2_transport *transport,
 266                                            const struct smb2_handle *handle,
 267                                            uint8_t level,
 268                                            void *private_data)
 269 {
 270         break_info.handle = *handle;
 271         break_info.level = level;
 272         break_info.count++;
 273
 274         printf("Let oplock break timeout\n");
 275         return true;
 276 }
 277
 278 static bool open_smb2_connection_no_level2_oplocks(struct torture_context *tctx,
 279                                                    struct smb2_tree **tree)
 280 {
 281         NTSTATUS status;
 282         const char *host = torture_setting_string(tctx, "host", NULL);
 283         const char *share = torture_setting_string(tctx, "share", NULL);
 284         struct cli_credentials *credentials = cmdline_credentials;
 285         struct smbcli_options options;
 286
 287         lpcfg_smbcli_options(tctx->lp_ctx, &options);
 288         options.use_level2_oplocks = false;
 289
 290         status = smb2_connect(tctx, host,
 291                               lpcfg_smb_ports(tctx->lp_ctx), share,
 292                               lpcfg_resolve_context(tctx->lp_ctx),
 293                               credentials, tree, tctx->ev, &options,
 294                               lpcfg_socket_options(tctx->lp_ctx),
 295                               lpcfg_gensec_settings(tctx, tctx->lp_ctx));
 296         if (!NT_STATUS_IS_OK(status)) {
 297                 torture_comment(tctx, "Failed to connect to SMB2 share "
 298                                 "\\\\%s\\%s - %s\n", host, share,
 299                                 nt_errstr(status));
 300                 return false;
 301         }
 302         return true;
 303 }
 304
 305 /*
 306    Timer handler function notifies the registering function that time is up
 307 */
 308 static void timeout_cb(struct tevent_context *ev,
 309                        struct tevent_timer *te,
 310                        struct timeval current_time,
 311                        void *private_data)
 312 {
 313         bool *timesup = (bool *)private_data;
 314         *timesup = true;
 315         return;
 316 }
 317
 318 /*
 319    Wait a short period of time to receive a single oplock break request
 320 */
 321 static void torture_wait_for_oplock_break(struct torture_context *tctx)
 322 {
 323         TALLOC_CTX *tmp_ctx = talloc_new(NULL);
 324         struct tevent_timer *te = NULL;
 325         struct timeval ne;
 326         bool timesup = false;
 327         int old_count = break_info.count;
 328
 329         /* Wait .1 seconds for an oplock break */
 330         ne = tevent_timeval_current_ofs(0, 100000);
 331
 332         if ((te = event_add_timed(tctx->ev, tmp_ctx, ne, timeout_cb, &timesup))
 333             == NULL)
 334         {
 335                 torture_comment(tctx, "Failed to wait for an oplock break. "
 336                                       "test results may not be accurate.");
 337                 goto done;
 338         }
 339
 340         while (!timesup && break_info.count < old_count + 1) {
 341                 if (event_loop_once(tctx->ev) != 0) {
 342                         torture_comment(tctx, "Failed to wait for an oplock "
 343                                               "break. test results may not be "
 344                                               "accurate.");
 345                         goto done;
 346                 }
 347         }
 348
 349 done:
 350         /* We don't know if the timed event fired and was freed, we received
 351          * our oplock break, or some other event triggered the loop.  Thus,
 352          * we create a tmp_ctx to be able to safely free/remove the timed
 353          * event in all 3 cases. */
 354         talloc_free(tmp_ctx);
 355
 356         return;
 357 }
 358
 359 static bool test_smb2_oplock_exclusive1(struct torture_context *tctx,
 360                                         struct smb2_tree *tree1,
 361                                         struct smb2_tree *tree2)
 362 {
 363         const char *fname = BASEDIR "\\test_exclusive1.dat";
 364         NTSTATUS status;
 365         bool ret = true;
 366         union smb_open io;
 367         union smb_unlink unl;
 368         struct smb2_handle h1;
 369         struct smb2_handle h;
 370
 371         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 372         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 373
 374         /* cleanup */
 375         smb2_util_unlink(tree1, fname);
 376
 377         tree1->session->transport->oplock.handler = torture_oplock_handler;
 378         tree1->session->transport->oplock.private_data = tree1;
 379
 380         /*
 381           base ntcreatex parms
 382         */
 383         ZERO_STRUCT(io.smb2);
 384         io.generic.level = RAW_OPEN_SMB2;
 385         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 386         io.smb2.in.alloc_size = 0;
 387         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 388         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 389         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 390         io.smb2.in.create_options = 0;
 391         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 392         io.smb2.in.security_flags = 0;
 393         io.smb2.in.fname = fname;
 394
 395         torture_comment(tctx, "EXCLUSIVE1: open a file with an exclusive "
 396                         "oplock (share mode: none)\n");
 397         ZERO_STRUCT(break_info);
 398         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 399
 400         status = smb2_create(tree1, tctx, &(io.smb2));
 401         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 402         h1 = io.smb2.out.file.handle;
 403         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
 404
 405         torture_comment(tctx, "a 2nd open should not cause a break\n");
 406         status = smb2_create(tree2, tctx, &(io.smb2));
 407         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
 408                                       "Incorrect status");
 409         torture_wait_for_oplock_break(tctx);
 410         CHECK_VAL(break_info.count, 0);
 411         CHECK_VAL(break_info.failures, 0);
 412
 413         torture_comment(tctx, "unlink it - should also be no break\n");
 414         unl.unlink.in.pattern = fname;
 415         unl.unlink.in.attrib = 0;
 416         status = smb2_util_unlink(tree2, fname);
 417         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
 418                                       "Incorrect status");
 419         torture_wait_for_oplock_break(tctx);
 420         CHECK_VAL(break_info.count, 0);
 421         CHECK_VAL(break_info.failures, 0);
 422
 423         smb2_util_close(tree1, h1);
 424         smb2_util_close(tree1, h);
 425
 426         smb2_deltree(tree1, BASEDIR);
 427         return ret;
 428 }
 429
 430 static bool test_smb2_oplock_exclusive2(struct torture_context *tctx,
 431                                         struct smb2_tree *tree1,
 432                                         struct smb2_tree *tree2)
 433 {
 434         const char *fname = BASEDIR "\\test_exclusive2.dat";
 435         NTSTATUS status;
 436         bool ret = true;
 437         union smb_open io;
 438         union smb_unlink unl;
 439         struct smb2_handle h, h1, h2;
 440
 441         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 442         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 443
 444         /* cleanup */
 445         smb2_util_unlink(tree1, fname);
 446
 447         tree1->session->transport->oplock.handler = torture_oplock_handler;
 448         tree1->session->transport->oplock.private_data = tree1;
 449
 450         /*
 451           base ntcreatex parms
 452         */
 453         ZERO_STRUCT(io.smb2);
 454         io.generic.level = RAW_OPEN_SMB2;
 455         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 456         io.smb2.in.alloc_size = 0;
 457         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 458         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 459         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 460         io.smb2.in.create_options = 0;
 461         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 462         io.smb2.in.security_flags = 0;
 463         io.smb2.in.fname = fname;
 464
 465         torture_comment(tctx, "EXCLUSIVE2: open a file with an exclusive "
 466                         "oplock (share mode: all)\n");
 467         ZERO_STRUCT(break_info);
 468         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 469         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
 470                 NTCREATEX_SHARE_ACCESS_WRITE|
 471                 NTCREATEX_SHARE_ACCESS_DELETE;
 472         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 473
 474         status = smb2_create(tree1, tctx, &(io.smb2));
 475         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 476         h1 = io.smb2.out.file.handle;
 477         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
 478
 479         torture_comment(tctx, "a 2nd open should cause a break to level 2\n");
 480         status = smb2_create(tree2, tctx, &(io.smb2));
 481         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 482         h2 = io.smb2.out.file.handle;
 483         torture_wait_for_oplock_break(tctx);
 484         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
 485         CHECK_VAL(break_info.count, 1);
 486         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
 487         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
 488         CHECK_VAL(break_info.failures, 0);
 489         ZERO_STRUCT(break_info);
 490
 491         /* now we have 2 level II oplocks... */
 492         torture_comment(tctx, "try to unlink it - should cause a break\n");
 493         unl.unlink.in.pattern = fname;
 494         unl.unlink.in.attrib = 0;
 495         status = smb2_util_unlink(tree2, fname);
 496         torture_assert_ntstatus_ok(tctx, status, "Error unlinking the file");
 497         torture_wait_for_oplock_break(tctx);
 498         CHECK_VAL(break_info.count, 0);
 499         CHECK_VAL(break_info.failures, 0);
 500
 501         torture_comment(tctx, "close both handles\n");
 502         smb2_util_close(tree1, h1);
 503         smb2_util_close(tree1, h2);
 504         smb2_util_close(tree1, h);
 505
 506         smb2_deltree(tree1, BASEDIR);
 507         return ret;
 508 }
 509
 510 static bool test_smb2_oplock_exclusive3(struct torture_context *tctx,
 511                                         struct smb2_tree *tree1,
 512                                         struct smb2_tree *tree2)
 513 {
 514         const char *fname = BASEDIR "\\test_exclusive3.dat";
 515         NTSTATUS status;
 516         bool ret = true;
 517         union smb_open io;
 518         union smb_setfileinfo sfi;
 519         struct smb2_handle h, h1;
 520
 521         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 522         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 523
 524         /* cleanup */
 525         smb2_util_unlink(tree1, fname);
 526
 527         tree1->session->transport->oplock.handler = torture_oplock_handler;
 528         tree1->session->transport->oplock.private_data = tree1;
 529
 530         /*
 531           base ntcreatex parms
 532         */
 533         ZERO_STRUCT(io.smb2);
 534         io.generic.level = RAW_OPEN_SMB2;
 535         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 536         io.smb2.in.alloc_size = 0;
 537         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 538         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 539         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 540         io.smb2.in.create_options = 0;
 541         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 542         io.smb2.in.security_flags = 0;
 543         io.smb2.in.fname = fname;
 544
 545         torture_comment(tctx, "EXCLUSIVE3: open a file with an exclusive "
 546                         "oplock (share mode: none)\n");
 547
 548         ZERO_STRUCT(break_info);
 549         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 550         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 551
 552         status = smb2_create(tree1, tctx, &(io.smb2));
 553         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 554         h1 = io.smb2.out.file.handle;
 555         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
 556
 557         torture_comment(tctx, "setpathinfo EOF should trigger a break to "
 558                         "none\n");
 559         ZERO_STRUCT(sfi);
 560         sfi.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
 561         sfi.generic.in.file.path = fname;
 562         sfi.end_of_file_info.in.size = 100;
 563
 564         status = smb2_composite_setpathinfo(tree2, &sfi);
 565
 566         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
 567                                       "Incorrect status");
 568         torture_wait_for_oplock_break(tctx);
 569         CHECK_VAL(break_info.count, 0);
 570         CHECK_VAL(break_info.failures, 0);
 571         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
 572
 573         smb2_util_close(tree1, h1);
 574         smb2_util_close(tree1, h);
 575
 576         smb2_deltree(tree1, BASEDIR);
 577         return ret;
 578 }
 579
 580 static bool test_smb2_oplock_exclusive4(struct torture_context *tctx,
 581                                         struct smb2_tree *tree1,
 582                                         struct smb2_tree *tree2)
 583 {
 584         const char *fname = BASEDIR "\\test_exclusive4.dat";
 585         NTSTATUS status;
 586         bool ret = true;
 587         union smb_open io;
 588         struct smb2_handle h, h1, h2;
 589
 590         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 591         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 592
 593         /* cleanup */
 594         smb2_util_unlink(tree1, fname);
 595
 596         tree1->session->transport->oplock.handler = torture_oplock_handler;
 597         tree1->session->transport->oplock.private_data = tree1;
 598
 599         /*
 600           base ntcreatex parms
 601         */
 602         ZERO_STRUCT(io.smb2);
 603         io.generic.level = RAW_OPEN_SMB2;
 604         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 605         io.smb2.in.alloc_size = 0;
 606         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 607         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 608         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 609         io.smb2.in.create_options = 0;
 610         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 611         io.smb2.in.security_flags = 0;
 612         io.smb2.in.fname = fname;
 613
 614         torture_comment(tctx, "EXCLUSIVE4: open with exclusive oplock\n");
 615         ZERO_STRUCT(break_info);
 616
 617         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 618         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 619         status = smb2_create(tree1, tctx, &(io.smb2));
 620         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 621         h1 = io.smb2.out.file.handle;
 622         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
 623
 624         ZERO_STRUCT(break_info);
 625         torture_comment(tctx, "second open with attributes only shouldn't "
 626                         "cause oplock break\n");
 627
 628         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 629         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
 630                                 SEC_FILE_WRITE_ATTRIBUTE |
 631                                 SEC_STD_SYNCHRONIZE;
 632         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 633         status = smb2_create(tree2, tctx, &(io.smb2));
 634         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
 635         h2 = io.smb2.out.file.handle;
 636         CHECK_VAL(io.smb2.out.oplock_level, NO_OPLOCK_RETURN);
 637         torture_wait_for_oplock_break(tctx);
 638         CHECK_VAL(break_info.count, 0);
 639         CHECK_VAL(break_info.failures, 0);
 640
 641         smb2_util_close(tree1, h1);
 642         smb2_util_close(tree2, h2);
 643         smb2_util_close(tree1, h);
 644
 645         smb2_deltree(tree1, BASEDIR);
 646         return ret;
 647 }
 648
 649 static bool test_smb2_oplock_exclusive5(struct torture_context *tctx,
 650                                         struct smb2_tree *tree1,
 651                                         struct smb2_tree *tree2)
 652 {
 653         const char *fname = BASEDIR "\\test_exclusive5.dat";
 654         NTSTATUS status;
 655         bool ret = true;
 656         union smb_open io;
 657         struct smb2_handle h, h1, h2;
 658
 659         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 660         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 661
 662         /* cleanup */
 663         smb2_util_unlink(tree1, fname);
 664
 665         tree1->session->transport->oplock.handler = torture_oplock_handler;
 666         tree1->session->transport->oplock.private_data = tree1;
 667
 668         tree2->session->transport->oplock.handler = torture_oplock_handler;
 669         tree2->session->transport->oplock.private_data = tree2;
 670
 671         /*
 672           base ntcreatex parms
 673         */
 674         ZERO_STRUCT(io.smb2);
 675         io.generic.level = RAW_OPEN_SMB2;
 676         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 677         io.smb2.in.alloc_size = 0;
 678         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 679         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 680         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 681         io.smb2.in.create_options = 0;
 682         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 683         io.smb2.in.security_flags = 0;
 684         io.smb2.in.fname = fname;
 685
 686         torture_comment(tctx, "EXCLUSIVE5: open with exclusive oplock\n");
 687         ZERO_STRUCT(break_info);
 688
 689         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 690         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
 691                 NTCREATEX_SHARE_ACCESS_WRITE|
 692                 NTCREATEX_SHARE_ACCESS_DELETE;
 693         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 694         status = smb2_create(tree1, tctx, &(io.smb2));
 695         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 696         h1 = io.smb2.out.file.handle;
 697         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
 698
 699         ZERO_STRUCT(break_info);
 700
 701         torture_comment(tctx, "second open with attributes only and "
 702                         "NTCREATEX_DISP_OVERWRITE_IF dispostion causes "
 703                         "oplock break\n");
 704
 705         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 706         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
 707                                 SEC_FILE_WRITE_ATTRIBUTE |
 708                                 SEC_STD_SYNCHRONIZE;
 709         io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
 710         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_II;
 711         status = smb2_create(tree2, tctx, &(io.smb2));
 712         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
 713         h2 = io.smb2.out.file.handle;
 714         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
 715         torture_wait_for_oplock_break(tctx);
 716         CHECK_VAL(break_info.count, 1);
 717         CHECK_VAL(break_info.failures, 0);
 718
 719         smb2_util_close(tree1, h1);
 720         smb2_util_close(tree2, h2);
 721         smb2_util_close(tree1, h);
 722
 723         smb2_deltree(tree1, BASEDIR);
 724         return ret;
 725 }
 726
 727 static bool test_smb2_oplock_exclusive6(struct torture_context *tctx,
 728                                         struct smb2_tree *tree1,
 729                                         struct smb2_tree *tree2)
 730 {
 731         const char *fname1 = BASEDIR "\\test_exclusive6_1.dat";
 732         const char *fname2 = BASEDIR "\\test_exclusive6_2.dat";
 733         NTSTATUS status;
 734         bool ret = true;
 735         union smb_open io;
 736         union smb_setfileinfo sinfo;
 737         struct smb2_handle h, h1;
 738
 739         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 740         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 741
 742         /* cleanup */
 743         smb2_util_unlink(tree1, fname1);
 744         smb2_util_unlink(tree2, fname2);
 745
 746         tree1->session->transport->oplock.handler = torture_oplock_handler;
 747         tree1->session->transport->oplock.private_data = tree1;
 748
 749         /*
 750           base ntcreatex parms
 751         */
 752         ZERO_STRUCT(io.smb2);
 753         io.generic.level = RAW_OPEN_SMB2;
 754         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 755         io.smb2.in.alloc_size = 0;
 756         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 757         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 758         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 759         io.smb2.in.create_options = 0;
 760         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 761         io.smb2.in.security_flags = 0;
 762         io.smb2.in.fname = fname1;
 763
 764         torture_comment(tctx, "EXCLUSIVE6: open a file with an exclusive "
 765                         "oplock (share mode: none)\n");
 766         ZERO_STRUCT(break_info);
 767         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 768         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
 769
 770         status = smb2_create(tree1, tctx, &(io.smb2));
 771         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 772         h1 = io.smb2.out.file.handle;
 773         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
 774
 775         torture_comment(tctx, "rename should not generate a break but get "
 776                         "a sharing violation\n");
 777         ZERO_STRUCT(sinfo);
 778         sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
 779         sinfo.rename_information.in.file.handle = h1;
 780         sinfo.rename_information.in.overwrite = true;
 781         sinfo.rename_information.in.new_name = fname2;
 782         status = smb2_setinfo_file(tree1, &sinfo);
 783
 784         torture_comment(tctx, "trying rename while first file open\n");
 785         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
 786                                       "Incorrect status");
 787         torture_wait_for_oplock_break(tctx);
 788         CHECK_VAL(break_info.count, 0);
 789         CHECK_VAL(break_info.failures, 0);
 790
 791         smb2_util_close(tree1, h1);
 792         smb2_util_close(tree1, h);
 793
 794         smb2_deltree(tree1, BASEDIR);
 795         return ret;
 796 }
 797
 798 static bool test_smb2_oplock_batch1(struct torture_context *tctx,
 799                                     struct smb2_tree *tree1,
 800                                     struct smb2_tree *tree2)
 801 {
 802         const char *fname = BASEDIR "\\test_batch1.dat";
 803         NTSTATUS status;
 804         bool ret = true;
 805         union smb_open io;
 806         struct smb2_handle h, h1;
 807         char c = 0;
 808
 809         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 810         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 811
 812         /* cleanup */
 813         smb2_util_unlink(tree1, fname);
 814
 815         tree1->session->transport->oplock.handler = torture_oplock_handler;
 816         tree1->session->transport->oplock.private_data = tree1;
 817
 818         /*
 819           base ntcreatex parms
 820         */
 821         ZERO_STRUCT(io.smb2);
 822         io.generic.level = RAW_OPEN_SMB2;
 823         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 824         io.smb2.in.alloc_size = 0;
 825         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 826         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 827         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 828         io.smb2.in.create_options = 0;
 829         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 830         io.smb2.in.security_flags = 0;
 831         io.smb2.in.fname = fname;
 832
 833         /*
 834           with a batch oplock we get a break
 835         */
 836         torture_comment(tctx, "BATCH1: open with batch oplock\n");
 837         ZERO_STRUCT(break_info);
 838         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 839         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
 840         status = smb2_create(tree1, tctx, &(io.smb2));
 841         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 842         h1 = io.smb2.out.file.handle;
 843         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
 844
 845         torture_comment(tctx, "unlink should generate a break\n");
 846         status = smb2_util_unlink(tree2, fname);
 847         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
 848                                       "Incorrect status");
 849
 850         torture_wait_for_oplock_break(tctx);
 851         CHECK_VAL(break_info.count, 1);
 852         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
 853         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
 854         CHECK_VAL(break_info.failures, 0);
 855
 856         torture_comment(tctx, "2nd unlink should not generate a break\n");
 857         ZERO_STRUCT(break_info);
 858         status = smb2_util_unlink(tree2, fname);
 859         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
 860                                       "Incorrect status");
 861
 862         torture_wait_for_oplock_break(tctx);
 863         CHECK_VAL(break_info.count, 0);
 864
 865         torture_comment(tctx, "writing should generate a self break to none\n");
 866         tree1->session->transport->oplock.handler =
 867             torture_oplock_handler_level2_to_none;
 868         smb2_util_write(tree1, h1, &c, 0, 1);
 869
 870         torture_wait_for_oplock_break(tctx);
 871
 872         CHECK_VAL(break_info.count, 1);
 873         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
 874         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_NONE);
 875         CHECK_VAL(break_info.failures, 0);
 876
 877         smb2_util_close(tree1, h1);
 878         smb2_util_close(tree1, h);
 879
 880         smb2_deltree(tree1, BASEDIR);
 881         return ret;
 882 }
 883
 884 static bool test_smb2_oplock_batch2(struct torture_context *tctx,
 885                                     struct smb2_tree *tree1,
 886                                     struct smb2_tree *tree2)
 887 {
 888         const char *fname = BASEDIR "\\test_batch2.dat";
 889         NTSTATUS status;
 890         bool ret = true;
 891         union smb_open io;
 892         char c = 0;
 893         struct smb2_handle h, h1;
 894
 895         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 896         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 897
 898         /* cleanup */
 899         smb2_util_unlink(tree1, fname);
 900
 901         tree1->session->transport->oplock.handler = torture_oplock_handler;
 902         tree1->session->transport->oplock.private_data = tree1;
 903
 904         /*
 905           base ntcreatex parms
 906         */
 907         ZERO_STRUCT(io.smb2);
 908         io.generic.level = RAW_OPEN_SMB2;
 909         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 910         io.smb2.in.alloc_size = 0;
 911         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 912         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 913         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 914         io.smb2.in.create_options = 0;
 915         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 916         io.smb2.in.security_flags = 0;
 917         io.smb2.in.fname = fname;
 918
 919         torture_comment(tctx, "BATCH2: open with batch oplock\n");
 920         ZERO_STRUCT(break_info);
 921         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
 922         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
 923         status = smb2_create(tree1, tctx, &(io.smb2));
 924         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
 925         h1 = io.smb2.out.file.handle;
 926         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
 927
 928         torture_comment(tctx, "unlink should generate a break, which we ack "
 929                         "as break to none\n");
 930         tree1->session->transport->oplock.handler =
 931                                 torture_oplock_handler_ack_to_none;
 932         tree1->session->transport->oplock.private_data = tree1;
 933         status = smb2_util_unlink(tree2, fname);
 934         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
 935                                      "Incorrect status");
 936
 937         torture_wait_for_oplock_break(tctx);
 938         CHECK_VAL(break_info.count, 1);
 939         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
 940         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
 941         CHECK_VAL(break_info.failures, 0);
 942
 943         torture_comment(tctx, "2nd unlink should not generate a break\n");
 944         ZERO_STRUCT(break_info);
 945         status = smb2_util_unlink(tree2, fname);
 946         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
 947                                       "Incorrect status");
 948
 949         torture_wait_for_oplock_break(tctx);
 950         CHECK_VAL(break_info.count, 0);
 951
 952         torture_comment(tctx, "writing should not generate a break\n");
 953         smb2_util_write(tree1, h1, &c, 0, 1);
 954
 955         torture_wait_for_oplock_break(tctx);
 956         CHECK_VAL(break_info.count, 0);
 957
 958         smb2_util_close(tree1, h1);
 959         smb2_util_close(tree1, h);
 960
 961         smb2_deltree(tree1, BASEDIR);
 962         return ret;
 963 }
 964
 965 static bool test_smb2_oplock_batch3(struct torture_context *tctx,
 966                                     struct smb2_tree *tree1,
 967                                     struct smb2_tree *tree2)
 968 {
 969         const char *fname = BASEDIR "\\test_batch3.dat";
 970         NTSTATUS status;
 971         bool ret = true;
 972         union smb_open io;
 973         struct smb2_handle h, h1;
 974
 975         status = torture_smb2_testdir(tree1, BASEDIR, &h);
 976         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
 977
 978         /* cleanup */
 979         smb2_util_unlink(tree1, fname);
 980         tree1->session->transport->oplock.handler = torture_oplock_handler;
 981         tree1->session->transport->oplock.private_data = tree1;
 982
 983         /*
 984           base ntcreatex parms
 985         */
 986         ZERO_STRUCT(io.smb2);
 987         io.generic.level = RAW_OPEN_SMB2;
 988         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
 989         io.smb2.in.alloc_size = 0;
 990         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
 991         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 992         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
 993         io.smb2.in.create_options = 0;
 994         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
 995         io.smb2.in.security_flags = 0;
 996         io.smb2.in.fname = fname;
 997
 998         torture_comment(tctx, "BATCH3: if we close on break then the unlink "
 999                         "can succeed\n");
1000         ZERO_STRUCT(break_info);
1001         tree1->session->transport->oplock.handler =
1002                                         torture_oplock_handler_close;
1003         tree1->session->transport->oplock.private_data = tree1;
1004
1005         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1006         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1007         status = smb2_create(tree1, tctx, &(io.smb2));
1008         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1009         h1 = io.smb2.out.file.handle;
1010         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1011
1012         ZERO_STRUCT(break_info);
1013         status = smb2_util_unlink(tree2, fname);
1014         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1015
1016         torture_wait_for_oplock_break(tctx);
1017         CHECK_VAL(break_info.count, 1);
1018         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
1019         CHECK_VAL(break_info.level, 1);
1020         CHECK_VAL(break_info.failures, 0);
1021
1022         smb2_util_close(tree1, h1);
1023         smb2_util_close(tree1, h);
1024
1025         smb2_deltree(tree1, BASEDIR);
1026         return ret;
1027 }
1028
1029 static bool test_smb2_oplock_batch4(struct torture_context *tctx,
1030                                     struct smb2_tree *tree1,
1031                                     struct smb2_tree *tree2)
1032 {
1033         const char *fname = BASEDIR "\\test_batch4.dat";
1034         NTSTATUS status;
1035         bool ret = true;
1036         union smb_open io;
1037         struct smb2_read r;
1038         struct smb2_handle h, h1;
1039
1040         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1041         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1042
1043         /* cleanup */
1044         smb2_util_unlink(tree1, fname);
1045
1046         tree1->session->transport->oplock.handler = torture_oplock_handler;
1047         tree1->session->transport->oplock.private_data = tree1;
1048
1049         /*
1050           base ntcreatex parms
1051         */
1052         ZERO_STRUCT(io.smb2);
1053         io.generic.level = RAW_OPEN_SMB2;
1054         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1055         io.smb2.in.alloc_size = 0;
1056         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1057         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1058         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1059         io.smb2.in.create_options = 0;
1060         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1061         io.smb2.in.security_flags = 0;
1062         io.smb2.in.fname = fname;
1063
1064         torture_comment(tctx, "BATCH4: a self read should not cause a break\n");
1065         ZERO_STRUCT(break_info);
1066
1067         tree1->session->transport->oplock.handler = torture_oplock_handler;
1068         tree1->session->transport->oplock.private_data = tree1;
1069
1070         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1071         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1072         status = smb2_create(tree1, tctx, &(io.smb2));
1073         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1074         h1 = io.smb2.out.file.handle;
1075         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1076
1077         ZERO_STRUCT(r);
1078         r.in.file.handle = h1;
1079         r.in.offset      = 0;
1080
1081         status = smb2_read(tree1, tree1, &r);
1082         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1083         torture_wait_for_oplock_break(tctx);
1084         CHECK_VAL(break_info.count, 0);
1085         CHECK_VAL(break_info.failures, 0);
1086
1087         smb2_util_close(tree1, h1);
1088         smb2_util_close(tree1, h);
1089
1090         smb2_deltree(tree1, BASEDIR);
1091         return ret;
1092 }
1093
1094 static bool test_smb2_oplock_batch5(struct torture_context *tctx,
1095                                     struct smb2_tree *tree1,
1096                                     struct smb2_tree *tree2)
1097 {
1098         const char *fname = BASEDIR "\\test_batch5.dat";
1099         NTSTATUS status;
1100         bool ret = true;
1101         union smb_open io;
1102         struct smb2_handle h, h1;
1103
1104         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1105         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1106
1107         /* cleanup */
1108         smb2_util_unlink(tree1, fname);
1109
1110         tree1->session->transport->oplock.handler = torture_oplock_handler;
1111         tree1->session->transport->oplock.private_data = tree1;
1112
1113         /*
1114           base ntcreatex parms
1115         */
1116         ZERO_STRUCT(io.smb2);
1117         io.generic.level = RAW_OPEN_SMB2;
1118         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1119         io.smb2.in.alloc_size = 0;
1120         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1121         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1122         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1123         io.smb2.in.create_options = 0;
1124         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1125         io.smb2.in.security_flags = 0;
1126         io.smb2.in.fname = fname;
1127
1128         torture_comment(tctx, "BATCH5: a 2nd open should give a break\n");
1129         ZERO_STRUCT(break_info);
1130
1131         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1132         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1133         status = smb2_create(tree1, tctx, &(io.smb2));
1134         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1135         h1 = io.smb2.out.file.handle;
1136         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1137
1138         ZERO_STRUCT(break_info);
1139
1140         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1141         status = smb2_create(tree2, tctx, &(io.smb2));
1142         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
1143                                       "Incorrect status");
1144
1145         torture_wait_for_oplock_break(tctx);
1146         CHECK_VAL(break_info.count, 1);
1147         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
1148         CHECK_VAL(break_info.level, 1);
1149         CHECK_VAL(break_info.failures, 0);
1150
1151         smb2_util_close(tree1, h1);
1152         smb2_util_close(tree1, h);
1153
1154         smb2_deltree(tree1, BASEDIR);
1155         return ret;
1156 }
1157
1158 static bool test_smb2_oplock_batch6(struct torture_context *tctx,
1159                                     struct smb2_tree *tree1,
1160                                     struct smb2_tree *tree2)
1161 {
1162         const char *fname = BASEDIR "\\test_batch6.dat";
1163         NTSTATUS status;
1164         bool ret = true;
1165         union smb_open io;
1166         struct smb2_handle h, h1, h2;
1167         char c = 0;
1168
1169         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1170         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1171
1172         /* cleanup */
1173         smb2_util_unlink(tree1, fname);
1174
1175         tree1->session->transport->oplock.handler = torture_oplock_handler;
1176         tree1->session->transport->oplock.private_data = tree1;
1177
1178         /*
1179           base ntcreatex parms
1180         */
1181         ZERO_STRUCT(io.smb2);
1182         io.generic.level = RAW_OPEN_SMB2;
1183         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1184         io.smb2.in.alloc_size = 0;
1185         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1186         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1187         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1188         io.smb2.in.create_options = 0;
1189         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1190         io.smb2.in.security_flags = 0;
1191         io.smb2.in.fname = fname;
1192
1193         torture_comment(tctx, "BATCH6: a 2nd open should give a break to "
1194                         "level II if the first open allowed shared read\n");
1195         ZERO_STRUCT(break_info);
1196         tree2->session->transport->oplock.handler = torture_oplock_handler;
1197         tree2->session->transport->oplock.private_data = tree2;
1198
1199         io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
1200                                 SEC_RIGHTS_FILE_WRITE;
1201         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1202                                 NTCREATEX_SHARE_ACCESS_WRITE;
1203         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1204         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1205         status = smb2_create(tree1, tctx, &(io.smb2));
1206         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1207         h1 = io.smb2.out.file.handle;
1208         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1209
1210         ZERO_STRUCT(break_info);
1211
1212         status = smb2_create(tree2, tctx, &(io.smb2));
1213         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1214         h2 = io.smb2.out.file.handle;
1215         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
1216
1217         torture_wait_for_oplock_break(tctx);
1218         CHECK_VAL(break_info.count, 1);
1219         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
1220         CHECK_VAL(break_info.level, 1);
1221         CHECK_VAL(break_info.failures, 0);
1222         ZERO_STRUCT(break_info);
1223
1224         torture_comment(tctx, "write should trigger a break to none on both\n");
1225         tree1->session->transport->oplock.handler =
1226             torture_oplock_handler_level2_to_none;
1227         tree2->session->transport->oplock.handler =
1228             torture_oplock_handler_level2_to_none;
1229         smb2_util_write(tree1, h1, &c, 0, 1);
1230
1231         /* We expect two breaks */
1232         torture_wait_for_oplock_break(tctx);
1233         torture_wait_for_oplock_break(tctx);
1234
1235         CHECK_VAL(break_info.count, 2);
1236         CHECK_VAL(break_info.level, 0);
1237         CHECK_VAL(break_info.failures, 0);
1238
1239         smb2_util_close(tree1, h1);
1240         smb2_util_close(tree2, h2);
1241         smb2_util_close(tree1, h);
1242
1243         smb2_deltree(tree1, BASEDIR);
1244         return ret;
1245 }
1246
1247 static bool test_smb2_oplock_batch7(struct torture_context *tctx,
1248                                     struct smb2_tree *tree1,
1249                                     struct smb2_tree *tree2)
1250 {
1251         const char *fname = BASEDIR "\\test_batch7.dat";
1252         NTSTATUS status;
1253         bool ret = true;
1254         union smb_open io;
1255         struct smb2_handle h, h1, h2;
1256
1257         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1258         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1259
1260         /* cleanup */
1261         smb2_util_unlink(tree1, fname);
1262
1263         tree1->session->transport->oplock.handler = torture_oplock_handler;
1264         tree1->session->transport->oplock.private_data = tree1;
1265
1266         /*
1267           base ntcreatex parms
1268         */
1269         ZERO_STRUCT(io.smb2);
1270         io.generic.level = RAW_OPEN_SMB2;
1271         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1272         io.smb2.in.alloc_size = 0;
1273         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1274         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1275         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1276         io.smb2.in.create_options = 0;
1277         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1278         io.smb2.in.security_flags = 0;
1279         io.smb2.in.fname = fname;
1280
1281         torture_comment(tctx, "BATCH7: a 2nd open should get an oplock when "
1282                         "we close instead of ack\n");
1283         ZERO_STRUCT(break_info);
1284         tree1->session->transport->oplock.handler =
1285                         torture_oplock_handler_close;
1286         tree1->session->transport->oplock.private_data = tree1;
1287
1288         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1289         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1290         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1291         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1292         status = smb2_create(tree1, tctx, &(io.smb2));
1293         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1294         h2 = io.smb2.out.file.handle;
1295         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1296
1297         ZERO_STRUCT(break_info);
1298
1299         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1300         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1301         status = smb2_create(tree2, tctx, &(io.smb2));
1302         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1303         h1 = io.smb2.out.file.handle;
1304         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1305
1306         torture_wait_for_oplock_break(tctx);
1307         CHECK_VAL(break_info.count, 1);
1308         CHECK_VAL(break_info.handle.data[0], h2.data[0]);
1309         CHECK_VAL(break_info.level, 1);
1310         CHECK_VAL(break_info.failures, 0);
1311
1312         smb2_util_close(tree2, h1);
1313         smb2_util_close(tree2, h);
1314
1315         smb2_deltree(tree1, BASEDIR);
1316         return ret;
1317 }
1318
1319 static bool test_smb2_oplock_batch8(struct torture_context *tctx,
1320                                     struct smb2_tree *tree1,
1321                                     struct smb2_tree *tree2)
1322 {
1323         const char *fname = BASEDIR "\\test_batch8.dat";
1324         NTSTATUS status;
1325         bool ret = true;
1326         union smb_open io;
1327         struct smb2_handle h, h1, h2;
1328
1329         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1330         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1331
1332         /* cleanup */
1333         smb2_util_unlink(tree1, fname);
1334
1335         tree1->session->transport->oplock.handler = torture_oplock_handler;
1336         tree1->session->transport->oplock.private_data = tree1;
1337
1338         /*
1339           base ntcreatex parms
1340         */
1341         ZERO_STRUCT(io.smb2);
1342         io.generic.level = RAW_OPEN_SMB2;
1343         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1344         io.smb2.in.alloc_size = 0;
1345         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1346         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1347         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1348         io.smb2.in.create_options = 0;
1349         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1350         io.smb2.in.security_flags = 0;
1351         io.smb2.in.fname = fname;
1352
1353         torture_comment(tctx, "BATCH8: open with batch oplock\n");
1354         ZERO_STRUCT(break_info);
1355
1356         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1357         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1358         status = smb2_create(tree1, tctx, &(io.smb2));
1359         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1360         h1 = io.smb2.out.file.handle;
1361         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1362
1363         ZERO_STRUCT(break_info);
1364         torture_comment(tctx, "second open with attributes only shouldn't "
1365                         "cause oplock break\n");
1366
1367         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1368         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
1369                                 SEC_FILE_WRITE_ATTRIBUTE |
1370                                 SEC_STD_SYNCHRONIZE;
1371         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1372         status = smb2_create(tree2, tctx, &(io.smb2));
1373         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1374         h2 = io.smb2.out.file.handle;
1375         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
1376         torture_wait_for_oplock_break(tctx);
1377         CHECK_VAL(break_info.count, 0);
1378         CHECK_VAL(break_info.failures, 0);
1379
1380         smb2_util_close(tree1, h1);
1381         smb2_util_close(tree2, h2);
1382         smb2_util_close(tree1, h);
1383
1384         smb2_deltree(tree1, BASEDIR);
1385         return ret;
1386 }
1387
1388 static bool test_smb2_oplock_batch9(struct torture_context *tctx,
1389                                      struct smb2_tree *tree1,
1390                                      struct smb2_tree *tree2)
1391 {
1392         const char *fname = BASEDIR "\\test_batch9.dat";
1393         NTSTATUS status;
1394         bool ret = true;
1395         union smb_open io;
1396         struct smb2_handle h, h1, h2;
1397         char c = 0;
1398
1399         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1400         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1401
1402         /* cleanup */
1403         smb2_util_unlink(tree1, fname);
1404
1405         tree1->session->transport->oplock.handler = torture_oplock_handler;
1406         tree1->session->transport->oplock.private_data = tree1;
1407
1408         /*
1409           base ntcreatex parms
1410         */
1411         ZERO_STRUCT(io.smb2);
1412         io.generic.level = RAW_OPEN_SMB2;
1413         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1414         io.smb2.in.alloc_size = 0;
1415         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1416         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1417         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1418         io.smb2.in.create_options = 0;
1419         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1420         io.smb2.in.security_flags = 0;
1421         io.smb2.in.fname = fname;
1422
1423         torture_comment(tctx, "BATCH9: open with attributes only can create "
1424                         "file\n");
1425
1426         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1427         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1428         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
1429                                 SEC_FILE_WRITE_ATTRIBUTE |
1430                                 SEC_STD_SYNCHRONIZE;
1431         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1432         status = smb2_create(tree1, tctx, &(io.smb2));
1433         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1434         h1 = io.smb2.out.file.handle;
1435         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1436
1437         torture_comment(tctx, "Subsequent normal open should break oplock on "
1438                         "attribute only open to level II\n");
1439
1440         ZERO_STRUCT(break_info);
1441
1442         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1443         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1444         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1445         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1446         status = smb2_create(tree2, tctx, &(io.smb2));
1447         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1448         h2 = io.smb2.out.file.handle;
1449         torture_wait_for_oplock_break(tctx);
1450         CHECK_VAL(break_info.count, 1);
1451         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
1452         CHECK_VAL(break_info.failures, 0);
1453         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
1454         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
1455         smb2_util_close(tree2, h2);
1456
1457         torture_comment(tctx, "third oplocked open should grant level2 without "
1458                         "break\n");
1459         ZERO_STRUCT(break_info);
1460
1461         tree2->session->transport->oplock.handler = torture_oplock_handler;
1462         tree2->session->transport->oplock.private_data = tree2;
1463
1464         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1465         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1466         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1467         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1468         status = smb2_create(tree2, tctx, &(io.smb2));
1469         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1470         h2 = io.smb2.out.file.handle;
1471         torture_wait_for_oplock_break(tctx);
1472         CHECK_VAL(break_info.count, 0);
1473         CHECK_VAL(break_info.failures, 0);
1474         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
1475
1476         ZERO_STRUCT(break_info);
1477
1478         torture_comment(tctx, "write should trigger a break to none on both\n");
1479         tree1->session->transport->oplock.handler =
1480             torture_oplock_handler_level2_to_none;
1481         tree2->session->transport->oplock.handler =
1482             torture_oplock_handler_level2_to_none;
1483         smb2_util_write(tree2, h2, &c, 0, 1);
1484
1485         /* We expect two breaks */
1486         torture_wait_for_oplock_break(tctx);
1487         torture_wait_for_oplock_break(tctx);
1488
1489         CHECK_VAL(break_info.count, 2);
1490         CHECK_VAL(break_info.level, 0);
1491         CHECK_VAL(break_info.failures, 0);
1492
1493         smb2_util_close(tree1, h1);
1494         smb2_util_close(tree2, h2);
1495         smb2_util_close(tree1, h);
1496
1497         smb2_deltree(tree1, BASEDIR);
1498         return ret;
1499 }
1500
1501 static bool test_smb2_oplock_batch10(struct torture_context *tctx,
1502                                      struct smb2_tree *tree1,
1503                                      struct smb2_tree *tree2)
1504 {
1505         const char *fname = BASEDIR "\\test_batch10.dat";
1506         NTSTATUS status;
1507         bool ret = true;
1508         union smb_open io;
1509         struct smb2_handle h, h1, h2;
1510
1511         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1512         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1513
1514         /* cleanup */
1515         smb2_util_unlink(tree1, fname);
1516
1517         tree1->session->transport->oplock.handler = torture_oplock_handler;
1518         tree1->session->transport->oplock.private_data = tree1;
1519
1520         /*
1521           base ntcreatex parms
1522         */
1523         ZERO_STRUCT(io.smb2);
1524         io.generic.level = RAW_OPEN_SMB2;
1525         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1526         io.smb2.in.alloc_size = 0;
1527         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1528         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1529         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1530         io.smb2.in.create_options = 0;
1531         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1532         io.smb2.in.security_flags = 0;
1533         io.smb2.in.fname = fname;
1534
1535         torture_comment(tctx, "BATCH10: Open with oplock after a non-oplock "
1536                         "open should grant level2\n");
1537         ZERO_STRUCT(break_info);
1538         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1539         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1540         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1541                 NTCREATEX_SHARE_ACCESS_WRITE|
1542                 NTCREATEX_SHARE_ACCESS_DELETE;
1543         status = smb2_create(tree1, tctx, &(io.smb2));
1544         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1545         h1 = io.smb2.out.file.handle;
1546         torture_wait_for_oplock_break(tctx);
1547         CHECK_VAL(break_info.count, 0);
1548         CHECK_VAL(break_info.failures, 0);
1549         CHECK_VAL(io.smb2.out.oplock_level, 0);
1550
1551         tree2->session->transport->oplock.handler =
1552             torture_oplock_handler_level2_to_none;
1553         tree2->session->transport->oplock.private_data = tree2;
1554
1555         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1556         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1557         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1558         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1559                 NTCREATEX_SHARE_ACCESS_WRITE|
1560                 NTCREATEX_SHARE_ACCESS_DELETE;
1561         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
1562         status = smb2_create(tree2, tctx, &(io.smb2));
1563         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1564         h2 = io.smb2.out.file.handle;
1565         torture_wait_for_oplock_break(tctx);
1566         CHECK_VAL(break_info.count, 0);
1567         CHECK_VAL(break_info.failures, 0);
1568         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
1569
1570         torture_comment(tctx, "write should trigger a break to none\n");
1571         {
1572                 struct smb2_write wr;
1573                 DATA_BLOB data;
1574                 data = data_blob_talloc(tree1, NULL, UINT16_MAX);
1575                 data.data[0] = (const uint8_t)'x';
1576                 ZERO_STRUCT(wr);
1577                 wr.in.file.handle = h1;
1578                 wr.in.offset      = 0;
1579                 wr.in.data        = data;
1580                 status = smb2_write(tree1, &wr);
1581                 torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1582         }
1583
1584         torture_wait_for_oplock_break(tctx);
1585
1586         CHECK_VAL(break_info.count, 1);
1587         CHECK_VAL(break_info.handle.data[0], h2.data[0]);
1588         CHECK_VAL(break_info.level, 0);
1589         CHECK_VAL(break_info.failures, 0);
1590
1591         smb2_util_close(tree1, h1);
1592         smb2_util_close(tree2, h2);
1593         smb2_util_close(tree1, h);
1594
1595         smb2_deltree(tree1, BASEDIR);
1596         return ret;
1597 }
1598
1599 static bool test_smb2_oplock_batch11(struct torture_context *tctx,
1600                                      struct smb2_tree *tree1,
1601                                      struct smb2_tree *tree2)
1602 {
1603         const char *fname = BASEDIR "\\test_batch11.dat";
1604         NTSTATUS status;
1605         bool ret = true;
1606         union smb_open io;
1607         union smb_setfileinfo sfi;
1608         struct smb2_handle h, h1;
1609
1610         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1611         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1612
1613         /* cleanup */
1614         smb2_util_unlink(tree1, fname);
1615
1616         tree1->session->transport->oplock.handler =
1617             torture_oplock_handler_two_notifications;
1618         tree1->session->transport->oplock.private_data = tree1;
1619
1620         /*
1621           base ntcreatex parms
1622         */
1623         ZERO_STRUCT(io.smb2);
1624         io.generic.level = RAW_OPEN_SMB2;
1625         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1626         io.smb2.in.alloc_size = 0;
1627         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1628         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1629         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1630         io.smb2.in.create_options = 0;
1631         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1632         io.smb2.in.security_flags = 0;
1633         io.smb2.in.fname = fname;
1634
1635         /* Test if a set-eof on pathname breaks an exclusive oplock. */
1636         torture_comment(tctx, "BATCH11: Test if setpathinfo set EOF breaks "
1637                         "oplocks.\n");
1638
1639         ZERO_STRUCT(break_info);
1640
1641         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1642         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1643         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1644         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1645                                 NTCREATEX_SHARE_ACCESS_WRITE|
1646                                 NTCREATEX_SHARE_ACCESS_DELETE;
1647         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1648         status = smb2_create(tree1, tctx, &(io.smb2));
1649         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1650         h1 = io.smb2.out.file.handle;
1651         torture_wait_for_oplock_break(tctx);
1652         CHECK_VAL(break_info.count, 0);
1653         CHECK_VAL(break_info.failures, 0);
1654         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1655
1656         ZERO_STRUCT(sfi);
1657         sfi.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
1658         sfi.generic.in.file.path = fname;
1659         sfi.end_of_file_info.in.size = 100;
1660
1661         status = smb2_composite_setpathinfo(tree2, &sfi);
1662         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1663
1664         /* We expect two breaks */
1665         torture_wait_for_oplock_break(tctx);
1666         torture_wait_for_oplock_break(tctx);
1667
1668         CHECK_VAL(break_info.count, 2);
1669         CHECK_VAL(break_info.failures, 0);
1670         CHECK_VAL(break_info.level, 0);
1671
1672         smb2_util_close(tree1, h1);
1673         smb2_util_close(tree1, h);
1674
1675         smb2_deltree(tree1, BASEDIR);
1676         return ret;
1677 }
1678
1679 static bool test_smb2_oplock_batch12(struct torture_context *tctx,
1680                                      struct smb2_tree *tree1,
1681                                      struct smb2_tree *tree2)
1682 {
1683         const char *fname = BASEDIR "\\test_batch12.dat";
1684         NTSTATUS status;
1685         bool ret = true;
1686         union smb_open io;
1687         union smb_setfileinfo sfi;
1688         struct smb2_handle h, h1;
1689
1690         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1691         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1692
1693         /* cleanup */
1694         smb2_util_unlink(tree1, fname);
1695
1696         tree1->session->transport->oplock.handler =
1697             torture_oplock_handler_two_notifications;
1698         tree1->session->transport->oplock.private_data = tree1;
1699
1700         /*
1701           base ntcreatex parms
1702         */
1703         ZERO_STRUCT(io.smb2);
1704         io.generic.level = RAW_OPEN_SMB2;
1705         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1706         io.smb2.in.alloc_size = 0;
1707         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1708         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1709         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1710         io.smb2.in.create_options = 0;
1711         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1712         io.smb2.in.security_flags = 0;
1713         io.smb2.in.fname = fname;
1714
1715         /* Test if a set-allocation size on pathname breaks an exclusive
1716          * oplock. */
1717         torture_comment(tctx, "BATCH12: Test if setpathinfo allocation size "
1718                         "breaks oplocks.\n");
1719
1720         ZERO_STRUCT(break_info);
1721
1722         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1723         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1724         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1725         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1726                                 NTCREATEX_SHARE_ACCESS_WRITE|
1727                                 NTCREATEX_SHARE_ACCESS_DELETE;
1728         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1729         status = smb2_create(tree1, tctx, &(io.smb2));
1730         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1731         h1 = io.smb2.out.file.handle;
1732         torture_wait_for_oplock_break(tctx);
1733         CHECK_VAL(break_info.count, 0);
1734         CHECK_VAL(break_info.failures, 0);
1735         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1736
1737         ZERO_STRUCT(sfi);
1738         sfi.generic.level = RAW_SFILEINFO_ALLOCATION_INFORMATION;
1739         sfi.generic.in.file.path = fname;
1740         sfi.allocation_info.in.alloc_size = 65536 * 8;
1741
1742         status = smb2_composite_setpathinfo(tree2, &sfi);
1743         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1744
1745         /* We expect two breaks */
1746         torture_wait_for_oplock_break(tctx);
1747         torture_wait_for_oplock_break(tctx);
1748
1749         CHECK_VAL(break_info.count, 2);
1750         CHECK_VAL(break_info.failures, 0);
1751         CHECK_VAL(break_info.level, 0);
1752
1753         smb2_util_close(tree1, h1);
1754         smb2_util_close(tree1, h);
1755
1756         smb2_deltree(tree1, BASEDIR);
1757         return ret;
1758 }
1759
1760 static bool test_smb2_oplock_batch13(struct torture_context *tctx,
1761                                      struct smb2_tree *tree1,
1762                                      struct smb2_tree *tree2)
1763 {
1764         const char *fname = BASEDIR "\\test_batch13.dat";
1765         NTSTATUS status;
1766         bool ret = true;
1767         union smb_open io;
1768         struct smb2_handle h, h1, h2;
1769
1770         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1771         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1772
1773         /* cleanup */
1774         smb2_util_unlink(tree1, fname);
1775
1776         tree1->session->transport->oplock.handler = torture_oplock_handler;
1777         tree1->session->transport->oplock.private_data = tree1;
1778
1779         tree2->session->transport->oplock.handler = torture_oplock_handler;
1780         tree2->session->transport->oplock.private_data = tree2;
1781
1782         /*
1783           base ntcreatex parms
1784         */
1785         ZERO_STRUCT(io.smb2);
1786         io.generic.level = RAW_OPEN_SMB2;
1787         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1788         io.smb2.in.alloc_size = 0;
1789         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1790         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1791         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1792         io.smb2.in.create_options = 0;
1793         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1794         io.smb2.in.security_flags = 0;
1795         io.smb2.in.fname = fname;
1796
1797         torture_comment(tctx, "BATCH13: open with batch oplock\n");
1798         ZERO_STRUCT(break_info);
1799
1800         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1801         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1802         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1803                 NTCREATEX_SHARE_ACCESS_WRITE|
1804                 NTCREATEX_SHARE_ACCESS_DELETE;
1805         status = smb2_create(tree1, tctx, &(io.smb2));
1806         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1807         h1 = io.smb2.out.file.handle;
1808         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1809
1810         ZERO_STRUCT(break_info);
1811
1812         torture_comment(tctx, "second open with attributes only and "
1813                         "NTCREATEX_DISP_OVERWRITE dispostion causes "
1814                         "oplock break\n");
1815
1816         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1817         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1818         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
1819                                 SEC_FILE_WRITE_ATTRIBUTE |
1820                                 SEC_STD_SYNCHRONIZE;
1821         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1822                                 NTCREATEX_SHARE_ACCESS_WRITE|
1823                                 NTCREATEX_SHARE_ACCESS_DELETE;
1824         io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
1825         status = smb2_create(tree2, tctx, &(io.smb2));
1826         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1827         h2 = io.smb2.out.file.handle;
1828         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
1829         torture_wait_for_oplock_break(tctx);
1830         CHECK_VAL(break_info.count, 1);
1831         CHECK_VAL(break_info.failures, 0);
1832
1833         smb2_util_close(tree1, h1);
1834         smb2_util_close(tree2, h2);
1835         smb2_util_close(tree1, h);
1836
1837         smb2_deltree(tree1, BASEDIR);
1838
1839         return ret;
1840 }
1841
1842 static bool test_smb2_oplock_batch14(struct torture_context *tctx,
1843                                      struct smb2_tree *tree1,
1844                                      struct smb2_tree *tree2)
1845 {
1846         const char *fname = BASEDIR "\\test_batch14.dat";
1847         NTSTATUS status;
1848         bool ret = true;
1849         union smb_open io;
1850         struct smb2_handle h, h1, h2;
1851
1852         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1853         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1854
1855         /* cleanup */
1856         smb2_util_unlink(tree1, fname);
1857
1858         tree1->session->transport->oplock.handler = torture_oplock_handler;
1859         tree1->session->transport->oplock.private_data = tree1;
1860
1861         /*
1862           base ntcreatex parms
1863         */
1864         ZERO_STRUCT(io.smb2);
1865         io.generic.level = RAW_OPEN_SMB2;
1866         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1867         io.smb2.in.alloc_size = 0;
1868         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1869         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1870         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1871         io.smb2.in.create_options = 0;
1872         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1873         io.smb2.in.security_flags = 0;
1874         io.smb2.in.fname = fname;
1875
1876         torture_comment(tctx, "BATCH14: open with batch oplock\n");
1877         ZERO_STRUCT(break_info);
1878
1879         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1880         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1881         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1882                 NTCREATEX_SHARE_ACCESS_WRITE|
1883                 NTCREATEX_SHARE_ACCESS_DELETE;
1884         status = smb2_create(tree1, tctx, &(io.smb2));
1885         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1886         h1 = io.smb2.out.file.handle;
1887         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1888
1889         ZERO_STRUCT(break_info);
1890
1891         torture_comment(tctx, "second open with attributes only and "
1892                         "NTCREATEX_DISP_SUPERSEDE dispostion causes "
1893                         "oplock break\n");
1894
1895         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1896         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1897         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
1898                                 SEC_FILE_WRITE_ATTRIBUTE |
1899                                 SEC_STD_SYNCHRONIZE;
1900         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1901                                 NTCREATEX_SHARE_ACCESS_WRITE|
1902                                 NTCREATEX_SHARE_ACCESS_DELETE;
1903         io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
1904         status = smb2_create(tree2, tctx, &(io.smb2));
1905         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
1906         h2 = io.smb2.out.file.handle;
1907         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
1908
1909         torture_wait_for_oplock_break(tctx);
1910         CHECK_VAL(break_info.count, 1);
1911         CHECK_VAL(break_info.failures, 0);
1912
1913         smb2_util_close(tree1, h1);
1914         smb2_util_close(tree2, h2);
1915         smb2_util_close(tree1, h);
1916
1917         smb2_deltree(tree1, BASEDIR);
1918         return ret;
1919 }
1920
1921 static bool test_smb2_oplock_batch15(struct torture_context *tctx,
1922                                      struct smb2_tree *tree1,
1923                                      struct smb2_tree *tree2)
1924 {
1925         const char *fname = BASEDIR "\\test_batch15.dat";
1926         NTSTATUS status;
1927         bool ret = true;
1928         union smb_open io;
1929         union smb_fileinfo qfi;
1930         struct smb2_handle h, h1;
1931
1932         status = torture_smb2_testdir(tree1, BASEDIR, &h);
1933         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
1934
1935         /* cleanup */
1936         smb2_util_unlink(tree1, fname);
1937
1938         tree1->session->transport->oplock.handler = torture_oplock_handler;
1939         tree1->session->transport->oplock.private_data = tree1;
1940
1941         /*
1942           base ntcreatex parms
1943         */
1944         ZERO_STRUCT(io.smb2);
1945         io.generic.level = RAW_OPEN_SMB2;
1946         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1947         io.smb2.in.alloc_size = 0;
1948         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1949         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1950         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
1951         io.smb2.in.create_options = 0;
1952         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
1953         io.smb2.in.security_flags = 0;
1954         io.smb2.in.fname = fname;
1955
1956         /* Test if a qpathinfo all info on pathname breaks a batch oplock. */
1957         torture_comment(tctx, "BATCH15: Test if qpathinfo all info breaks "
1958                         "a batch oplock (should not).\n");
1959
1960         ZERO_STRUCT(break_info);
1961
1962         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
1963         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
1964         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
1965         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1966                                 NTCREATEX_SHARE_ACCESS_WRITE|
1967                                 NTCREATEX_SHARE_ACCESS_DELETE;
1968         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
1969         status = smb2_create(tree1, tctx, &(io.smb2));
1970         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
1971         h1 = io.smb2.out.file.handle;
1972
1973         torture_wait_for_oplock_break(tctx);
1974         CHECK_VAL(break_info.count, 0);
1975         CHECK_VAL(break_info.failures, 0);
1976         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1977
1978         ZERO_STRUCT(qfi);
1979         qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
1980         qfi.generic.in.file.handle = h1;
1981         status = smb2_getinfo_file(tree2, tctx, &qfi);
1982
1983         torture_wait_for_oplock_break(tctx);
1984         CHECK_VAL(break_info.count, 0);
1985
1986         smb2_util_close(tree1, h1);
1987         smb2_util_close(tree1, h);
1988
1989         smb2_deltree(tree1, BASEDIR);
1990         return ret;
1991 }
1992
1993 static bool test_smb2_oplock_batch16(struct torture_context *tctx,
1994                                      struct smb2_tree *tree1,
1995                                      struct smb2_tree *tree2)
1996 {
1997         const char *fname = BASEDIR "\\test_batch16.dat";
1998         NTSTATUS status;
1999         bool ret = true;
2000         union smb_open io;
2001         struct smb2_handle h, h1, h2;
2002
2003         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2004         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2005
2006         /* cleanup */
2007         smb2_util_unlink(tree1, fname);
2008
2009         tree1->session->transport->oplock.handler = torture_oplock_handler;
2010         tree1->session->transport->oplock.private_data = tree1;
2011
2012         tree2->session->transport->oplock.handler = torture_oplock_handler;
2013         tree2->session->transport->oplock.private_data = tree2;
2014
2015         /*
2016           base ntcreatex parms
2017         */
2018         ZERO_STRUCT(io.smb2);
2019         io.generic.level = RAW_OPEN_SMB2;
2020         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2021         io.smb2.in.alloc_size = 0;
2022         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2023         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2024         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2025         io.smb2.in.create_options = 0;
2026         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2027         io.smb2.in.security_flags = 0;
2028         io.smb2.in.fname = fname;
2029
2030         torture_comment(tctx, "BATCH16: open with batch oplock\n");
2031         ZERO_STRUCT(break_info);
2032
2033         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2034         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2035         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2036                 NTCREATEX_SHARE_ACCESS_WRITE|
2037                 NTCREATEX_SHARE_ACCESS_DELETE;
2038         status = smb2_create(tree1, tctx, &(io.smb2));
2039         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2040         h1 = io.smb2.out.file.handle;
2041         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2042
2043         ZERO_STRUCT(break_info);
2044
2045         torture_comment(tctx, "second open with attributes only and "
2046                         "NTCREATEX_DISP_OVERWRITE_IF dispostion causes "
2047                         "oplock break\n");
2048
2049         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2050         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2051         io.smb2.in.desired_access = SEC_FILE_READ_ATTRIBUTE |
2052                                 SEC_FILE_WRITE_ATTRIBUTE |
2053                                 SEC_STD_SYNCHRONIZE;
2054         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2055                                 NTCREATEX_SHARE_ACCESS_WRITE|
2056                                 NTCREATEX_SHARE_ACCESS_DELETE;
2057         io.smb2.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
2058         status = smb2_create(tree2, tctx, &(io.smb2));
2059         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2060         h2 = io.smb2.out.file.handle;
2061         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
2062
2063         torture_wait_for_oplock_break(tctx);
2064         CHECK_VAL(break_info.count, 1);
2065         CHECK_VAL(break_info.failures, 0);
2066
2067         smb2_util_close(tree1, h1);
2068         smb2_util_close(tree2, h2);
2069         smb2_util_close(tree1, h);
2070
2071         smb2_deltree(tree1, BASEDIR);
2072         return ret;
2073 }
2074
2075 /* This function is a placeholder for the SMB1 RAW-OPLOCK-BATCH17 test.  Since
2076  * SMB2 doesn't have a RENAME command this test isn't applicable.  However,
2077  * it's much less confusing, when comparing test, to keep the SMB1 and SMB2
2078  * test numbers in sync. */
2079 #if 0
2080 static bool test_raw_oplock_batch17(struct torture_context *tctx,
2081                                     struct smb2_tree *tree1,
2082                                     struct smb2_tree *tree2)
2083 {
2084         return true;
2085 }
2086 #endif
2087
2088 /* This function is a placeholder for the SMB1 RAW-OPLOCK-BATCH18 test.  Since
2089  * SMB2 doesn't have an NTRENAME command this test isn't applicable.  However,
2090  * it's much less confusing, when comparing tests, to keep the SMB1 and SMB2
2091  * test numbers in sync. */
2092 #if 0
2093 static bool test_raw_oplock_batch18(struct torture_context *tctx,
2094                                     struct smb2_tree *tree1,
2095                                     struct smb2_tree *tree2)
2096 {
2097         return true;
2098 }
2099 #endif
2100
2101 static bool test_smb2_oplock_batch19(struct torture_context *tctx,
2102                                      struct smb2_tree *tree1)
2103 {
2104         const char *fname1 = BASEDIR "\\test_batch19_1.dat";
2105         const char *fname2 = BASEDIR "\\test_batch19_2.dat";
2106         NTSTATUS status;
2107         bool ret = true;
2108         union smb_open io;
2109         union smb_fileinfo qfi;
2110         union smb_setfileinfo sfi;
2111         struct smb2_handle h, h1;
2112
2113         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2114         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2115
2116         /* cleanup */
2117         smb2_util_unlink(tree1, fname1);
2118         smb2_util_unlink(tree1, fname2);
2119
2120         tree1->session->transport->oplock.handler = torture_oplock_handler;
2121         tree1->session->transport->oplock.private_data = tree1;
2122
2123         /*
2124           base ntcreatex parms
2125         */
2126         ZERO_STRUCT(io.smb2);
2127         io.generic.level = RAW_OPEN_SMB2;
2128         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2129         io.smb2.in.alloc_size = 0;
2130         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2131         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2132         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2133         io.smb2.in.create_options = 0;
2134         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2135         io.smb2.in.security_flags = 0;
2136         io.smb2.in.fname = fname1;
2137
2138         torture_comment(tctx, "BATCH19: open a file with an batch oplock "
2139                         "(share mode: none)\n");
2140         ZERO_STRUCT(break_info);
2141         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2142         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2143         status = smb2_create(tree1, tctx, &(io.smb2));
2144         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2145         h1 = io.smb2.out.file.handle;
2146         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2147
2148         torture_comment(tctx, "setfileinfo rename info should not trigger "
2149                         "a break but should cause a sharing violation\n");
2150         ZERO_STRUCT(sfi);
2151         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
2152         sfi.generic.in.file.path = fname1;
2153         sfi.rename_information.in.file.handle   = h1;
2154         sfi.rename_information.in.overwrite     = 0;
2155         sfi.rename_information.in.root_fid      = 0;
2156         sfi.rename_information.in.new_name      = fname2;
2157
2158         status = smb2_setinfo_file(tree1, &sfi);
2159
2160         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
2161                                       "Incorrect status");
2162
2163         torture_wait_for_oplock_break(tctx);
2164         CHECK_VAL(break_info.count, 0);
2165
2166         ZERO_STRUCT(qfi);
2167         qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
2168         qfi.generic.in.file.handle = h1;
2169
2170         status = smb2_getinfo_file(tree1, tctx, &qfi);
2171         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2172         CHECK_STRMATCH(qfi.all_info2.out.fname.s, fname1);
2173
2174         smb2_util_close(tree1, h1);
2175         smb2_util_close(tree1, h);
2176
2177         smb2_deltree(tree1, fname1);
2178         smb2_deltree(tree1, fname2);
2179         return ret;
2180 }
2181
2182 static bool test_smb2_oplock_batch20(struct torture_context *tctx,
2183                                      struct smb2_tree *tree1,
2184                                      struct smb2_tree *tree2)
2185 {
2186         const char *fname1 = BASEDIR "\\test_batch20_1.dat";
2187         const char *fname2 = BASEDIR "\\test_batch20_2.dat";
2188         NTSTATUS status;
2189         bool ret = true;
2190         union smb_open io;
2191         union smb_fileinfo qfi;
2192         union smb_setfileinfo sfi;
2193         struct smb2_handle h, h1, h2;
2194
2195         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2196         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2197
2198         /* cleanup */
2199         smb2_util_unlink(tree1, fname1);
2200         smb2_util_unlink(tree1, fname2);
2201
2202         tree1->session->transport->oplock.handler = torture_oplock_handler;
2203         tree1->session->transport->oplock.private_data = tree1;
2204
2205         /*
2206           base ntcreatex parms
2207         */
2208         ZERO_STRUCT(io.smb2);
2209         io.generic.level = RAW_OPEN_SMB2;
2210         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2211         io.smb2.in.alloc_size = 0;
2212         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2213         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2214         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2215         io.smb2.in.create_options = 0;
2216         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2217         io.smb2.in.security_flags = 0;
2218         io.smb2.in.fname = fname1;
2219
2220         torture_comment(tctx, "BATCH20: open a file with an batch oplock "
2221                         "(share mode: all)\n");
2222         ZERO_STRUCT(break_info);
2223         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2224         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2225         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2226                                 NTCREATEX_SHARE_ACCESS_WRITE|
2227                                 NTCREATEX_SHARE_ACCESS_DELETE;
2228         status = smb2_create(tree1, tctx, &(io.smb2));
2229         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2230         h1 = io.smb2.out.file.handle;
2231         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2232
2233         torture_comment(tctx, "setfileinfo rename info should not trigger "
2234                         "a break but should cause a sharing violation\n");
2235         ZERO_STRUCT(sfi);
2236         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
2237         sfi.rename_information.in.file.handle   = h1;
2238         sfi.rename_information.in.overwrite     = 0;
2239         sfi.rename_information.in.new_name      = fname2;
2240
2241         status = smb2_setinfo_file(tree1, &sfi);
2242         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
2243                                       "Incorrect status");
2244
2245         torture_wait_for_oplock_break(tctx);
2246         CHECK_VAL(break_info.count, 0);
2247
2248         ZERO_STRUCT(qfi);
2249         qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
2250         qfi.generic.in.file.handle = h1;
2251
2252         status = smb2_getinfo_file(tree1, tctx, &qfi);
2253         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2254         CHECK_STRMATCH(qfi.all_info2.out.fname.s, fname1);
2255
2256         torture_comment(tctx, "open the file a second time requesting batch "
2257                         "(share mode: all)\n");
2258         ZERO_STRUCT(break_info);
2259         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2260         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2261         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2262                                 NTCREATEX_SHARE_ACCESS_WRITE|
2263                                 NTCREATEX_SHARE_ACCESS_DELETE;
2264         io.smb2.in.fname = fname1;
2265         status = smb2_create(tree2, tctx, &(io.smb2));
2266         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2267         h2 = io.smb2.out.file.handle;
2268         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
2269
2270         torture_wait_for_oplock_break(tctx);
2271         CHECK_VAL(break_info.count, 1);
2272         CHECK_VAL(break_info.failures, 0);
2273         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
2274
2275         torture_comment(tctx, "setfileinfo rename info should not trigger "
2276                         "a break but should cause a sharing violation\n");
2277         ZERO_STRUCT(break_info);
2278         ZERO_STRUCT(sfi);
2279         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
2280         sfi.rename_information.in.file.handle   = h2;
2281         sfi.rename_information.in.overwrite     = 0;
2282         sfi.rename_information.in.new_name      = fname2;
2283
2284         status = smb2_setinfo_file(tree2, &sfi);
2285         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
2286                                       "Incorrect status");
2287
2288         torture_wait_for_oplock_break(tctx);
2289         CHECK_VAL(break_info.count, 0);
2290
2291         ZERO_STRUCT(qfi);
2292         qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
2293         qfi.generic.in.file.handle = h1;
2294
2295         status = smb2_getinfo_file(tree1, tctx, &qfi);
2296         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2297         CHECK_STRMATCH(qfi.all_info2.out.fname.s, fname1);
2298
2299         ZERO_STRUCT(qfi);
2300         qfi.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
2301         qfi.generic.in.file.handle = h2;
2302
2303         status = smb2_getinfo_file(tree2, tctx, &qfi);
2304         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2305         CHECK_STRMATCH(qfi.all_info2.out.fname.s, fname1);
2306
2307         smb2_util_close(tree1, h1);
2308         smb2_util_close(tree2, h2);
2309         smb2_util_close(tree1, h);
2310
2311         smb2_deltree(tree1, fname1);
2312         return ret;
2313 }
2314
2315 static bool test_smb2_oplock_batch21(struct torture_context *tctx,
2316                                      struct smb2_tree *tree1)
2317 {
2318         const char *fname = BASEDIR "\\test_batch21.dat";
2319         NTSTATUS status;
2320         bool ret = true;
2321         union smb_open io;
2322         struct smb2_handle h, h1;
2323         char c = 0;
2324
2325         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2326         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2327
2328         /* cleanup */
2329         smb2_util_unlink(tree1, fname);
2330
2331         tree1->session->transport->oplock.handler = torture_oplock_handler;
2332         tree1->session->transport->oplock.private_data = tree1;
2333
2334         /*
2335           base ntcreatex parms
2336         */
2337         ZERO_STRUCT(io.smb2);
2338         io.generic.level = RAW_OPEN_SMB2;
2339         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2340         io.smb2.in.alloc_size = 0;
2341         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2342         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2343         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2344         io.smb2.in.create_options = 0;
2345         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2346         io.smb2.in.security_flags = 0;
2347         io.smb2.in.fname = fname;
2348
2349         /*
2350           with a batch oplock we get a break
2351         */
2352         torture_comment(tctx, "BATCH21: open with batch oplock\n");
2353         ZERO_STRUCT(break_info);
2354         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2355         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2356         status = smb2_create(tree1, tctx, &(io.smb2));
2357         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2358         h1 = io.smb2.out.file.handle;
2359         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2360
2361         torture_comment(tctx, "writing should not generate a break\n");
2362         status = smb2_util_write(tree1, h1, &c, 0, 1);
2363         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2364
2365         torture_wait_for_oplock_break(tctx);
2366         CHECK_VAL(break_info.count, 0);
2367
2368         smb2_util_close(tree1, h1);
2369         smb2_util_close(tree1, h);
2370
2371         smb2_deltree(tree1, BASEDIR);
2372         return ret;
2373 }
2374
2375 static bool test_smb2_oplock_batch22(struct torture_context *tctx,
2376                                      struct smb2_tree *tree1)
2377 {
2378         const char *fname = BASEDIR "\\test_batch22.dat";
2379         NTSTATUS status;
2380         bool ret = true;
2381         union smb_open io;
2382         struct smb2_handle h, h1, h2;
2383         struct timeval tv;
2384         int timeout = torture_setting_int(tctx, "oplocktimeout", 30);
2385         int te;
2386
2387         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2388         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2389
2390         /* cleanup */
2391         smb2_util_unlink(tree1, fname);
2392
2393         tree1->session->transport->oplock.handler = torture_oplock_handler;
2394         tree1->session->transport->oplock.private_data = tree1;
2395         /*
2396           base ntcreatex parms
2397         */
2398         ZERO_STRUCT(io.smb2);
2399         io.generic.level = RAW_OPEN_SMB2;
2400         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2401         io.smb2.in.alloc_size = 0;
2402         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2403         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2404         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2405         io.smb2.in.create_options = 0;
2406         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2407         io.smb2.in.security_flags = 0;
2408         io.smb2.in.fname = fname;
2409
2410         /*
2411           with a batch oplock we get a break
2412         */
2413         torture_comment(tctx, "BATCH22: open with batch oplock\n");
2414         ZERO_STRUCT(break_info);
2415         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2416         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2417         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2418                 NTCREATEX_SHARE_ACCESS_WRITE|
2419                 NTCREATEX_SHARE_ACCESS_DELETE;
2420         status = smb2_create(tree1, tctx, &(io.smb2));
2421         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2422         h1 = io.smb2.out.file.handle;
2423         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2424
2425         torture_comment(tctx, "a 2nd open should succeed after the oplock "
2426                         "break timeout\n");
2427         tv = timeval_current();
2428         tree1->session->transport->oplock.handler =
2429                                 torture_oplock_handler_timeout;
2430         status = smb2_create(tree1, tctx, &(io.smb2));
2431         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2432         h2 = io.smb2.out.file.handle;
2433         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
2434
2435         torture_wait_for_oplock_break(tctx);
2436         te = (int)timeval_elapsed(&tv);
2437         CHECK_RANGE(te, timeout - 1, timeout + 15);
2438         torture_comment(tctx, "waited %d seconds for oplock timeout\n", te);
2439
2440         CHECK_VAL(break_info.count, 1);
2441         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
2442         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
2443         CHECK_VAL(break_info.failures, 0);
2444
2445         smb2_util_close(tree1, h1);
2446         smb2_util_close(tree1, h2);
2447         smb2_util_close(tree1, h);
2448
2449         smb2_deltree(tree1, BASEDIR);
2450         return ret;
2451 }
2452
2453 static bool test_smb2_oplock_batch23(struct torture_context *tctx,
2454                                      struct smb2_tree *tree1,
2455                                      struct smb2_tree *tree2)
2456 {
2457         const char *fname = BASEDIR "\\test_batch23.dat";
2458         NTSTATUS status;
2459         bool ret = true;
2460         union smb_open io;
2461         struct smb2_handle h, h1, h2, h3;
2462         struct smb2_tree *tree3 = NULL;
2463
2464         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2465         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2466
2467         /* cleanup */
2468         smb2_util_unlink(tree1, fname);
2469
2470         ret = open_smb2_connection_no_level2_oplocks(tctx, &tree3);
2471         CHECK_VAL(ret, true);
2472
2473         tree1->session->transport->oplock.handler = torture_oplock_handler;
2474         tree1->session->transport->oplock.private_data = tree1;
2475
2476         tree2->session->transport->oplock.handler = torture_oplock_handler;
2477         tree2->session->transport->oplock.private_data = tree2;
2478
2479         tree3->session->transport->oplock.handler = torture_oplock_handler;
2480         tree3->session->transport->oplock.private_data = tree3;
2481
2482         /*
2483           base ntcreatex parms
2484         */
2485         ZERO_STRUCT(io.smb2);
2486         io.generic.level = RAW_OPEN_SMB2;
2487         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2488         io.smb2.in.alloc_size = 0;
2489         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2490         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2491         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2492         io.smb2.in.create_options = 0;
2493         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2494         io.smb2.in.security_flags = 0;
2495         io.smb2.in.fname = fname;
2496
2497         torture_comment(tctx, "BATCH23: an open and ask for a batch oplock\n");
2498         ZERO_STRUCT(break_info);
2499
2500         io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
2501                                 SEC_RIGHTS_FILE_WRITE;
2502         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
2503                                 NTCREATEX_SHARE_ACCESS_WRITE;
2504         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2505         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2506         status = smb2_create(tree1, tctx, &(io.smb2));
2507         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2508         h1 = io.smb2.out.file.handle;
2509         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2510
2511         ZERO_STRUCT(break_info);
2512
2513         torture_comment(tctx, "a 2nd open without level2 oplock support "
2514                         "should generate a break to level2\n");
2515         status = smb2_create(tree3, tctx, &(io.smb2));
2516         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2517         h3 = io.smb2.out.file.handle;
2518
2519         torture_wait_for_oplock_break(tctx);
2520         CHECK_VAL(break_info.count, 1);
2521         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
2522         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
2523         CHECK_VAL(break_info.failures, 0);
2524
2525         ZERO_STRUCT(break_info);
2526
2527         torture_comment(tctx, "a 3rd open with level2 oplock support should "
2528                         "not generate a break\n");
2529         status = smb2_create(tree2, tctx, &(io.smb2));
2530         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2531         h2 = io.smb2.out.file.handle;
2532         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
2533
2534         torture_wait_for_oplock_break(tctx);
2535         CHECK_VAL(break_info.count, 0);
2536
2537         smb2_util_close(tree1, h1);
2538         smb2_util_close(tree2, h2);
2539         smb2_util_close(tree3, h3);
2540         smb2_util_close(tree1, h);
2541
2542         smb2_deltree(tree1, BASEDIR);
2543         return ret;
2544 }
2545
2546 static bool test_smb2_oplock_batch24(struct torture_context *tctx,
2547                                      struct smb2_tree *tree1,
2548                                      struct smb2_tree *tree2)
2549 {
2550         const char *fname = BASEDIR "\\test_batch24.dat";
2551         NTSTATUS status;
2552         bool ret = true;
2553         union smb_open io;
2554         struct smb2_handle h, h1, h2;
2555         struct smb2_tree *tree3 = NULL;
2556
2557         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2558         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2559
2560         /* cleanup */
2561         smb2_util_unlink(tree1, fname);
2562
2563         ret = open_smb2_connection_no_level2_oplocks(tctx, &tree3);
2564         CHECK_VAL(ret, true);
2565
2566         tree1->session->transport->oplock.handler = torture_oplock_handler;
2567         tree1->session->transport->oplock.private_data = tree1;
2568
2569         tree2->session->transport->oplock.handler = torture_oplock_handler;
2570         tree2->session->transport->oplock.private_data = tree2;
2571
2572         tree3->session->transport->oplock.handler = torture_oplock_handler;
2573         tree3->session->transport->oplock.private_data = tree3;
2574
2575         /*
2576           base ntcreatex parms
2577         */
2578         ZERO_STRUCT(io.smb2);
2579         io.generic.level = RAW_OPEN_SMB2;
2580         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2581         io.smb2.in.alloc_size = 0;
2582         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2583         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2584         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2585         io.smb2.in.create_options = 0;
2586         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2587         io.smb2.in.security_flags = 0;
2588         io.smb2.in.fname = fname;
2589
2590         torture_comment(tctx, "BATCH24: a open without level support and "
2591                         "ask for a batch oplock\n");
2592         ZERO_STRUCT(break_info);
2593
2594         io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
2595                                 SEC_RIGHTS_FILE_WRITE;
2596         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
2597                                 NTCREATEX_SHARE_ACCESS_WRITE;
2598         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2599         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2600
2601         status = smb2_create(tree3, tctx, &(io.smb2));
2602         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2603         h2 = io.smb2.out.file.handle;
2604         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2605
2606         ZERO_STRUCT(break_info);
2607
2608         torture_comment(tctx, "a 2nd open with level2 oplock support should "
2609                         "generate a break\n");
2610         status = smb2_create(tree2, tctx, &(io.smb2));
2611         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2612         h1 = io.smb2.out.file.handle;
2613         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
2614
2615         torture_wait_for_oplock_break(tctx);
2616         CHECK_VAL(break_info.count, 1);
2617         CHECK_VAL(break_info.handle.data[0], h2.data[0]);
2618         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
2619         CHECK_VAL(break_info.failures, 0);
2620
2621         smb2_util_close(tree3, h2);
2622         smb2_util_close(tree2, h1);
2623         smb2_util_close(tree1, h);
2624
2625         smb2_deltree(tree1, BASEDIR);
2626         return ret;
2627 }
2628
2629 static bool test_smb2_oplock_batch25(struct torture_context *tctx,
2630                                      struct smb2_tree *tree1)
2631 {
2632         const char *fname = BASEDIR "\\test_batch25.dat";
2633         NTSTATUS status;
2634         bool ret = true;
2635         union smb_open io;
2636         struct smb2_handle h, h1;
2637
2638         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2639         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2640
2641         /* cleanup */
2642         smb2_util_unlink(tree1, fname);
2643
2644         tree1->session->transport->oplock.handler = torture_oplock_handler;
2645         tree1->session->transport->oplock.private_data = tree1;
2646
2647         /*
2648           base ntcreatex parms
2649         */
2650         ZERO_STRUCT(io.smb2);
2651         io.generic.level = RAW_OPEN_SMB2;
2652         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2653         io.smb2.in.alloc_size = 0;
2654         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2655         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2656         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2657         io.smb2.in.create_options = 0;
2658         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2659         io.smb2.in.security_flags = 0;
2660         io.smb2.in.fname = fname;
2661
2662         torture_comment(tctx, "BATCH25: open a file with an batch oplock "
2663                         "(share mode: none)\n");
2664
2665         ZERO_STRUCT(break_info);
2666         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2667         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2668
2669         status = smb2_create(tree1, tctx, &(io.smb2));
2670         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2671         h1 = io.smb2.out.file.handle;
2672         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2673
2674         torture_comment(tctx, "changing the file attribute info should trigger "
2675                         "a break and a violation\n");
2676
2677         status = smb2_util_setatr(tree1, fname, FILE_ATTRIBUTE_HIDDEN);
2678         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_SHARING_VIOLATION,
2679                                       "Incorrect status");
2680
2681         torture_wait_for_oplock_break(tctx);
2682         CHECK_VAL(break_info.count, 1);
2683
2684         smb2_util_close(tree1, h1);
2685         smb2_util_close(tree1, h);
2686
2687         smb2_deltree(tree1, fname);
2688         return ret;
2689 }
2690
2691 /* Test how oplocks work on streams. */
2692 static bool test_raw_oplock_stream1(struct torture_context *tctx,
2693                                     struct smb2_tree *tree1,
2694                                     struct smb2_tree *tree2)
2695 {
2696         NTSTATUS status;
2697         union smb_open io;
2698         const char *fname_base = BASEDIR "\\test_stream1.txt";
2699         const char *fname_stream, *fname_default_stream;
2700         const char *default_stream = "::$DATA";
2701         const char *stream = "Stream One:$DATA";
2702         bool ret = true;
2703         struct smb2_handle h, h_base, h_stream;
2704         int i;
2705
2706 #define NSTREAM_OPLOCK_RESULTS 8
2707         struct {
2708                 const char **fname;
2709                 bool open_base_file;
2710                 uint32_t oplock_req;
2711                 uint32_t oplock_granted;
2712         } stream_oplock_results[NSTREAM_OPLOCK_RESULTS] = {
2713                 /* Request oplock on stream without the base file open. */
2714                 {&fname_stream, false, SMB2_OPLOCK_LEVEL_BATCH, SMB2_OPLOCK_LEVEL_BATCH},
2715                 {&fname_default_stream, false, SMB2_OPLOCK_LEVEL_BATCH, SMB2_OPLOCK_LEVEL_BATCH},
2716                 {&fname_stream, false, SMB2_OPLOCK_LEVEL_EXCLUSIVE, SMB2_OPLOCK_LEVEL_EXCLUSIVE},
2717                 {&fname_default_stream, false,  SMB2_OPLOCK_LEVEL_EXCLUSIVE, SMB2_OPLOCK_LEVEL_EXCLUSIVE},
2718
2719                 /* Request oplock on stream with the base file open. */
2720                 {&fname_stream, true, SMB2_OPLOCK_LEVEL_BATCH, SMB2_OPLOCK_LEVEL_BATCH},
2721                 {&fname_default_stream, true, SMB2_OPLOCK_LEVEL_BATCH, SMB2_OPLOCK_LEVEL_II},
2722                 {&fname_stream, true, SMB2_OPLOCK_LEVEL_EXCLUSIVE, SMB2_OPLOCK_LEVEL_EXCLUSIVE},
2723                 {&fname_default_stream, true,  SMB2_OPLOCK_LEVEL_EXCLUSIVE, SMB2_OPLOCK_LEVEL_II},
2724         };
2725
2726         fname_stream = talloc_asprintf(tctx, "%s:%s", fname_base, stream);
2727         fname_default_stream = talloc_asprintf(tctx, "%s%s", fname_base,
2728                                                default_stream);
2729
2730         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2731         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2732
2733         /* Initialize handles to "closed".  Using -1 in the first 64-bytes
2734          * as the sentry for this */
2735         h_stream.data[0] = -1;
2736
2737         /* cleanup */
2738         smb2_util_unlink(tree1, fname_base);
2739
2740         tree1->session->transport->oplock.handler = torture_oplock_handler;
2741         tree1->session->transport->oplock.private_data = tree1;
2742
2743         tree2->session->transport->oplock.handler = torture_oplock_handler;
2744         tree2->session->transport->oplock.private_data = tree2;
2745
2746         /* Setup generic open parameters. */
2747         ZERO_STRUCT(io.smb2);
2748         io.generic.level = RAW_OPEN_SMB2;
2749         io.smb2.in.desired_access = (SEC_FILE_READ_DATA |
2750                                      SEC_FILE_WRITE_DATA |
2751                                      SEC_FILE_APPEND_DATA |
2752                                      SEC_STD_READ_CONTROL);
2753         io.smb2.in.alloc_size = 0;
2754         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2755         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
2756                                   NTCREATEX_SHARE_ACCESS_WRITE;
2757         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2758         io.smb2.in.create_options = 0;
2759         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2760         io.smb2.in.security_flags = 0;
2761
2762         /* Create the file with a stream */
2763         io.smb2.in.fname = fname_stream;
2764         io.smb2.in.create_flags = 0;
2765         io.smb2.in.create_disposition = NTCREATEX_DISP_CREATE;
2766         status = smb2_create(tree1, tctx, &(io.smb2));
2767         torture_assert_ntstatus_ok(tctx, status, "Error creating file");
2768         smb2_util_close(tree1, io.smb2.out.file.handle);
2769
2770         /* Change the disposition to open now that the file has been created. */
2771         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN;
2772
2773         /* Try some permutations of taking oplocks on streams. */
2774         for (i = 0; i < NSTREAM_OPLOCK_RESULTS; i++) {
2775                 const char *fname = *stream_oplock_results[i].fname;
2776                 bool open_base_file = stream_oplock_results[i].open_base_file;
2777                 uint32_t oplock_req = stream_oplock_results[i].oplock_req;
2778                 uint32_t oplock_granted =
2779                     stream_oplock_results[i].oplock_granted;
2780
2781                 if (open_base_file) {
2782                         torture_comment(tctx, "Opening base file: %s with "
2783                             "%d\n", fname_base, SMB2_OPLOCK_LEVEL_BATCH);
2784                         io.smb2.in.fname = fname_base;
2785                         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2786                         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2787                         status = smb2_create(tree2, tctx, &(io.smb2));
2788                         torture_assert_ntstatus_ok(tctx, status,
2789                             "Error opening file");
2790                         CHECK_VAL(io.smb2.out.oplock_level,
2791                             SMB2_OPLOCK_LEVEL_BATCH);
2792                         h_base = io.smb2.out.file.handle;
2793                 }
2794
2795                 torture_comment(tctx, "%d: Opening stream: %s with %d\n", i,
2796                     fname, oplock_req);
2797                 io.smb2.in.fname = fname;
2798                 io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2799                 io.smb2.in.oplock_level = oplock_req;
2800
2801                 /* Do the open with the desired oplock on the stream. */
2802                 status = smb2_create(tree1, tctx, &(io.smb2));
2803                 torture_assert_ntstatus_ok(tctx, status, "Error opening file");
2804                 CHECK_VAL(io.smb2.out.oplock_level, oplock_granted);
2805                 smb2_util_close(tree1, io.smb2.out.file.handle);
2806
2807                 /* Cleanup the base file if it was opened. */
2808                 if (open_base_file)
2809                         smb2_util_close(tree2, h_base);
2810         }
2811
2812         /* Open the stream with an exclusive oplock. */
2813         torture_comment(tctx, "Opening stream: %s with %d\n",
2814             fname_stream, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
2815         io.smb2.in.fname = fname_stream;
2816         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2817         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
2818         status = smb2_create(tree1, tctx, &(io.smb2));
2819         torture_assert_ntstatus_ok(tctx, status, "Error opening file");
2820         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_EXCLUSIVE);
2821         h_stream = io.smb2.out.file.handle;
2822
2823         /* Open the base file and see if it contends. */
2824         ZERO_STRUCT(break_info);
2825         torture_comment(tctx, "Opening base file: %s with %d\n",
2826             fname_base, SMB2_OPLOCK_LEVEL_BATCH);
2827         io.smb2.in.fname = fname_base;
2828         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2829         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2830         status = smb2_create(tree2, tctx, &(io.smb2));
2831         torture_assert_ntstatus_ok(tctx, status, "Error opening file");
2832         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2833         smb2_util_close(tree2, io.smb2.out.file.handle);
2834
2835         torture_wait_for_oplock_break(tctx);
2836         CHECK_VAL(break_info.count, 0);
2837         CHECK_VAL(break_info.failures, 0);
2838
2839         /* Open the stream again to see if it contends. */
2840         ZERO_STRUCT(break_info);
2841         torture_comment(tctx, "Opening stream again: %s with "
2842             "%d\n", fname_base, SMB2_OPLOCK_LEVEL_BATCH);
2843         io.smb2.in.fname = fname_stream;
2844         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2845         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_EXCLUSIVE;
2846         status = smb2_create(tree2, tctx, &(io.smb2));
2847         torture_assert_ntstatus_ok(tctx, status, "Error opening file");
2848         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
2849         smb2_util_close(tree2, io.smb2.out.file.handle);
2850
2851         torture_wait_for_oplock_break(tctx);
2852         CHECK_VAL(break_info.count, 1);
2853         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
2854         CHECK_VAL(break_info.failures, 0);
2855
2856         /* Close the stream. */
2857         if (h_stream.data[0] != -1) {
2858                 smb2_util_close(tree1, h_stream);
2859         }
2860
2861         smb2_util_close(tree1, h);
2862
2863         smb2_deltree(tree1, BASEDIR);
2864         return ret;
2865 }
2866
2867 static bool test_smb2_oplock_doc(struct torture_context *tctx, struct smb2_tree *tree)
2868 {
2869         const char *fname = BASEDIR "\\test_oplock_doc.dat";
2870         NTSTATUS status;
2871         bool ret = true;
2872         union smb_open io;
2873         struct smb2_handle h, h1;
2874
2875         status = torture_smb2_testdir(tree, BASEDIR, &h);
2876         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2877
2878         /* cleanup */
2879         smb2_util_unlink(tree, fname);
2880         tree->session->transport->oplock.handler = torture_oplock_handler;
2881         tree->session->transport->oplock.private_data = tree;
2882
2883         /*
2884           base ntcreatex parms
2885         */
2886         ZERO_STRUCT(io.smb2);
2887         io.generic.level = RAW_OPEN_SMB2;
2888         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
2889         io.smb2.in.alloc_size = 0;
2890         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2891         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2892         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2893         io.smb2.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
2894         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2895         io.smb2.in.security_flags = 0;
2896         io.smb2.in.fname = fname;
2897
2898         torture_comment(tctx, "open a delete-on-close file with a batch "
2899                         "oplock\n");
2900         ZERO_STRUCT(break_info);
2901         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2902         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2903
2904         status = smb2_create(tree, tctx, &(io.smb2));
2905         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2906         h1 = io.smb2.out.file.handle;
2907         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2908
2909         smb2_util_close(tree, h1);
2910
2911         smb2_util_unlink(tree, fname);
2912         smb2_deltree(tree, BASEDIR);
2913         return ret;
2914 }
2915
2916 /* Open a file with a batch oplock, then open it again from a second client
2917  * requesting no oplock. Having two open file handles should break our own
2918  * oplock during BRL acquisition.
2919  */
2920 static bool test_smb2_oplock_brl1(struct torture_context *tctx,
2921                                 struct smb2_tree *tree1,
2922                                 struct smb2_tree *tree2)
2923 {
2924         const char *fname = BASEDIR "\\test_batch_brl.dat";
2925         /*int fname, f;*/
2926         bool ret = true;
2927         uint8_t buf[1000];
2928         bool correct = true;
2929         union smb_open io;
2930         NTSTATUS status;
2931         struct smb2_lock lck;
2932         struct smb2_lock_element lock[1];
2933         struct smb2_handle h, h1, h2;
2934
2935         status = torture_smb2_testdir(tree1, BASEDIR, &h);
2936         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
2937
2938         /* cleanup */
2939         smb2_util_unlink(tree1, fname);
2940
2941         tree1->session->transport->oplock.handler =
2942             torture_oplock_handler_two_notifications;
2943         tree1->session->transport->oplock.private_data = tree1;
2944
2945         /*
2946           base ntcreatex parms
2947         */
2948         ZERO_STRUCT(io.smb2);
2949         io.generic.level = RAW_OPEN_SMB2;
2950         io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
2951                                     SEC_RIGHTS_FILE_WRITE;
2952         io.smb2.in.alloc_size = 0;
2953         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2954         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
2955                                   NTCREATEX_SHARE_ACCESS_WRITE;
2956         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
2957         io.smb2.in.create_options = 0;
2958         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
2959         io.smb2.in.security_flags = 0;
2960         io.smb2.in.fname = fname;
2961
2962         /*
2963           with a batch oplock we get a break
2964         */
2965         torture_comment(tctx, "open with batch oplock\n");
2966         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2967         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
2968
2969         status = smb2_create(tree1, tctx, &(io.smb2));
2970         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
2971         h1 = io.smb2.out.file.handle;
2972         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2973
2974         /* create a file with bogus data */
2975         memset(buf, 0, sizeof(buf));
2976
2977         status = smb2_util_write(tree1, h1,buf, 0, sizeof(buf));
2978         if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
2979                 torture_comment(tctx, "Failed to create file\n");
2980                 correct = false;
2981                 goto done;
2982         }
2983
2984         torture_comment(tctx, "a 2nd open should give a break\n");
2985         ZERO_STRUCT(break_info);
2986
2987         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
2988         io.smb2.in.oplock_level = 0;
2989         status = smb2_create(tree2, tctx, &(io.smb2));
2990         h2 = io.smb2.out.file.handle;
2991         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
2992
2993         torture_wait_for_oplock_break(tctx);
2994         CHECK_VAL(break_info.count, 1);
2995         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
2996         CHECK_VAL(break_info.failures, 0);
2997         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
2998
2999         ZERO_STRUCT(break_info);
3000
3001         torture_comment(tctx, "a self BRL acquisition should break to none\n");
3002         lock[0].offset = 0;
3003         lock[0].length = 4;
3004         lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
3005                         SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
3006
3007         ZERO_STRUCT(lck);
3008         lck.in.file.handle = h1;
3009         lck.in.locks = &lock[0];
3010         lck.in.lock_count = 1;
3011         status = smb2_lock(tree1, &lck);
3012         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
3013
3014         torture_wait_for_oplock_break(tctx);
3015         CHECK_VAL(break_info.count, 1);
3016         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_NONE);
3017         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
3018         CHECK_VAL(break_info.failures, 0);
3019
3020         /* expect no oplock break */
3021         ZERO_STRUCT(break_info);
3022         lock[0].offset = 2;
3023         status = smb2_lock(tree1, &lck);
3024         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_LOCK_NOT_GRANTED,
3025                                       "Incorrect status");
3026
3027         torture_wait_for_oplock_break(tctx);
3028         CHECK_VAL(break_info.count, 0);
3029         CHECK_VAL(break_info.level, 0);
3030         CHECK_VAL(break_info.failures, 0);
3031
3032         smb2_util_close(tree1, h1);
3033         smb2_util_close(tree2, h2);
3034         smb2_util_close(tree1, h);
3035
3036 done:
3037         smb2_deltree(tree1, BASEDIR);
3038         return ret;
3039
3040 }
3041
3042 /* Open a file with a batch oplock on one tree and then acquire a brl.
3043  * We should not contend our own oplock.
3044  */
3045 static bool test_smb2_oplock_brl2(struct torture_context *tctx, struct smb2_tree *tree1)
3046 {
3047         const char *fname = BASEDIR "\\test_batch_brl.dat";
3048         /*int fname, f;*/
3049         bool ret = true;
3050         uint8_t buf[1000];
3051         bool correct = true;
3052         union smb_open io;
3053         NTSTATUS status;
3054         struct smb2_handle h, h1;
3055         struct smb2_lock lck;
3056         struct smb2_lock_element lock[1];
3057
3058         status = torture_smb2_testdir(tree1, BASEDIR, &h);
3059         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
3060
3061         /* cleanup */
3062         smb2_util_unlink(tree1, fname);
3063
3064         tree1->session->transport->oplock.handler = torture_oplock_handler;
3065         tree1->session->transport->oplock.private_data = tree1;
3066
3067         /*
3068           base ntcreatex parms
3069         */
3070         ZERO_STRUCT(io.smb2);
3071         io.generic.level = RAW_OPEN_SMB2;
3072         io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
3073                                     SEC_RIGHTS_FILE_WRITE;
3074         io.smb2.in.alloc_size = 0;
3075         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3076         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
3077                                   NTCREATEX_SHARE_ACCESS_WRITE;
3078         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
3079         io.smb2.in.create_options = 0;
3080         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3081         io.smb2.in.security_flags = 0;
3082         io.smb2.in.fname = fname;
3083
3084         /*
3085           with a batch oplock we get a break
3086         */
3087         torture_comment(tctx, "open with batch oplock\n");
3088         ZERO_STRUCT(break_info);
3089         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
3090         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
3091
3092         status = smb2_create(tree1, tctx, &(io.smb2));
3093         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
3094         h1 = io.smb2.out.file.handle;
3095         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
3096
3097         /* create a file with bogus data */
3098         memset(buf, 0, sizeof(buf));
3099
3100         status = smb2_util_write(tree1, h1, buf, 0, sizeof(buf));
3101         if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
3102                 torture_comment(tctx, "Failed to create file\n");
3103                 correct = false;
3104                 goto done;
3105         }
3106
3107         ZERO_STRUCT(break_info);
3108
3109         torture_comment(tctx, "a self BRL acquisition should not break to "
3110                         "none\n");
3111
3112         lock[0].offset = 0;
3113         lock[0].length = 4;
3114         lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
3115                         SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
3116
3117         ZERO_STRUCT(lck);
3118         lck.in.file.handle = h1;
3119         lck.in.locks = &lock[0];
3120         lck.in.lock_count = 1;
3121         status = smb2_lock(tree1, &lck);
3122         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
3123
3124         lock[0].offset = 2;
3125         status = smb2_lock(tree1, &lck);
3126         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_LOCK_NOT_GRANTED,
3127                                       "Incorrect status");
3128
3129         /* With one file handle open a BRL should not contend our oplock.
3130          * Thus, no oplock break will be received and the entire break_info
3131          * struct will be 0 */
3132         torture_wait_for_oplock_break(tctx);
3133         CHECK_VAL(break_info.count, 0);
3134         CHECK_VAL(break_info.level, 0);
3135         CHECK_VAL(break_info.failures, 0);
3136
3137         smb2_util_close(tree1, h1);
3138         smb2_util_close(tree1, h);
3139
3140 done:
3141         smb2_deltree(tree1, BASEDIR);
3142         return ret;
3143 }
3144
3145 /* Open a file with a batch oplock twice from one tree and then acquire a
3146  * brl. BRL acquisition should break our own oplock.
3147  */
3148 static bool test_smb2_oplock_brl3(struct torture_context *tctx, struct smb2_tree *tree1)
3149 {
3150         const char *fname = BASEDIR "\\test_batch_brl.dat";
3151         bool ret = true;
3152         uint8_t buf[1000];
3153         bool correct = true;
3154         union smb_open io;
3155         NTSTATUS status;
3156         struct smb2_handle h, h1, h2;
3157         struct smb2_lock lck;
3158         struct smb2_lock_element lock[1];
3159
3160         status = torture_smb2_testdir(tree1, BASEDIR, &h);
3161         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
3162
3163         /* cleanup */
3164         smb2_util_unlink(tree1, fname);
3165         tree1->session->transport->oplock.handler =
3166             torture_oplock_handler_two_notifications;
3167         tree1->session->transport->oplock.private_data = tree1;
3168
3169         /*
3170           base ntcreatex parms
3171         */
3172         ZERO_STRUCT(io.smb2);
3173         io.generic.level = RAW_OPEN_SMB2;
3174         io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
3175                                     SEC_RIGHTS_FILE_WRITE;
3176         io.smb2.in.alloc_size = 0;
3177         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3178         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
3179                                   NTCREATEX_SHARE_ACCESS_WRITE;
3180         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
3181         io.smb2.in.create_options = 0;
3182         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3183         io.smb2.in.security_flags = 0;
3184         io.smb2.in.fname = fname;
3185
3186         /*
3187           with a batch oplock we get a break
3188         */
3189         torture_comment(tctx, "open with batch oplock\n");
3190         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
3191         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
3192
3193         status = smb2_create(tree1, tctx, &(io.smb2));
3194         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
3195         h1 = io.smb2.out.file.handle;
3196         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
3197
3198         /* create a file with bogus data */
3199         memset(buf, 0, sizeof(buf));
3200         status = smb2_util_write(tree1, h1, buf, 0, sizeof(buf));
3201
3202         if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
3203                 torture_comment(tctx, "Failed to create file\n");
3204                 correct = false;
3205                 goto done;
3206         }
3207
3208         torture_comment(tctx, "a 2nd open should give a break\n");
3209         ZERO_STRUCT(break_info);
3210
3211         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
3212         io.smb2.in.oplock_level = 0;
3213         status = smb2_create(tree1, tctx, &(io.smb2));
3214         h2 = io.smb2.out.file.handle;
3215         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
3216         CHECK_VAL(break_info.count, 1);
3217         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_II);
3218         CHECK_VAL(break_info.failures, 0);
3219         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
3220
3221         ZERO_STRUCT(break_info);
3222
3223         torture_comment(tctx, "a self BRL acquisition should break to none\n");
3224
3225         lock[0].offset = 0;
3226         lock[0].length = 4;
3227         lock[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE |
3228                         SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
3229
3230         ZERO_STRUCT(lck);
3231         lck.in.file.handle = h1;
3232         lck.in.locks = &lock[0];
3233         lck.in.lock_count = 1;
3234         status = smb2_lock(tree1, &lck);
3235         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
3236
3237         torture_wait_for_oplock_break(tctx);
3238         CHECK_VAL(break_info.count, 1);
3239         CHECK_VAL(break_info.level, SMB2_OPLOCK_LEVEL_NONE);
3240         CHECK_VAL(break_info.handle.data[0], h1.data[0]);
3241         CHECK_VAL(break_info.failures, 0);
3242
3243         /* expect no oplock break */
3244         ZERO_STRUCT(break_info);
3245         lock[0].offset = 2;
3246         status = smb2_lock(tree1, &lck);
3247         torture_assert_ntstatus_equal(tctx, status, NT_STATUS_LOCK_NOT_GRANTED,
3248                                       "Incorrect status");
3249
3250         torture_wait_for_oplock_break(tctx);
3251         CHECK_VAL(break_info.count, 0);
3252         CHECK_VAL(break_info.level, 0);
3253         CHECK_VAL(break_info.failures, 0);
3254
3255         smb2_util_close(tree1, h1);
3256         smb2_util_close(tree1, h2);
3257         smb2_util_close(tree1, h);
3258
3259 done:
3260         smb2_deltree(tree1, BASEDIR);
3261         return ret;
3262
3263 }
3264
3265 /* Starting the SMB2 specific oplock tests at 500 so we can keep the SMB1
3266  * tests in sync with an identically numbered SMB2 test */
3267
3268 /* Test whether the server correctly returns an error when we send
3269  * a response to a levelII to none oplock notification. */
3270 static bool test_smb2_oplock_levelII500(struct torture_context *tctx,
3271                                       struct smb2_tree *tree1)
3272 {
3273         const char *fname = BASEDIR "\\test_levelII500.dat";
3274         NTSTATUS status;
3275         bool ret = true;
3276         union smb_open io;
3277         struct smb2_handle h, h1;
3278         char c = 0;
3279
3280         status = torture_smb2_testdir(tree1, BASEDIR, &h);
3281         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
3282
3283         /* cleanup */
3284         smb2_util_unlink(tree1, fname);
3285
3286         tree1->session->transport->oplock.handler = torture_oplock_handler;
3287         tree1->session->transport->oplock.private_data = tree1;
3288
3289         /*
3290           base ntcreatex parms
3291         */
3292         ZERO_STRUCT(io.smb2);
3293         io.generic.level = RAW_OPEN_SMB2;
3294         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
3295         io.smb2.in.alloc_size = 0;
3296         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3297         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
3298         io.smb2.in.create_options = 0;
3299         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3300         io.smb2.in.security_flags = 0;
3301         io.smb2.in.fname = fname;
3302
3303         torture_comment(tctx, "LEVELII500: acknowledging a break from II to "
3304                         "none should return an error\n");
3305         ZERO_STRUCT(break_info);
3306
3307         io.smb2.in.desired_access = SEC_RIGHTS_FILE_READ |
3308                                 SEC_RIGHTS_FILE_WRITE;
3309         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
3310                                 NTCREATEX_SHARE_ACCESS_WRITE;
3311         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
3312         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_II;
3313         status = smb2_create(tree1, tctx, &(io.smb2));
3314         torture_assert_ntstatus_ok(tctx, status, "Error opening the file");
3315         h1 = io.smb2.out.file.handle;
3316         CHECK_VAL(io.smb2.out.oplock_level, SMB2_OPLOCK_LEVEL_II);
3317
3318         ZERO_STRUCT(break_info);
3319
3320         torture_comment(tctx, "write should trigger a break to none and when "
3321                         "we reply, an oplock break failure\n");
3322         smb2_util_write(tree1, h1, &c, 0, 1);
3323
3324         /* Wait several times to receive both the break notification, and the
3325          * NT_STATUS_INVALID_OPLOCK_PROTOCOL error in the break response */
3326         torture_wait_for_oplock_break(tctx);
3327         torture_wait_for_oplock_break(tctx);
3328         torture_wait_for_oplock_break(tctx);
3329         torture_wait_for_oplock_break(tctx);
3330
3331         /* There appears to be a race condition in W2K8 and W2K8R2 where
3332          * sometimes the server will happily reply to our break response with
3333          * NT_STATUS_OK, and sometimes it will return the OPLOCK_PROTOCOL
3334          * error.  As the MS-SMB2 doc states that a client should not reply to
3335          * a level2 to none break notification, I'm leaving the protocol error
3336          * as the expected behavior. */
3337         CHECK_VAL(break_info.count, 1);
3338         CHECK_VAL(break_info.level, 0);
3339         CHECK_VAL(break_info.failures, 1);
3340         torture_assert_ntstatus_equal(tctx, break_info.failure_status,
3341                                       NT_STATUS_INVALID_OPLOCK_PROTOCOL,
3342                                       "Incorrect status");
3343
3344         smb2_util_close(tree1, h1);
3345         smb2_util_close(tree1, h);
3346
3347         smb2_deltree(tree1, BASEDIR);
3348         return ret;
3349 }
3350
3351 struct torture_suite *torture_smb2_oplocks_init(void)
3352 {
3353         struct torture_suite *suite =
3354             torture_suite_create(talloc_autofree_context(), "oplock");
3355
3356         torture_suite_add_2smb2_test(suite, "exclusive1", test_smb2_oplock_exclusive1);
3357         torture_suite_add_2smb2_test(suite, "exclusive2", test_smb2_oplock_exclusive2);
3358         torture_suite_add_2smb2_test(suite, "exclusive3", test_smb2_oplock_exclusive3);
3359         torture_suite_add_2smb2_test(suite, "exclusive4", test_smb2_oplock_exclusive4);
3360         torture_suite_add_2smb2_test(suite, "exclusive5", test_smb2_oplock_exclusive5);
3361         torture_suite_add_2smb2_test(suite, "exclusive6", test_smb2_oplock_exclusive6);
3362         torture_suite_add_2smb2_test(suite, "batch1", test_smb2_oplock_batch1);
3363         torture_suite_add_2smb2_test(suite, "batch2", test_smb2_oplock_batch2);
3364         torture_suite_add_2smb2_test(suite, "batch3", test_smb2_oplock_batch3);
3365         torture_suite_add_2smb2_test(suite, "batch4", test_smb2_oplock_batch4);
3366         torture_suite_add_2smb2_test(suite, "batch5", test_smb2_oplock_batch5);
3367         torture_suite_add_2smb2_test(suite, "batch6", test_smb2_oplock_batch6);
3368         torture_suite_add_2smb2_test(suite, "batch7", test_smb2_oplock_batch7);
3369         torture_suite_add_2smb2_test(suite, "batch8", test_smb2_oplock_batch8);
3370         torture_suite_add_2smb2_test(suite, "batch9", test_smb2_oplock_batch9);
3371         torture_suite_add_2smb2_test(suite, "batch10", test_smb2_oplock_batch10);
3372         torture_suite_add_2smb2_test(suite, "batch11", test_smb2_oplock_batch11);
3373         torture_suite_add_2smb2_test(suite, "batch12", test_smb2_oplock_batch12);
3374         torture_suite_add_2smb2_test(suite, "batch13", test_smb2_oplock_batch13);
3375         torture_suite_add_2smb2_test(suite, "batch14", test_smb2_oplock_batch14);
3376         torture_suite_add_2smb2_test(suite, "batch15", test_smb2_oplock_batch15);
3377         torture_suite_add_2smb2_test(suite, "batch16", test_smb2_oplock_batch16);
3378         torture_suite_add_1smb2_test(suite, "batch19", test_smb2_oplock_batch19);
3379         torture_suite_add_2smb2_test(suite, "batch20", test_smb2_oplock_batch20);
3380         torture_suite_add_1smb2_test(suite, "batch21", test_smb2_oplock_batch21);
3381         torture_suite_add_1smb2_test(suite, "batch22", test_smb2_oplock_batch22);
3382         torture_suite_add_2smb2_test(suite, "batch23", test_smb2_oplock_batch23);
3383         torture_suite_add_2smb2_test(suite, "batch24", test_smb2_oplock_batch24);
3384         torture_suite_add_1smb2_test(suite, "batch25", test_smb2_oplock_batch25);
3385         torture_suite_add_2smb2_test(suite, "stream1", test_raw_oplock_stream1);
3386         torture_suite_add_1smb2_test(suite, "doc", test_smb2_oplock_doc);
3387         torture_suite_add_2smb2_test(suite, "brl1", test_smb2_oplock_brl1);
3388         torture_suite_add_1smb2_test(suite, "brl2", test_smb2_oplock_brl2);
3389         torture_suite_add_1smb2_test(suite, "brl3", test_smb2_oplock_brl3);
3390         torture_suite_add_1smb2_test(suite, "levelii500", test_smb2_oplock_levelII500);
3391
3392         suite->description = talloc_strdup(suite, "SMB2-OPLOCK tests");
3393
3394         return suite;
3395 }
3396
3397 /*
3398    stress testing of oplocks
3399 */
3400 bool test_smb2_bench_oplock(struct torture_context *tctx,
3401                                    struct smb2_tree *tree)
3402 {
3403         struct smb2_tree **trees;
3404         bool ret = true;
3405         NTSTATUS status;
3406         TALLOC_CTX *mem_ctx = talloc_new(tctx);
3407         int torture_nprocs = torture_setting_int(tctx, "nprocs", 4);
3408         int i, count=0;
3409         int timelimit = torture_setting_int(tctx, "timelimit", 10);
3410         union smb_open io;
3411         struct timeval tv;
3412         struct smb2_handle h;
3413
3414         trees = talloc_array(mem_ctx, struct smb2_tree *, torture_nprocs);
3415
3416         torture_comment(tctx, "Opening %d connections\n", torture_nprocs);
3417         for (i=0;i<torture_nprocs;i++) {
3418                 if (!torture_smb2_connection(tctx, &trees[i])) {
3419                         return false;
3420                 }
3421                 talloc_steal(mem_ctx, trees[i]);
3422                 trees[i]->session->transport->oplock.handler =
3423                                         torture_oplock_handler_close;
3424                 trees[i]->session->transport->oplock.private_data = trees[i];
3425         }
3426
3427         status = torture_smb2_testdir(trees[0], BASEDIR, &h);
3428         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
3429
3430         ZERO_STRUCT(io.smb2);
3431         io.smb2.level = RAW_OPEN_SMB2;
3432         io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
3433         io.smb2.in.alloc_size = 0;
3434         io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3435         io.smb2.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
3436         io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
3437         io.smb2.in.create_options = 0;
3438         io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3439         io.smb2.in.security_flags = 0;
3440         io.smb2.in.fname = BASEDIR "\\test.dat";
3441         io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
3442         io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
3443
3444         tv = timeval_current();
3445
3446         /*
3447           we open the same file with SHARE_ACCESS_NONE from all the
3448           connections in a round robin fashion. Each open causes an
3449           oplock break on the previous connection, which is answered
3450           by the oplock_handler_close() to close the file.
3451
3452           This measures how fast we can pass on oplocks, and stresses
3453           the oplock handling code
3454         */
3455         torture_comment(tctx, "Running for %d seconds\n", timelimit);
3456         while (timeval_elapsed(&tv) < timelimit) {
3457                 for (i=0;i<torture_nprocs;i++) {
3458                         status = smb2_create(trees[i], mem_ctx, &(io.smb2));
3459                         torture_assert_ntstatus_ok(tctx, status, "Incorrect status");
3460                         count++;
3461                 }
3462
3463                 if (torture_setting_bool(tctx, "progress", true)) {
3464                         torture_comment(tctx, "%.2f ops/second\r",
3465                                         count/timeval_elapsed(&tv));
3466                 }
3467         }
3468
3469         torture_comment(tctx, "%.2f ops/second\n", count/timeval_elapsed(&tv));
3470         smb2_util_close(trees[0], io.smb2.out.file.handle);
3471         smb2_util_unlink(trees[0], BASEDIR "\\test.dat");
3472         smb2_deltree(trees[0], BASEDIR);
3473         talloc_free(mem_ctx);
3474         return ret;
3475 }
3476
3477 static struct hold_oplock_info {
3478         const char *fname;
3479         bool close_on_break;
3480         uint32_t share_access;
3481         struct smb2_handle handle;
3482 } hold_info[] = {
3483         { BASEDIR "\\notshared_close", true,
3484           NTCREATEX_SHARE_ACCESS_NONE, },
3485         { BASEDIR "\\notshared_noclose", false,
3486           NTCREATEX_SHARE_ACCESS_NONE, },
3487         { BASEDIR "\\shared_close", true,
3488           NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE, },
3489         { BASEDIR "\\shared_noclose", false,
3490           NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE, },
3491 };
3492
3493 static bool torture_oplock_handler_hold(struct smb2_transport *transport,
3494                                         const struct smb2_handle *handle,
3495                                         uint8_t level, void *private_data)
3496 {
3497         struct hold_oplock_info *info;
3498         int i;
3499
3500         for (i=0;i<ARRAY_SIZE(hold_info);i++) {
3501                 if (smb2_util_handle_equal(hold_info[i].handle, *handle))
3502                         break;
3503         }
3504
3505         if (i == ARRAY_SIZE(hold_info)) {
3506                 printf("oplock break for unknown handle 0x%llx%llx\n",
3507                        (unsigned long long) handle->data[0],
3508                        (unsigned long long) handle->data[1]);
3509                 return false;
3510         }
3511
3512         info = &hold_info[i];
3513
3514         if (info->close_on_break) {
3515                 printf("oplock break on %s - closing\n", info->fname);
3516                 torture_oplock_handler_close(transport, handle,
3517                                              level, private_data);
3518                 return true;
3519         }
3520
3521         printf("oplock break on %s - acking break\n", info->fname);
3522         printf("Acking to none in oplock handler\n");
3523
3524         torture_oplock_handler_ack_to_none(transport, handle,
3525                                            level, private_data);
3526         return true;
3527 }
3528
3529 /*
3530    used for manual testing of oplocks - especially interaction with
3531    other filesystems (such as NFS and local access)
3532 */
3533 bool test_smb2_hold_oplock(struct torture_context *tctx,
3534                            struct smb2_tree *tree)
3535 {
3536         struct torture_context *mem_ctx = talloc_new(tctx);
3537         struct tevent_context *ev =
3538                 (struct tevent_context *)tree->session->transport->socket->event.ctx;
3539         int i;
3540         struct smb2_handle h;
3541         NTSTATUS status;
3542
3543         torture_comment(tctx, "Setting up open files with oplocks in %s\n",
3544                         BASEDIR);
3545
3546         status = torture_smb2_testdir(tree, BASEDIR, &h);
3547         torture_assert_ntstatus_ok(tctx, status, "Error creating directory");
3548
3549         tree->session->transport->oplock.handler = torture_oplock_handler_hold;
3550         tree->session->transport->oplock.private_data = tree;
3551
3552         /* setup the files */
3553         for (i=0;i<ARRAY_SIZE(hold_info);i++) {
3554                 union smb_open io;
3555                 char c = 1;
3556
3557                 ZERO_STRUCT(io.smb2);
3558                 io.generic.level = RAW_OPEN_SMB2;
3559                 io.smb2.in.desired_access = SEC_RIGHTS_FILE_ALL;
3560                 io.smb2.in.alloc_size = 0;
3561                 io.smb2.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
3562                 io.smb2.in.share_access = hold_info[i].share_access;
3563                 io.smb2.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
3564                 io.smb2.in.create_options = 0;
3565                 io.smb2.in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS;
3566                 io.smb2.in.security_flags = 0;
3567                 io.smb2.in.fname = hold_info[i].fname;
3568                 io.smb2.in.create_flags = NTCREATEX_FLAGS_EXTENDED;
3569                 io.smb2.in.oplock_level = SMB2_OPLOCK_LEVEL_BATCH;
3570
3571                 torture_comment(tctx, "opening %s\n", hold_info[i].fname);
3572
3573                 status = smb2_create(tree, mem_ctx, &(io.smb2));
3574                 if (!NT_STATUS_IS_OK(status)) {
3575                         torture_comment(tctx, "Failed to open %s - %s\n",
3576                                hold_info[i].fname, nt_errstr(status));
3577                         return false;
3578                 }
3579
3580                 if (io.smb2.out.oplock_level != SMB2_OPLOCK_LEVEL_BATCH) {
3581                         torture_comment(tctx, "Oplock not granted for %s - "
3582                                         "expected %d but got %d\n",
3583                                         hold_info[i].fname,
3584                                         SMB2_OPLOCK_LEVEL_BATCH,
3585                                         io.smb2.out.oplock_level);
3586                         return false;
3587                 }
3588                 hold_info[i].handle = io.smb2.out.file.handle;
3589
3590                 /* make the file non-zero size */
3591                 status = smb2_util_write(tree, hold_info[i].handle, &c, 0, 1);
3592                 if (!NT_STATUS_EQUAL(status, NT_STATUS_OK)) {
3593                         torture_comment(tctx, "Failed to write to file\n");
3594                         return false;
3595                 }
3596         }
3597
3598         torture_comment(tctx, "Waiting for oplock events\n");
3599         event_loop_wait(ev);
3600         smb2_deltree(tree, BASEDIR);
3601         talloc_free(mem_ctx);
3602         return true;
3603 }