source4/torture/raw/oplock.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    basic raw test suite for oplocks
   4    Copyright (C) Andrew Tridgell 2003
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "libcli/raw/libcliraw.h"
  22 #include "libcli/raw/raw_proto.h"
  23 #include "libcli/libcli.h"
  24 #include "torture/util.h"
  25 #include "lib/events/events.h"
  26 #include "param/param.h"
  27 #include "lib/cmdline/popt_common.h"
  28 #include "libcli/resolve/resolve.h"
  29 #include "torture/raw/proto.h"
  30
  31 #define CHECK_VAL(v, correct) do { \
  32         if ((v) != (correct)) { \
  33                 torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s got 0x%x - should be 0x%x\n", \
  34                                 __location__, #v, (int)v, (int)correct); \
  35                 ret = false; \
  36         }} while (0)
  37
  38 #define CHECK_RANGE(v, min, max) do {                                   \
  39         if ((v) < (min) || (v) > (max)) {                               \
  40                 torture_warning(tctx, "(%s): wrong value for %s got "   \
  41                     "%d - should be between %d and %d\n",               \
  42                     __location__, #v, (int)v, (int)min, (int)max);      \
  43         }} while (0)
  44
  45 #define CHECK_STRMATCH(v, correct) do { \
  46         if (!v || strstr((v),(correct)) == NULL) { \
  47                 torture_result(tctx, TORTURE_FAIL,  "(%s): wrong value for %s got '%s' - should be '%s'\n", \
  48                                 __location__, #v, v?v:"NULL", correct); \
  49                 ret = false; \
  50         } \
  51 } while (0)
  52
  53 #define CHECK_STATUS(tctx, status, correct) do { \
  54         if (!NT_STATUS_EQUAL(status, correct)) { \
  55                 torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
  56                        nt_errstr(status), nt_errstr(correct)); \
  57                 ret = false; \
  58                 goto done; \
  59         }} while (0)
  60
  61
  62 static struct {
  63         int fnum;
  64         uint8_t level;
  65         int count;
  66         int failures;
  67 } break_info;
  68
  69 #define BASEDIR "\\test_oplock"
  70
  71 /*
  72   a handler function for oplock break requests. Ack it as a break to level II if possible
  73 */
  74 static bool oplock_handler_ack_to_given(struct smbcli_transport *transport,
  75                                         uint16_t tid, uint16_t fnum,
  76                                         uint8_t level, void *private_data)
  77 {
  78         struct smbcli_tree *tree = (struct smbcli_tree *)private_data;
  79         const char *name;
  80
  81         break_info.fnum = fnum;
  82         break_info.level = level;
  83         break_info.count++;
  84
  85         switch (level) {
  86         case OPLOCK_BREAK_TO_LEVEL_II:
  87                 name = "level II";
  88                 break;
  89         case OPLOCK_BREAK_TO_NONE:
  90                 name = "none";
  91                 break;
  92         default:
  93                 name = "unknown";
  94                 break_info.failures++;
  95         }
  96         printf("Acking to %s [0x%02X] in oplock handler\n",
  97                 name, level);
  98
  99         return smbcli_oplock_ack(tree, fnum, level);
 100 }
 101
 102 /*
 103   a handler function for oplock break requests. Ack it as a break to none
 104 */
 105 static bool oplock_handler_ack_to_none(struct smbcli_transport *transport,
 106                                        uint16_t tid, uint16_t fnum,
 107                                        uint8_t level, void *private_data)
 108 {
 109         struct smbcli_tree *tree = (struct smbcli_tree *)private_data;
 110         break_info.fnum = fnum;
 111         break_info.level = level;
 112         break_info.count++;
 113
 114         printf("Acking to none in oplock handler\n");
 115
 116         return smbcli_oplock_ack(tree, fnum, OPLOCK_BREAK_TO_NONE);
 117 }
 118
 119 /*
 120   a handler function for oplock break requests. Let it timeout
 121 */
 122 static bool oplock_handler_timeout(struct smbcli_transport *transport,
 123                                    uint16_t tid, uint16_t fnum,
 124                                    uint8_t level, void *private_data)
 125 {
 126         break_info.fnum = fnum;
 127         break_info.level = level;
 128         break_info.count++;
 129
 130         printf("Let oplock break timeout\n");
 131         return true;
 132 }
 133
 134 static void oplock_handler_close_recv(struct smbcli_request *req)
 135 {
 136         NTSTATUS status;
 137         status = smbcli_request_simple_recv(req);
 138         if (!NT_STATUS_IS_OK(status)) {
 139                 printf("close failed in oplock_handler_close\n");
 140                 break_info.failures++;
 141         }
 142 }
 143
 144 /*
 145   a handler function for oplock break requests - close the file
 146 */
 147 static bool oplock_handler_close(struct smbcli_transport *transport, uint16_t tid,
 148                                  uint16_t fnum, uint8_t level, void *private_data)
 149 {
 150         union smb_close io;
 151         struct smbcli_tree *tree = (struct smbcli_tree *)private_data;
 152         struct smbcli_request *req;
 153
 154         break_info.fnum = fnum;
 155         break_info.level = level;
 156         break_info.count++;
 157
 158         io.close.level = RAW_CLOSE_CLOSE;
 159         io.close.in.file.fnum = fnum;
 160         io.close.in.write_time = 0;
 161         req = smb_raw_close_send(tree, &io);
 162         if (req == NULL) {
 163                 printf("failed to send close in oplock_handler_close\n");
 164                 return false;
 165         }
 166
 167         req->async.fn = oplock_handler_close_recv;
 168         req->async.private_data = NULL;
 169
 170         return true;
 171 }
 172
 173 static bool open_connection_no_level2_oplocks(struct torture_context *tctx,
 174                                               struct smbcli_state **c)
 175 {
 176         NTSTATUS status;
 177         struct smbcli_options options;
 178         struct smbcli_session_options session_options;
 179
 180         lpcfg_smbcli_options(tctx->lp_ctx, &options);
 181         lpcfg_smbcli_session_options(tctx->lp_ctx, &session_options);
 182
 183         options.use_level2_oplocks = false;
 184
 185         status = smbcli_full_connection(tctx, c,
 186                                         torture_setting_string(tctx, "host", NULL),
 187                                         lpcfg_smb_ports(tctx->lp_ctx),
 188                                         torture_setting_string(tctx, "share", NULL),
 189                                         NULL, lpcfg_socket_options(tctx->lp_ctx),
 190                                         popt_get_cmdline_credentials(),
 191                                         lpcfg_resolve_context(tctx->lp_ctx),
 192                                         tctx->ev, &options, &session_options,
 193                                         lpcfg_gensec_settings(tctx, tctx->lp_ctx));
 194         if (!NT_STATUS_IS_OK(status)) {
 195                 torture_comment(tctx, "Failed to open connection - %s\n",
 196                                 nt_errstr(status));
 197                 return false;
 198         }
 199
 200         return true;
 201 }
 202
 203 /*
 204    Timer handler function notifies the registering function that time is up
 205 */
 206 static void timeout_cb(struct tevent_context *ev,
 207                        struct tevent_timer *te,
 208                        struct timeval current_time,
 209                        void *private_data)
 210 {
 211         bool *timesup = (bool *)private_data;
 212         *timesup = true;
 213         return;
 214 }
 215
 216 /*
 217    Wait a short period of time to receive a single oplock break request
 218 */
 219 static void torture_wait_for_oplock_break(struct torture_context *tctx)
 220 {
 221         TALLOC_CTX *tmp_ctx = talloc_new(NULL);
 222         struct tevent_timer *te = NULL;
 223         struct timeval ne;
 224         bool timesup = false;
 225         int old_count = break_info.count;
 226
 227         /* Wait .1 seconds for an oplock break */
 228         ne = tevent_timeval_current_ofs(0, 100000);
 229
 230         if ((te = tevent_add_timer(tctx->ev, tmp_ctx, ne, timeout_cb, &timesup))
 231             == NULL)
 232         {
 233                 torture_comment(tctx, "Failed to wait for an oplock break. "
 234                                       "test results may not be accurate.");
 235                 goto done;
 236         }
 237
 238         while (!timesup && break_info.count < old_count + 1) {
 239                 if (tevent_loop_once(tctx->ev) != 0) {
 240                         torture_comment(tctx, "Failed to wait for an oplock "
 241                                               "break. test results may not be "
 242                                               "accurate.");
 243                         goto done;
 244                 }
 245         }
 246
 247 done:
 248         /* We don't know if the timed event fired and was freed, we received
 249          * our oplock break, or some other event triggered the loop.  Thus,
 250          * we create a tmp_ctx to be able to safely free/remove the timed
 251          * event in all 3 cases. */
 252         talloc_free(tmp_ctx);
 253
 254         return;
 255 }
 256
 257 static uint8_t get_break_level1_to_none_count(struct torture_context *tctx)
 258 {
 259         return torture_setting_bool(tctx, "2_step_break_to_none", false) ?
 260             2 : 1;
 261 }
 262
 263 static uint8_t get_setinfo_break_count(struct torture_context *tctx)
 264 {
 265         if (TARGET_IS_W2K12(tctx)) {
 266                 return 2;
 267         }
 268         if (TARGET_IS_SAMBA3(tctx)) {
 269                 return 2;
 270         }
 271         return 1;
 272 }
 273
 274 static bool test_raw_oplock_exclusive1(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 275 {
 276         const char *fname = BASEDIR "\\test_exclusive1.dat";
 277         NTSTATUS status;
 278         bool ret = true;
 279         union smb_open io;
 280         union smb_unlink unl;
 281         uint16_t fnum=0;
 282
 283         if (!torture_setup_dir(cli1, BASEDIR)) {
 284                 return false;
 285         }
 286
 287         /* cleanup */
 288         smbcli_unlink(cli1->tree, fname);
 289
 290         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 291
 292         /*
 293           base ntcreatex parms
 294         */
 295         io.generic.level = RAW_OPEN_NTCREATEX;
 296         io.ntcreatex.in.root_fid.fnum = 0;
 297         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
 298         io.ntcreatex.in.alloc_size = 0;
 299         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 300         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 301         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 302         io.ntcreatex.in.create_options = 0;
 303         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 304         io.ntcreatex.in.security_flags = 0;
 305         io.ntcreatex.in.fname = fname;
 306
 307         torture_comment(tctx, "EXCLUSIVE1: open a file with an exclusive oplock (share mode: none)\n");
 308         ZERO_STRUCT(break_info);
 309         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
 310
 311         status = smb_raw_open(cli1->tree, tctx, &io);
 312         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 313         fnum = io.ntcreatex.out.file.fnum;
 314         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 315
 316         torture_comment(tctx, "a 2nd open should not cause a break\n");
 317         status = smb_raw_open(cli2->tree, tctx, &io);
 318         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 319         torture_wait_for_oplock_break(tctx);
 320         CHECK_VAL(break_info.count, 0);
 321         CHECK_VAL(break_info.failures, 0);
 322
 323         torture_comment(tctx, "unlink it - should also be no break\n");
 324         unl.unlink.in.pattern = fname;
 325         unl.unlink.in.attrib = 0;
 326         status = smb_raw_unlink(cli2->tree, &unl);
 327         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 328         torture_wait_for_oplock_break(tctx);
 329         CHECK_VAL(break_info.count, 0);
 330         CHECK_VAL(break_info.failures, 0);
 331
 332         smbcli_close(cli1->tree, fnum);
 333
 334 done:
 335         smb_raw_exit(cli1->session);
 336         smb_raw_exit(cli2->session);
 337         smbcli_deltree(cli1->tree, BASEDIR);
 338         return ret;
 339 }
 340
 341 static bool test_raw_oplock_exclusive2(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 342 {
 343         const char *fname = BASEDIR "\\test_exclusive2.dat";
 344         NTSTATUS status;
 345         bool ret = true;
 346         union smb_open io;
 347         union smb_unlink unl;
 348         uint16_t fnum=0, fnum2=0;
 349
 350         if (!torture_setup_dir(cli1, BASEDIR)) {
 351                 return false;
 352         }
 353
 354         /* cleanup */
 355         smbcli_unlink(cli1->tree, fname);
 356
 357         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 358
 359         /*
 360           base ntcreatex parms
 361         */
 362         io.generic.level = RAW_OPEN_NTCREATEX;
 363         io.ntcreatex.in.root_fid.fnum = 0;
 364         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
 365         io.ntcreatex.in.alloc_size = 0;
 366         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 367         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 368         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 369         io.ntcreatex.in.create_options = 0;
 370         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 371         io.ntcreatex.in.security_flags = 0;
 372         io.ntcreatex.in.fname = fname;
 373
 374         torture_comment(tctx, "EXCLUSIVE2: open a file with an exclusive oplock (share mode: all)\n");
 375         ZERO_STRUCT(break_info);
 376         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
 377         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
 378                 NTCREATEX_SHARE_ACCESS_WRITE|
 379                 NTCREATEX_SHARE_ACCESS_DELETE;
 380
 381         status = smb_raw_open(cli1->tree, tctx, &io);
 382         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 383         fnum = io.ntcreatex.out.file.fnum;
 384         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 385
 386         torture_comment(tctx, "a 2nd open should cause a break to level 2\n");
 387         status = smb_raw_open(cli2->tree, tctx, &io);
 388         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 389         fnum2 = io.ntcreatex.out.file.fnum;
 390         torture_wait_for_oplock_break(tctx);
 391         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
 392         CHECK_VAL(break_info.count, 1);
 393         CHECK_VAL(break_info.fnum, fnum);
 394         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
 395         CHECK_VAL(break_info.failures, 0);
 396         ZERO_STRUCT(break_info);
 397
 398         /* now we have 2 level II oplocks... */
 399         torture_comment(tctx, "try to unlink it - should not cause a break, but a sharing violation\n");
 400         unl.unlink.in.pattern = fname;
 401         unl.unlink.in.attrib = 0;
 402         status = smb_raw_unlink(cli2->tree, &unl);
 403         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 404         torture_wait_for_oplock_break(tctx);
 405         CHECK_VAL(break_info.count, 0);
 406         CHECK_VAL(break_info.failures, 0);
 407
 408         torture_comment(tctx, "close 1st handle\n");
 409         smbcli_close(cli1->tree, fnum);
 410
 411         torture_comment(tctx, "try to unlink it - should not cause a break, but a sharing violation\n");
 412         unl.unlink.in.pattern = fname;
 413         unl.unlink.in.attrib = 0;
 414         status = smb_raw_unlink(cli2->tree, &unl);
 415         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 416         torture_wait_for_oplock_break(tctx);
 417         CHECK_VAL(break_info.count, 0);
 418         CHECK_VAL(break_info.failures, 0);
 419
 420         torture_comment(tctx, "close 2nd handle\n");
 421         smbcli_close(cli2->tree, fnum2);
 422
 423         torture_comment(tctx, "unlink it\n");
 424         unl.unlink.in.pattern = fname;
 425         unl.unlink.in.attrib = 0;
 426         status = smb_raw_unlink(cli2->tree, &unl);
 427         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 428         torture_wait_for_oplock_break(tctx);
 429         CHECK_VAL(break_info.count, 0);
 430         CHECK_VAL(break_info.failures, 0);
 431
 432 done:
 433         smb_raw_exit(cli1->session);
 434         smb_raw_exit(cli2->session);
 435         smbcli_deltree(cli1->tree, BASEDIR);
 436         return ret;
 437 }
 438
 439 static bool test_raw_oplock_exclusive3(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 440 {
 441         const char *fname = BASEDIR "\\test_exclusive3.dat";
 442         NTSTATUS status;
 443         bool ret = true;
 444         union smb_open io;
 445         union smb_setfileinfo sfi;
 446         uint16_t fnum=0;
 447
 448         if (!torture_setup_dir(cli1, BASEDIR)) {
 449                 return false;
 450         }
 451
 452         /* cleanup */
 453         smbcli_unlink(cli1->tree, fname);
 454
 455         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 456
 457         /*
 458           base ntcreatex parms
 459         */
 460         io.generic.level = RAW_OPEN_NTCREATEX;
 461         io.ntcreatex.in.root_fid.fnum = 0;
 462         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
 463         io.ntcreatex.in.alloc_size = 0;
 464         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 465         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_WRITE;
 466         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 467         io.ntcreatex.in.create_options = 0;
 468         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 469         io.ntcreatex.in.security_flags = 0;
 470         io.ntcreatex.in.fname = fname;
 471
 472         torture_comment(tctx, "EXCLUSIVE3: open a file with an exclusive oplock (share mode: none)\n");
 473
 474         ZERO_STRUCT(break_info);
 475         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
 476
 477         status = smb_raw_open(cli1->tree, tctx, &io);
 478         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 479         fnum = io.ntcreatex.out.file.fnum;
 480         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 481
 482         torture_comment(tctx, "setpathinfo EOF should trigger a break to none\n");
 483         ZERO_STRUCT(sfi);
 484         sfi.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
 485         sfi.generic.in.file.path = fname;
 486         sfi.end_of_file_info.in.size = 100;
 487
 488         status = smb_raw_setpathinfo(cli2->tree, &sfi);
 489
 490         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 491         torture_wait_for_oplock_break(tctx);
 492         CHECK_VAL(break_info.count, get_setinfo_break_count(tctx));
 493         CHECK_VAL(break_info.failures, 0);
 494         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
 495
 496         smbcli_close(cli1->tree, fnum);
 497
 498 done:
 499         smb_raw_exit(cli1->session);
 500         smb_raw_exit(cli2->session);
 501         smbcli_deltree(cli1->tree, BASEDIR);
 502         return ret;
 503 }
 504
 505 static bool test_raw_oplock_exclusive4(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 506 {
 507         const char *fname = BASEDIR "\\test_exclusive4.dat";
 508         NTSTATUS status;
 509         bool ret = true;
 510         union smb_open io;
 511         uint16_t fnum=0, fnum2=0;
 512
 513         if (!torture_setup_dir(cli1, BASEDIR)) {
 514                 return false;
 515         }
 516
 517         /* cleanup */
 518         smbcli_unlink(cli1->tree, fname);
 519
 520         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 521
 522         /*
 523           base ntcreatex parms
 524         */
 525         io.generic.level = RAW_OPEN_NTCREATEX;
 526         io.ntcreatex.in.root_fid.fnum = 0;
 527         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
 528         io.ntcreatex.in.alloc_size = 0;
 529         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 530         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 531         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 532         io.ntcreatex.in.create_options = 0;
 533         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 534         io.ntcreatex.in.security_flags = 0;
 535         io.ntcreatex.in.fname = fname;
 536
 537         torture_comment(tctx, "EXCLUSIVE4: open with exclusive oplock\n");
 538         ZERO_STRUCT(break_info);
 539         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 540
 541         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
 542         status = smb_raw_open(cli1->tree, tctx, &io);
 543         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 544         fnum = io.ntcreatex.out.file.fnum;
 545         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 546
 547         ZERO_STRUCT(break_info);
 548         torture_comment(tctx, "second open with attributes only shouldn't cause oplock break\n");
 549
 550         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
 551         io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
 552         status = smb_raw_open(cli2->tree, tctx, &io);
 553         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 554         fnum2 = io.ntcreatex.out.file.fnum;
 555         CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
 556         torture_wait_for_oplock_break(tctx);
 557         CHECK_VAL(break_info.count, 0);
 558         CHECK_VAL(break_info.failures, 0);
 559
 560         /*
 561          * Open another non-stat open. This reproduces bug 10216. Make sure it
 562          * won't happen again...
 563          */
 564         io.ntcreatex.in.flags = 0;
 565         io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA;
 566         status = smb_raw_open(cli2->tree, tctx, &io);
 567         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 568         torture_wait_for_oplock_break(tctx);
 569         CHECK_VAL(break_info.count, 0);
 570         CHECK_VAL(break_info.failures, 0);
 571
 572         smbcli_close(cli1->tree, fnum);
 573         smbcli_close(cli2->tree, fnum2);
 574
 575 done:
 576         smb_raw_exit(cli1->session);
 577         smb_raw_exit(cli2->session);
 578         smbcli_deltree(cli1->tree, BASEDIR);
 579         return ret;
 580 }
 581
 582 static bool test_raw_oplock_exclusive5(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 583 {
 584         const char *fname = BASEDIR "\\test_exclusive5.dat";
 585         NTSTATUS status;
 586         bool ret = true;
 587         union smb_open io;
 588         uint16_t fnum=0, fnum2=0;
 589
 590         if (!torture_setup_dir(cli1, BASEDIR)) {
 591                 return false;
 592         }
 593
 594         /* cleanup */
 595         smbcli_unlink(cli1->tree, fname);
 596
 597         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 598         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli1->tree);
 599
 600         /*
 601           base ntcreatex parms
 602         */
 603         io.generic.level = RAW_OPEN_NTCREATEX;
 604         io.ntcreatex.in.root_fid.fnum = 0;
 605         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
 606         io.ntcreatex.in.alloc_size = 0;
 607         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 608         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 609         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 610         io.ntcreatex.in.create_options = 0;
 611         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 612         io.ntcreatex.in.security_flags = 0;
 613         io.ntcreatex.in.fname = fname;
 614
 615         torture_comment(tctx, "EXCLUSIVE5: open with exclusive oplock\n");
 616         ZERO_STRUCT(break_info);
 617         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 618
 619
 620         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
 621         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
 622                 NTCREATEX_SHARE_ACCESS_WRITE|
 623                 NTCREATEX_SHARE_ACCESS_DELETE;
 624         status = smb_raw_open(cli1->tree, tctx, &io);
 625         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 626         fnum = io.ntcreatex.out.file.fnum;
 627         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 628
 629         ZERO_STRUCT(break_info);
 630
 631         torture_comment(tctx, "second open with attributes only and NTCREATEX_DISP_OVERWRITE_IF dispostion causes oplock break\n");
 632
 633         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
 634         io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
 635         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
 636         status = smb_raw_open(cli2->tree, tctx, &io);
 637         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 638         fnum2 = io.ntcreatex.out.file.fnum;
 639         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
 640         torture_wait_for_oplock_break(tctx);
 641         CHECK_VAL(break_info.count, get_break_level1_to_none_count(tctx));
 642         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
 643         CHECK_VAL(break_info.failures, 0);
 644
 645         smbcli_close(cli1->tree, fnum);
 646         smbcli_close(cli2->tree, fnum2);
 647
 648 done:
 649         smb_raw_exit(cli1->session);
 650         smb_raw_exit(cli2->session);
 651         smbcli_deltree(cli1->tree, BASEDIR);
 652         return ret;
 653 }
 654
 655 static bool test_raw_oplock_exclusive6(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
 656 {
 657         const char *fname1 = BASEDIR "\\test_exclusive6_1.dat";
 658         const char *fname2 = BASEDIR "\\test_exclusive6_2.dat";
 659         NTSTATUS status;
 660         bool ret = true;
 661         union smb_open io;
 662         union smb_rename rn;
 663         uint16_t fnum=0;
 664
 665         if (!torture_setup_dir(cli1, BASEDIR)) {
 666                 return false;
 667         }
 668
 669         /* cleanup */
 670         smbcli_unlink(cli1->tree, fname1);
 671         smbcli_unlink(cli1->tree, fname2);
 672
 673         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
 674
 675         /*
 676           base ntcreatex parms
 677         */
 678         io.generic.level = RAW_OPEN_NTCREATEX;
 679         io.ntcreatex.in.root_fid.fnum = 0;
 680         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
 681         io.ntcreatex.in.alloc_size = 0;
 682         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 683         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
 684         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 685         io.ntcreatex.in.create_options = 0;
 686         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 687         io.ntcreatex.in.security_flags = 0;
 688         io.ntcreatex.in.fname = fname1;
 689
 690         torture_comment(tctx, "EXCLUSIVE6: open a file with an exclusive "
 691                         "oplock (share mode: none)\n");
 692         ZERO_STRUCT(break_info);
 693         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED | NTCREATEX_FLAGS_REQUEST_OPLOCK;
 694
 695         status = smb_raw_open(cli1->tree, tctx, &io);
 696         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 697         fnum = io.ntcreatex.out.file.fnum;
 698         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 699
 700         torture_comment(tctx, "rename should not generate a break but get a "
 701                         "sharing violation\n");
 702         ZERO_STRUCT(rn);
 703         rn.generic.level = RAW_RENAME_RENAME;
 704         rn.rename.in.pattern1 = fname1;
 705         rn.rename.in.pattern2 = fname2;
 706         rn.rename.in.attrib = 0;
 707
 708         torture_comment(tctx, "trying rename while first file open\n");
 709         status = smb_raw_rename(cli2->tree, &rn);
 710
 711         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
 712         torture_wait_for_oplock_break(tctx);
 713         CHECK_VAL(break_info.count, 0);
 714         CHECK_VAL(break_info.failures, 0);
 715
 716         smbcli_close(cli1->tree, fnum);
 717
 718 done:
 719         smb_raw_exit(cli1->session);
 720         smb_raw_exit(cli2->session);
 721         smbcli_deltree(cli1->tree, BASEDIR);
 722         return ret;
 723 }
 724
 725 /**
 726  * Exclusive version of batch19
 727  */
 728 static bool test_raw_oplock_exclusive7(struct torture_context *tctx,
 729     struct smbcli_state *cli1, struct smbcli_state *cli2)
 730 {
 731         const char *fname1 = BASEDIR "\\test_exclusiv6_1.dat";
 732         const char *fname2 = BASEDIR "\\test_exclusiv6_2.dat";
 733         const char *fname3 = BASEDIR "\\test_exclusiv6_3.dat";
 734         NTSTATUS status;
 735         bool ret = true;
 736         union smb_open io;
 737         union smb_fileinfo qfi;
 738         union smb_setfileinfo sfi;
 739         uint16_t fnum=0;
 740         uint16_t fnum2 = 0;
 741
 742         if (!torture_setup_dir(cli1, BASEDIR)) {
 743                 return false;
 744         }
 745
 746         /* cleanup */
 747         smbcli_unlink(cli1->tree, fname1);
 748         smbcli_unlink(cli1->tree, fname2);
 749         smbcli_unlink(cli1->tree, fname3);
 750
 751         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
 752             cli1->tree);
 753
 754         /*
 755           base ntcreatex parms
 756         */
 757         io.generic.level = RAW_OPEN_NTCREATEX;
 758         io.ntcreatex.in.root_fid.fnum = 0;
 759         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
 760         io.ntcreatex.in.alloc_size = 0;
 761         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 762         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
 763             NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
 764         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 765         io.ntcreatex.in.create_options = 0;
 766         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 767         io.ntcreatex.in.security_flags = 0;
 768         io.ntcreatex.in.fname = fname1;
 769
 770         torture_comment(tctx, "open a file with an exclusive oplock (share "
 771             "mode: none)\n");
 772         ZERO_STRUCT(break_info);
 773         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
 774                 NTCREATEX_FLAGS_REQUEST_OPLOCK;
 775         status = smb_raw_open(cli1->tree, tctx, &io);
 776         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 777         fnum = io.ntcreatex.out.file.fnum;
 778         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 779
 780         torture_comment(tctx, "setpathinfo rename info should trigger a break "
 781             "to none\n");
 782         ZERO_STRUCT(sfi);
 783         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
 784         sfi.generic.in.file.path = fname1;
 785         sfi.rename_information.in.overwrite     = 0;
 786         sfi.rename_information.in.root_fid      = 0;
 787         sfi.rename_information.in.new_name      = fname2+strlen(BASEDIR)+1;
 788
 789         status = smb_raw_setpathinfo(cli2->tree, &sfi);
 790         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 791
 792         torture_wait_for_oplock_break(tctx);
 793         CHECK_VAL(break_info.failures, 0);
 794
 795         if (TARGET_IS_WINXP(tctx) || TARGET_IS_W2K12(tctx)) {
 796                 /* XP incorrectly breaks to level2. */
 797                 CHECK_VAL(break_info.count, 1);
 798                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
 799         } else {
 800                 /* Exclusive oplocks should not be broken on rename. */
 801                 CHECK_VAL(break_info.failures, 0);
 802                 CHECK_VAL(break_info.count, 0);
 803         }
 804
 805         ZERO_STRUCT(qfi);
 806         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
 807         qfi.generic.in.file.fnum = fnum;
 808
 809         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
 810         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 811         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname2);
 812
 813         /* Try breaking to level2 and then see if rename breaks the level2.*/
 814         ZERO_STRUCT(break_info);
 815         io.ntcreatex.in.fname = fname2;
 816         status = smb_raw_open(cli2->tree, tctx, &io);
 817         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 818         fnum2 = io.ntcreatex.out.file.fnum;
 819         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
 820
 821         torture_wait_for_oplock_break(tctx);
 822         CHECK_VAL(break_info.failures, 0);
 823
 824         if (TARGET_IS_WINXP(tctx)) {
 825                 /* XP already broke to level2. */
 826                 CHECK_VAL(break_info.failures, 0);
 827                 CHECK_VAL(break_info.count, 0);
 828         } else if (TARGET_IS_W2K12(tctx)) {
 829                 /* no break */
 830                 CHECK_VAL(break_info.count, 0);
 831                 CHECK_VAL(break_info.level, 0);
 832         } else {
 833                 /* Break to level 2 expected. */
 834                 CHECK_VAL(break_info.count, 1);
 835                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
 836         }
 837
 838         ZERO_STRUCT(break_info);
 839         sfi.generic.in.file.path = fname2;
 840         sfi.rename_information.in.overwrite     = 0;
 841         sfi.rename_information.in.root_fid      = 0;
 842         sfi.rename_information.in.new_name      = fname1+strlen(BASEDIR)+1;
 843
 844         status = smb_raw_setpathinfo(cli2->tree, &sfi);
 845         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 846
 847         /* Level2 oplocks are not broken on rename. */
 848         torture_wait_for_oplock_break(tctx);
 849         CHECK_VAL(break_info.failures, 0);
 850         CHECK_VAL(break_info.count, 0);
 851
 852         /* Close and re-open file with oplock. */
 853         smbcli_close(cli1->tree, fnum);
 854         status = smb_raw_open(cli1->tree, tctx, &io);
 855         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 856         fnum = io.ntcreatex.out.file.fnum;
 857         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 858
 859         torture_comment(tctx, "setfileinfo rename info on a client's own fid "
 860             "should not trigger a break nor a violation\n");
 861         ZERO_STRUCT(break_info);
 862         ZERO_STRUCT(sfi);
 863         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
 864         sfi.generic.in.file.fnum = fnum;
 865         sfi.rename_information.in.overwrite     = 0;
 866         sfi.rename_information.in.root_fid      = 0;
 867         sfi.rename_information.in.new_name      = fname3+strlen(BASEDIR)+1;
 868
 869         status = smb_raw_setfileinfo(cli1->tree, &sfi);
 870         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 871
 872         torture_wait_for_oplock_break(tctx);
 873         if (TARGET_IS_WINXP(tctx)) {
 874                 /* XP incorrectly breaks to level2. */
 875                 CHECK_VAL(break_info.count, 1);
 876                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
 877         } else {
 878                 CHECK_VAL(break_info.count, 0);
 879         }
 880
 881         ZERO_STRUCT(qfi);
 882         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
 883         qfi.generic.in.file.fnum = fnum;
 884
 885         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
 886         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 887         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname3);
 888
 889 done:
 890         smbcli_close(cli1->tree, fnum);
 891         smbcli_close(cli2->tree, fnum2);
 892
 893         smb_raw_exit(cli1->session);
 894         smb_raw_exit(cli2->session);
 895         smbcli_deltree(cli1->tree, BASEDIR);
 896         return ret;
 897 }
 898
 899 static bool test_raw_oplock_exclusive8(struct torture_context *tctx,
 900                                        struct smbcli_state *cli1,
 901                                        struct smbcli_state *cli2)
 902 {
 903         const char *fname = BASEDIR "\\test_exclusive8.dat";
 904         NTSTATUS status;
 905         bool ret = true;
 906         union smb_open io;
 907         uint16_t fnum1 = 0;
 908         uint16_t fnum2 = 0;
 909         uint16_t fnum3 = 0;
 910
 911         if (!torture_setup_dir(cli1, BASEDIR)) {
 912                 return false;
 913         }
 914
 915         /* cleanup */
 916         smbcli_unlink(cli1->tree, fname);
 917
 918         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
 919                               cli1->tree);
 920
 921         /*
 922           base ntcreatex parms
 923         */
 924         io.generic.level = RAW_OPEN_NTCREATEX;
 925         io.ntcreatex.in.root_fid.fnum = 0;
 926         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
 927         io.ntcreatex.in.alloc_size = 0;
 928         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
 929         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
 930                 NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
 931         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
 932         io.ntcreatex.in.create_options = 0;
 933         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
 934         io.ntcreatex.in.security_flags = 0;
 935         io.ntcreatex.in.fname = fname;
 936
 937         torture_comment(tctx, "open a file with an exclusive oplock (share "
 938                         "mode: all)\n");
 939         ZERO_STRUCT(break_info);
 940         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
 941                 NTCREATEX_FLAGS_REQUEST_OPLOCK;
 942         status = smb_raw_open(cli1->tree, tctx, &io);
 943         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 944         fnum1 = io.ntcreatex.out.file.fnum;
 945         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
 946
 947         torture_comment(tctx, "second open with delete should trigger a "
 948                         "break\n");
 949
 950         io.ntcreatex.in.access_mask = SEC_STD_DELETE;
 951         io.ntcreatex.in.flags = 0;
 952         status = smb_raw_open(cli2->tree, tctx, &io);
 953         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 954         fnum2 = io.ntcreatex.out.file.fnum;
 955         CHECK_VAL(break_info.count, get_break_level1_to_none_count(tctx));
 956         CHECK_VAL(break_info.failures, 0);
 957         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
 958
 959         /* Trigger a little panic in "old" samba code.. */
 960         status = smb_raw_open(cli2->tree, tctx, &io);
 961         CHECK_STATUS(tctx, status, NT_STATUS_OK);
 962         fnum3 = io.ntcreatex.out.file.fnum;
 963
 964         smbcli_close(cli2->tree, fnum3);
 965         smbcli_close(cli2->tree, fnum2);
 966         smbcli_close(cli1->tree, fnum1);
 967
 968 done:
 969         smbcli_deltree(cli1->tree, BASEDIR);
 970         smb_raw_exit(cli1->session);
 971         smb_raw_exit(cli2->session);
 972         return ret;
 973 }
 974
 975 static bool test_raw_oplock_exclusive9(struct torture_context *tctx,
 976                                        struct smbcli_state *cli1,
 977                                        struct smbcli_state *cli2)
 978 {
 979         const char *fname = BASEDIR "\\test_exclusive9.dat";
 980         NTSTATUS status;
 981         bool ret = true;
 982         union smb_open io;
 983         uint16_t fnum=0, fnum2=0;
 984         int i;
 985
 986         struct {
 987                 uint32_t create_disposition;
 988                 uint32_t break_level;
 989         } levels[] = {
 990                 { NTCREATEX_DISP_SUPERSEDE, OPLOCK_BREAK_TO_NONE },
 991                 { NTCREATEX_DISP_OPEN, OPLOCK_BREAK_TO_LEVEL_II },
 992                 { NTCREATEX_DISP_OVERWRITE_IF, OPLOCK_BREAK_TO_NONE },
 993                 { NTCREATEX_DISP_OPEN_IF, OPLOCK_BREAK_TO_LEVEL_II },
 994         };
 995
 996         if (!torture_setup_dir(cli1, BASEDIR)) {
 997                 return false;
 998         }
 999
1000         /* cleanup */
1001         smbcli_unlink(cli1->tree, fname);
1002
1003         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
1004                               cli1->tree);
1005         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given,
1006                               cli1->tree);
1007
1008         /*
1009           base ntcreatex parms
1010         */
1011         io.generic.level = RAW_OPEN_NTCREATEX;
1012         io.ntcreatex.in.root_fid.fnum = 0;
1013         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1014         io.ntcreatex.in.alloc_size = 0;
1015         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1016         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1017         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1018         io.ntcreatex.in.create_options = 0;
1019         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1020         io.ntcreatex.in.security_flags = 0;
1021         io.ntcreatex.in.fname = fname;
1022
1023         ZERO_STRUCT(break_info);
1024         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
1025                               cli1->tree);
1026
1027         for (i=0; i<ARRAY_SIZE(levels); i++) {
1028
1029                 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1030                         NTCREATEX_FLAGS_REQUEST_OPLOCK;
1031                 io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1032                         NTCREATEX_SHARE_ACCESS_WRITE|
1033                         NTCREATEX_SHARE_ACCESS_DELETE;
1034                 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1035                 status = smb_raw_open(cli1->tree, tctx, &io);
1036                 CHECK_STATUS(tctx, status, NT_STATUS_OK);
1037                 fnum = io.ntcreatex.out.file.fnum;
1038                 CHECK_VAL(io.ntcreatex.out.oplock_level,
1039                           EXCLUSIVE_OPLOCK_RETURN);
1040
1041                 ZERO_STRUCT(break_info);
1042
1043                 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1044                         NTCREATEX_FLAGS_REQUEST_OPLOCK;
1045                 io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA;
1046                 io.ntcreatex.in.open_disposition =
1047                         levels[i].create_disposition;
1048                 status = smb_raw_open(cli2->tree, tctx, &io);
1049                 CHECK_STATUS(tctx, status, NT_STATUS_OK);
1050                 fnum2 = io.ntcreatex.out.file.fnum;
1051                 CHECK_VAL(io.ntcreatex.out.oplock_level,
1052                           LEVEL_II_OPLOCK_RETURN);
1053                 torture_wait_for_oplock_break(tctx);
1054                 CHECK_VAL(break_info.count, 1);
1055                 CHECK_VAL(break_info.level, levels[i].break_level);
1056                 CHECK_VAL(break_info.failures, 0);
1057
1058                 smbcli_close(cli1->tree, fnum);
1059                 smbcli_close(cli2->tree, fnum2);
1060         }
1061
1062 done:
1063         smb_raw_exit(cli1->session);
1064         smb_raw_exit(cli2->session);
1065         smbcli_deltree(cli1->tree, BASEDIR);
1066         return ret;
1067 }
1068
1069 static bool test_raw_oplock_level_ii_1(struct torture_context *tctx,
1070                                        struct smbcli_state *cli1,
1071                                        struct smbcli_state *cli2)
1072 {
1073         const char *fname = BASEDIR "\\test_level_ii_1.dat";
1074         NTSTATUS status;
1075         bool ret = true;
1076         union smb_open io;
1077         uint16_t fnum=0, fnum2=0;
1078         char c = 0;
1079         ssize_t written;
1080
1081         if (!torture_setup_dir(cli1, BASEDIR)) {
1082                 return false;
1083         }
1084
1085         /* cleanup */
1086         smbcli_unlink(cli1->tree, fname);
1087
1088         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
1089                               cli1->tree);
1090         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given,
1091                               cli1->tree);
1092
1093         /*
1094           base ntcreatex parms
1095         */
1096         io.generic.level = RAW_OPEN_NTCREATEX;
1097         io.ntcreatex.in.root_fid.fnum = 0;
1098         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1099         io.ntcreatex.in.alloc_size = 0;
1100         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1101         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1102         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1103         io.ntcreatex.in.create_options = 0;
1104         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1105         io.ntcreatex.in.security_flags = 0;
1106         io.ntcreatex.in.fname = fname;
1107
1108         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1109                 NTCREATEX_FLAGS_REQUEST_OPLOCK;
1110         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
1111                 NTCREATEX_SHARE_ACCESS_WRITE|
1112                 NTCREATEX_SHARE_ACCESS_DELETE;
1113         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1114         status = smb_raw_open(cli1->tree, tctx, &io);
1115         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1116         fnum = io.ntcreatex.out.file.fnum;
1117         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
1118
1119         ZERO_STRUCT(break_info);
1120
1121         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1122                 NTCREATEX_FLAGS_REQUEST_OPLOCK;
1123         io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA;
1124         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1125         status = smb_raw_open(cli2->tree, tctx, &io);
1126         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1127         fnum2 = io.ntcreatex.out.file.fnum;
1128         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
1129         torture_wait_for_oplock_break(tctx);
1130         CHECK_VAL(break_info.count, 1);
1131         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
1132         CHECK_VAL(break_info.failures, 0);
1133
1134         status = smbcli_close(cli2->tree, fnum2);
1135         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1136
1137         /*
1138          * fnum1 has a level2 oplock now
1139          */
1140
1141         ZERO_STRUCT(break_info);
1142
1143         /*
1144          * Don't answer the break to none that will come in
1145          */
1146
1147         smbcli_oplock_handler(cli1->transport, oplock_handler_timeout,
1148                               cli1->tree);
1149
1150         io.ntcreatex.in.flags = 0;
1151         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1152
1153         status = smb_raw_open(cli2->tree, tctx, &io);
1154         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1155         fnum2 = io.ntcreatex.out.file.fnum;
1156         CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
1157         torture_wait_for_oplock_break(tctx);
1158         CHECK_VAL(break_info.count, 1);
1159         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
1160         CHECK_VAL(break_info.failures, 0);
1161
1162         /*
1163          * Check that a write does not cause another break. This used to be a
1164          * bug in smbd.
1165          */
1166
1167         ZERO_STRUCT(break_info);
1168         written = smbcli_write(cli2->tree, fnum2, 0, &c, 0, 1);
1169         CHECK_VAL(written, 1);
1170         torture_wait_for_oplock_break(tctx);
1171         CHECK_VAL(break_info.count, 0);
1172         CHECK_VAL(break_info.failures, 0);
1173
1174         status = smbcli_close(cli2->tree, fnum2);
1175         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1176         status = smbcli_close(cli1->tree, fnum);
1177         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1178
1179 done:
1180         smb_raw_exit(cli1->session);
1181         smb_raw_exit(cli2->session);
1182         smbcli_deltree(cli1->tree, BASEDIR);
1183         return ret;
1184 }
1185
1186 static bool test_raw_oplock_batch1(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1187 {
1188         const char *fname = BASEDIR "\\test_batch1.dat";
1189         NTSTATUS status;
1190         bool ret = true;
1191         union smb_open io;
1192         union smb_unlink unl;
1193         uint16_t fnum=0;
1194         char c = 0;
1195
1196         if (!torture_setup_dir(cli1, BASEDIR)) {
1197                 return false;
1198         }
1199
1200         /* cleanup */
1201         smbcli_unlink(cli1->tree, fname);
1202
1203         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1204
1205         /*
1206           base ntcreatex parms
1207         */
1208         io.generic.level = RAW_OPEN_NTCREATEX;
1209         io.ntcreatex.in.root_fid.fnum = 0;
1210         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1211         io.ntcreatex.in.alloc_size = 0;
1212         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1213         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1214         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1215         io.ntcreatex.in.create_options = 0;
1216         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1217         io.ntcreatex.in.security_flags = 0;
1218         io.ntcreatex.in.fname = fname;
1219
1220         /*
1221           with a batch oplock we get a break
1222         */
1223         torture_comment(tctx, "BATCH1: open with batch oplock\n");
1224         ZERO_STRUCT(break_info);
1225         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1226                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1227                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1228         status = smb_raw_open(cli1->tree, tctx, &io);
1229         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1230         fnum = io.ntcreatex.out.file.fnum;
1231         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1232
1233         torture_comment(tctx, "unlink should generate a break\n");
1234         unl.unlink.in.pattern = fname;
1235         unl.unlink.in.attrib = 0;
1236         status = smb_raw_unlink(cli2->tree, &unl);
1237         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
1238
1239         torture_wait_for_oplock_break(tctx);
1240         CHECK_VAL(break_info.count, 1);
1241         CHECK_VAL(break_info.fnum, fnum);
1242         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
1243         CHECK_VAL(break_info.failures, 0);
1244
1245         torture_comment(tctx, "2nd unlink should not generate a break\n");
1246         ZERO_STRUCT(break_info);
1247         status = smb_raw_unlink(cli2->tree, &unl);
1248         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
1249
1250         torture_wait_for_oplock_break(tctx);
1251         CHECK_VAL(break_info.count, 0);
1252
1253         torture_comment(tctx, "writing should generate a self break to none\n");
1254         smbcli_write(cli1->tree, fnum, 0, &c, 0, 1);
1255
1256         torture_wait_for_oplock_break(tctx);
1257         torture_wait_for_oplock_break(tctx);
1258         CHECK_VAL(break_info.count, 1);
1259         CHECK_VAL(break_info.fnum, fnum);
1260         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
1261         CHECK_VAL(break_info.failures, 0);
1262
1263         smbcli_close(cli1->tree, fnum);
1264
1265 done:
1266         smb_raw_exit(cli1->session);
1267         smb_raw_exit(cli2->session);
1268         smbcli_deltree(cli1->tree, BASEDIR);
1269         return ret;
1270 }
1271
1272 static bool test_raw_oplock_batch2(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1273 {
1274         const char *fname = BASEDIR "\\test_batch2.dat";
1275         NTSTATUS status;
1276         bool ret = true;
1277         union smb_open io;
1278         union smb_unlink unl;
1279         uint16_t fnum=0;
1280         char c = 0;
1281
1282         if (!torture_setup_dir(cli1, BASEDIR)) {
1283                 return false;
1284         }
1285
1286         /* cleanup */
1287         smbcli_unlink(cli1->tree, fname);
1288
1289         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1290
1291         /*
1292           base ntcreatex parms
1293         */
1294         io.generic.level = RAW_OPEN_NTCREATEX;
1295         io.ntcreatex.in.root_fid.fnum = 0;
1296         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1297         io.ntcreatex.in.alloc_size = 0;
1298         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1299         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1300         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1301         io.ntcreatex.in.create_options = 0;
1302         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1303         io.ntcreatex.in.security_flags = 0;
1304         io.ntcreatex.in.fname = fname;
1305
1306         torture_comment(tctx, "BATCH2: open with batch oplock\n");
1307         ZERO_STRUCT(break_info);
1308         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1309                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1310                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1311         status = smb_raw_open(cli1->tree, tctx, &io);
1312         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1313         fnum = io.ntcreatex.out.file.fnum;
1314         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1315
1316         torture_comment(tctx, "unlink should generate a break, which we ack as break to none\n");
1317         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_none, cli1->tree);
1318         unl.unlink.in.pattern = fname;
1319         unl.unlink.in.attrib = 0;
1320         status = smb_raw_unlink(cli2->tree, &unl);
1321         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
1322
1323         torture_wait_for_oplock_break(tctx);
1324         CHECK_VAL(break_info.count, 1);
1325         CHECK_VAL(break_info.fnum, fnum);
1326         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
1327         CHECK_VAL(break_info.failures, 0);
1328
1329         torture_comment(tctx, "2nd unlink should not generate a break\n");
1330         ZERO_STRUCT(break_info);
1331         status = smb_raw_unlink(cli2->tree, &unl);
1332         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
1333
1334         torture_wait_for_oplock_break(tctx);
1335         CHECK_VAL(break_info.count, 0);
1336
1337         torture_comment(tctx, "writing should not generate a break\n");
1338         smbcli_write(cli1->tree, fnum, 0, &c, 0, 1);
1339
1340         torture_wait_for_oplock_break(tctx);
1341         CHECK_VAL(break_info.count, 0);
1342
1343         smbcli_close(cli1->tree, fnum);
1344
1345 done:
1346         smb_raw_exit(cli1->session);
1347         smb_raw_exit(cli2->session);
1348         smbcli_deltree(cli1->tree, BASEDIR);
1349         return ret;
1350 }
1351
1352 static bool test_raw_oplock_batch3(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1353 {
1354         const char *fname = BASEDIR "\\test_batch3.dat";
1355         NTSTATUS status;
1356         bool ret = true;
1357         union smb_open io;
1358         union smb_unlink unl;
1359         uint16_t fnum=0;
1360
1361         if (!torture_setup_dir(cli1, BASEDIR)) {
1362                 return false;
1363         }
1364
1365         /* cleanup */
1366         smbcli_unlink(cli1->tree, fname);
1367
1368         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1369
1370         /*
1371           base ntcreatex parms
1372         */
1373         io.generic.level = RAW_OPEN_NTCREATEX;
1374         io.ntcreatex.in.root_fid.fnum = 0;
1375         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1376         io.ntcreatex.in.alloc_size = 0;
1377         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1378         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1379         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1380         io.ntcreatex.in.create_options = 0;
1381         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1382         io.ntcreatex.in.security_flags = 0;
1383         io.ntcreatex.in.fname = fname;
1384
1385         torture_comment(tctx, "BATCH3: if we close on break then the unlink can succeed\n");
1386         ZERO_STRUCT(break_info);
1387         smbcli_oplock_handler(cli1->transport, oplock_handler_close, cli1->tree);
1388         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1389                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1390                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1391         status = smb_raw_open(cli1->tree, tctx, &io);
1392         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1393         fnum = io.ntcreatex.out.file.fnum;
1394         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1395
1396         unl.unlink.in.pattern = fname;
1397         unl.unlink.in.attrib = 0;
1398         ZERO_STRUCT(break_info);
1399         status = smb_raw_unlink(cli2->tree, &unl);
1400         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1401
1402         torture_wait_for_oplock_break(tctx);
1403         CHECK_VAL(break_info.count, 1);
1404         CHECK_VAL(break_info.fnum, fnum);
1405         CHECK_VAL(break_info.level, 1);
1406         CHECK_VAL(break_info.failures, 0);
1407
1408         smbcli_close(cli1->tree, fnum);
1409
1410 done:
1411         smb_raw_exit(cli1->session);
1412         smb_raw_exit(cli2->session);
1413         smbcli_deltree(cli1->tree, BASEDIR);
1414         return ret;
1415 }
1416
1417 static bool test_raw_oplock_batch4(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1418 {
1419         const char *fname = BASEDIR "\\test_batch4.dat";
1420         NTSTATUS status;
1421         bool ret = true;
1422         union smb_open io;
1423         union smb_read rd;
1424         uint16_t fnum=0;
1425
1426         if (!torture_setup_dir(cli1, BASEDIR)) {
1427                 return false;
1428         }
1429
1430         /* cleanup */
1431         smbcli_unlink(cli1->tree, fname);
1432
1433         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1434
1435         /*
1436           base ntcreatex parms
1437         */
1438         io.generic.level = RAW_OPEN_NTCREATEX;
1439         io.ntcreatex.in.root_fid.fnum = 0;
1440         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1441         io.ntcreatex.in.alloc_size = 0;
1442         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1443         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1444         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1445         io.ntcreatex.in.create_options = 0;
1446         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1447         io.ntcreatex.in.security_flags = 0;
1448         io.ntcreatex.in.fname = fname;
1449
1450         torture_comment(tctx, "BATCH4: a self read should not cause a break\n");
1451         ZERO_STRUCT(break_info);
1452         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1453
1454         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1455                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1456                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1457         status = smb_raw_open(cli1->tree, tctx, &io);
1458         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1459         fnum = io.ntcreatex.out.file.fnum;
1460         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1461
1462         rd.readx.level = RAW_READ_READX;
1463         rd.readx.in.file.fnum = fnum;
1464         rd.readx.in.mincnt = 1;
1465         rd.readx.in.maxcnt = 1;
1466         rd.readx.in.offset = 0;
1467         rd.readx.in.remaining = 0;
1468         rd.readx.in.read_for_execute = false;
1469         status = smb_raw_read(cli1->tree, &rd);
1470         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1471         torture_wait_for_oplock_break(tctx);
1472         CHECK_VAL(break_info.count, 0);
1473         CHECK_VAL(break_info.failures, 0);
1474
1475         smbcli_close(cli1->tree, fnum);
1476
1477 done:
1478         smb_raw_exit(cli1->session);
1479         smb_raw_exit(cli2->session);
1480         smbcli_deltree(cli1->tree, BASEDIR);
1481         return ret;
1482 }
1483
1484 static bool test_raw_oplock_batch5(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1485 {
1486         const char *fname = BASEDIR "\\test_batch5.dat";
1487         NTSTATUS status;
1488         bool ret = true;
1489         union smb_open io;
1490         uint16_t fnum=0;
1491
1492         if (!torture_setup_dir(cli1, BASEDIR)) {
1493                 return false;
1494         }
1495
1496         /* cleanup */
1497         smbcli_unlink(cli1->tree, fname);
1498
1499         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1500
1501         /*
1502           base ntcreatex parms
1503         */
1504         io.generic.level = RAW_OPEN_NTCREATEX;
1505         io.ntcreatex.in.root_fid.fnum = 0;
1506         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1507         io.ntcreatex.in.alloc_size = 0;
1508         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1509         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1510         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1511         io.ntcreatex.in.create_options = 0;
1512         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1513         io.ntcreatex.in.security_flags = 0;
1514         io.ntcreatex.in.fname = fname;
1515
1516         torture_comment(tctx, "BATCH5: a 2nd open should give a break\n");
1517         ZERO_STRUCT(break_info);
1518         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1519
1520         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1521                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1522                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1523         status = smb_raw_open(cli1->tree, tctx, &io);
1524         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1525         fnum = io.ntcreatex.out.file.fnum;
1526         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1527
1528         ZERO_STRUCT(break_info);
1529
1530         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
1531         status = smb_raw_open(cli2->tree, tctx, &io);
1532         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
1533
1534         torture_wait_for_oplock_break(tctx);
1535         CHECK_VAL(break_info.count, 1);
1536         CHECK_VAL(break_info.fnum, fnum);
1537         CHECK_VAL(break_info.level, 1);
1538         CHECK_VAL(break_info.failures, 0);
1539
1540         smbcli_close(cli1->tree, fnum);
1541
1542 done:
1543         smb_raw_exit(cli1->session);
1544         smb_raw_exit(cli2->session);
1545         smbcli_deltree(cli1->tree, BASEDIR);
1546         return ret;
1547 }
1548
1549 static bool test_raw_oplock_batch6(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1550 {
1551         const char *fname = BASEDIR "\\test_batch6.dat";
1552         NTSTATUS status;
1553         bool ret = true;
1554         union smb_open io;
1555         uint16_t fnum=0, fnum2=0;
1556         char c = 0;
1557
1558         if (!torture_setup_dir(cli1, BASEDIR)) {
1559                 return false;
1560         }
1561
1562         /* cleanup */
1563         smbcli_unlink(cli1->tree, fname);
1564
1565         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1566         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
1567
1568         /*
1569           base ntcreatex parms
1570         */
1571         io.generic.level = RAW_OPEN_NTCREATEX;
1572         io.ntcreatex.in.root_fid.fnum = 0;
1573         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1574         io.ntcreatex.in.alloc_size = 0;
1575         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1576         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1577         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1578         io.ntcreatex.in.create_options = 0;
1579         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1580         io.ntcreatex.in.security_flags = 0;
1581         io.ntcreatex.in.fname = fname;
1582
1583         torture_comment(tctx, "BATCH6: a 2nd open should give a break to level II if the first open allowed shared read\n");
1584         ZERO_STRUCT(break_info);
1585
1586         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_WRITE;
1587         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
1588         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1589                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1590                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1591         status = smb_raw_open(cli1->tree, tctx, &io);
1592         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1593         fnum = io.ntcreatex.out.file.fnum;
1594         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1595
1596         ZERO_STRUCT(break_info);
1597
1598         status = smb_raw_open(cli2->tree, tctx, &io);
1599         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1600         fnum2 = io.ntcreatex.out.file.fnum;
1601         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
1602
1603         //torture_wait_for_oplock_break(tctx);
1604         CHECK_VAL(break_info.count, 1);
1605         CHECK_VAL(break_info.fnum, fnum);
1606         CHECK_VAL(break_info.level, 1);
1607         CHECK_VAL(break_info.failures, 0);
1608         ZERO_STRUCT(break_info);
1609
1610         torture_comment(tctx, "write should trigger a break to none on both\n");
1611         smbcli_write(cli1->tree, fnum, 0, &c, 0, 1);
1612
1613         /* We expect two breaks */
1614         torture_wait_for_oplock_break(tctx);
1615         torture_wait_for_oplock_break(tctx);
1616
1617         CHECK_VAL(break_info.count, 2);
1618         CHECK_VAL(break_info.level, 0);
1619         CHECK_VAL(break_info.failures, 0);
1620
1621         smbcli_close(cli1->tree, fnum);
1622         smbcli_close(cli2->tree, fnum2);
1623
1624 done:
1625         smb_raw_exit(cli1->session);
1626         smb_raw_exit(cli2->session);
1627         smbcli_deltree(cli1->tree, BASEDIR);
1628         return ret;
1629 }
1630
1631 static bool test_raw_oplock_batch7(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1632 {
1633         const char *fname = BASEDIR "\\test_batch7.dat";
1634         NTSTATUS status;
1635         bool ret = true;
1636         union smb_open io;
1637         uint16_t fnum=0, fnum2=0;
1638
1639         if (!torture_setup_dir(cli1, BASEDIR)) {
1640                 return false;
1641         }
1642
1643         /* cleanup */
1644         smbcli_unlink(cli1->tree, fname);
1645
1646         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1647
1648         /*
1649           base ntcreatex parms
1650         */
1651         io.generic.level = RAW_OPEN_NTCREATEX;
1652         io.ntcreatex.in.root_fid.fnum = 0;
1653         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1654         io.ntcreatex.in.alloc_size = 0;
1655         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1656         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1657         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1658         io.ntcreatex.in.create_options = 0;
1659         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1660         io.ntcreatex.in.security_flags = 0;
1661         io.ntcreatex.in.fname = fname;
1662
1663         torture_comment(tctx, "BATCH7: a 2nd open should get an oplock when we close instead of ack\n");
1664         ZERO_STRUCT(break_info);
1665         smbcli_oplock_handler(cli1->transport, oplock_handler_close, cli1->tree);
1666
1667         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1668         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1669         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1670                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1671                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1672         status = smb_raw_open(cli1->tree, tctx, &io);
1673         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1674         fnum2 = io.ntcreatex.out.file.fnum;
1675         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1676
1677         ZERO_STRUCT(break_info);
1678
1679         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1680                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1681                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1682         status = smb_raw_open(cli2->tree, tctx, &io);
1683         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1684         fnum = io.ntcreatex.out.file.fnum;
1685         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1686
1687         torture_wait_for_oplock_break(tctx);
1688         CHECK_VAL(break_info.count, 1);
1689         CHECK_VAL(break_info.fnum, fnum2);
1690         CHECK_VAL(break_info.level, 1);
1691         CHECK_VAL(break_info.failures, 0);
1692
1693         smbcli_close(cli2->tree, fnum);
1694
1695 done:
1696         smb_raw_exit(cli1->session);
1697         smb_raw_exit(cli2->session);
1698         smbcli_deltree(cli1->tree, BASEDIR);
1699         return ret;
1700 }
1701
1702 static bool test_raw_oplock_batch8(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1703 {
1704         const char *fname = BASEDIR "\\test_batch8.dat";
1705         NTSTATUS status;
1706         bool ret = true;
1707         union smb_open io;
1708         uint16_t fnum=0, fnum2=0;
1709
1710         if (!torture_setup_dir(cli1, BASEDIR)) {
1711                 return false;
1712         }
1713
1714         /* cleanup */
1715         smbcli_unlink(cli1->tree, fname);
1716
1717         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1718
1719         /*
1720           base ntcreatex parms
1721         */
1722         io.generic.level = RAW_OPEN_NTCREATEX;
1723         io.ntcreatex.in.root_fid.fnum = 0;
1724         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1725         io.ntcreatex.in.alloc_size = 0;
1726         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1727         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1728         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1729         io.ntcreatex.in.create_options = 0;
1730         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1731         io.ntcreatex.in.security_flags = 0;
1732         io.ntcreatex.in.fname = fname;
1733
1734         torture_comment(tctx, "BATCH8: open with batch oplock\n");
1735         ZERO_STRUCT(break_info);
1736         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1737
1738         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1739                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1740                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1741         status = smb_raw_open(cli1->tree, tctx, &io);
1742         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1743         fnum = io.ntcreatex.out.file.fnum;
1744         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1745
1746         ZERO_STRUCT(break_info);
1747         torture_comment(tctx, "second open with attributes only shouldn't cause oplock break\n");
1748
1749         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1750                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1751                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1752         io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
1753         status = smb_raw_open(cli2->tree, tctx, &io);
1754         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1755         fnum2 = io.ntcreatex.out.file.fnum;
1756         CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
1757         torture_wait_for_oplock_break(tctx);
1758         CHECK_VAL(break_info.count, 0);
1759         CHECK_VAL(break_info.failures, 0);
1760
1761         smbcli_close(cli1->tree, fnum);
1762         smbcli_close(cli2->tree, fnum2);
1763
1764 done:
1765         smb_raw_exit(cli1->session);
1766         smb_raw_exit(cli2->session);
1767         smbcli_deltree(cli1->tree, BASEDIR);
1768         return ret;
1769 }
1770
1771 static bool test_raw_oplock_batch9(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1772 {
1773         const char *fname = BASEDIR "\\test_batch9.dat";
1774         NTSTATUS status;
1775         bool ret = true;
1776         union smb_open io;
1777         uint16_t fnum=0, fnum2=0;
1778         char c = 0;
1779
1780         if (!torture_setup_dir(cli1, BASEDIR)) {
1781                 return false;
1782         }
1783
1784         /* cleanup */
1785         smbcli_unlink(cli1->tree, fname);
1786
1787         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1788
1789         /*
1790           base ntcreatex parms
1791         */
1792         io.generic.level = RAW_OPEN_NTCREATEX;
1793         io.ntcreatex.in.root_fid.fnum = 0;
1794         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1795         io.ntcreatex.in.alloc_size = 0;
1796         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1797         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1798         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1799         io.ntcreatex.in.create_options = 0;
1800         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1801         io.ntcreatex.in.security_flags = 0;
1802         io.ntcreatex.in.fname = fname;
1803
1804         torture_comment(tctx, "BATCH9: open with attributes only can create file\n");
1805
1806         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1807                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1808                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1809         io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
1810         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
1811         status = smb_raw_open(cli1->tree, tctx, &io);
1812         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1813         fnum = io.ntcreatex.out.file.fnum;
1814         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1815
1816         torture_comment(tctx, "Subsequent normal open should break oplock on attribute only open to level II\n");
1817
1818         ZERO_STRUCT(break_info);
1819         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1820
1821         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1822                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1823                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1824         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1825         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1826         status = smb_raw_open(cli2->tree, tctx, &io);
1827         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1828         fnum2 = io.ntcreatex.out.file.fnum;
1829         torture_wait_for_oplock_break(tctx);
1830         CHECK_VAL(break_info.count, 1);
1831         CHECK_VAL(break_info.fnum, fnum);
1832         CHECK_VAL(break_info.failures, 0);
1833         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
1834         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
1835         smbcli_close(cli2->tree, fnum2);
1836
1837         torture_comment(tctx, "third oplocked open should grant level2 without break\n");
1838         ZERO_STRUCT(break_info);
1839         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1840         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
1841         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1842                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1843                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1844         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1845         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1846         status = smb_raw_open(cli2->tree, tctx, &io);
1847         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1848         fnum2 = io.ntcreatex.out.file.fnum;
1849         torture_wait_for_oplock_break(tctx);
1850         CHECK_VAL(break_info.count, 0);
1851         CHECK_VAL(break_info.failures, 0);
1852         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
1853
1854         ZERO_STRUCT(break_info);
1855
1856         torture_comment(tctx, "write should trigger a break to none on both\n");
1857         smbcli_write(cli2->tree, fnum2, 0, &c, 0, 1);
1858
1859         /* We expect two breaks */
1860         torture_wait_for_oplock_break(tctx);
1861         torture_wait_for_oplock_break(tctx);
1862
1863         CHECK_VAL(break_info.count, 2);
1864         CHECK_VAL(break_info.level, 0);
1865         CHECK_VAL(break_info.failures, 0);
1866
1867         smbcli_close(cli1->tree, fnum);
1868         smbcli_close(cli2->tree, fnum2);
1869
1870 done:
1871         smb_raw_exit(cli1->session);
1872         smb_raw_exit(cli2->session);
1873         smbcli_deltree(cli1->tree, BASEDIR);
1874         return ret;
1875 }
1876
1877 static bool test_raw_oplock_batch9a(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1878 {
1879         const char *fname = BASEDIR "\\test_batch9a.dat";
1880         NTSTATUS status;
1881         bool ret = true;
1882         union smb_open io;
1883         uint16_t fnum=0, fnum2=0;
1884         char c = 0;
1885
1886         if (!torture_setup_dir(cli1, BASEDIR)) {
1887                 return false;
1888         }
1889
1890         /* cleanup */
1891         smbcli_unlink(cli1->tree, fname);
1892
1893         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1894
1895         /*
1896           base ntcreatex parms
1897         */
1898         io.generic.level = RAW_OPEN_NTCREATEX;
1899         io.ntcreatex.in.root_fid.fnum = 0;
1900         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1901         io.ntcreatex.in.alloc_size = 0;
1902         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
1903         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
1904         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
1905         io.ntcreatex.in.create_options = 0;
1906         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
1907         io.ntcreatex.in.security_flags = 0;
1908         io.ntcreatex.in.fname = fname;
1909
1910         torture_comment(tctx, "BATCH9: open with attributes only can create file\n");
1911
1912         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1913                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1914                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1915         io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
1916         status = smb_raw_open(cli1->tree, tctx, &io);
1917         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1918         fnum = io.ntcreatex.out.file.fnum;
1919         CHECK_VAL(io.ntcreatex.out.create_action, FILE_WAS_CREATED);
1920         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
1921
1922         torture_comment(tctx, "Subsequent attributes open should not break\n");
1923
1924         ZERO_STRUCT(break_info);
1925         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1926
1927         status = smb_raw_open(cli2->tree, tctx, &io);
1928         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1929         fnum2 = io.ntcreatex.out.file.fnum;
1930         torture_wait_for_oplock_break(tctx);
1931         CHECK_VAL(break_info.count, 0);
1932         CHECK_VAL(io.ntcreatex.out.create_action, FILE_WAS_OPENED);
1933         CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
1934         smbcli_close(cli2->tree, fnum2);
1935
1936         torture_comment(tctx, "Subsequent normal open should break oplock on attribute only open to level II\n");
1937
1938         ZERO_STRUCT(break_info);
1939         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1940
1941         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1942                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1943                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1944         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1945         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1946         status = smb_raw_open(cli2->tree, tctx, &io);
1947         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1948         fnum2 = io.ntcreatex.out.file.fnum;
1949         torture_wait_for_oplock_break(tctx);
1950         CHECK_VAL(break_info.count, 1);
1951         CHECK_VAL(break_info.fnum, fnum);
1952         CHECK_VAL(break_info.failures, 0);
1953         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
1954         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
1955         smbcli_close(cli2->tree, fnum2);
1956
1957         torture_comment(tctx, "third oplocked open should grant level2 without break\n");
1958         ZERO_STRUCT(break_info);
1959         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
1960         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
1961         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
1962                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
1963                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
1964         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
1965         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
1966         status = smb_raw_open(cli2->tree, tctx, &io);
1967         CHECK_STATUS(tctx, status, NT_STATUS_OK);
1968         fnum2 = io.ntcreatex.out.file.fnum;
1969         torture_wait_for_oplock_break(tctx);
1970         CHECK_VAL(break_info.count, 0);
1971         CHECK_VAL(break_info.failures, 0);
1972         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
1973
1974         ZERO_STRUCT(break_info);
1975
1976         torture_comment(tctx, "write should trigger a break to none on both\n");
1977         smbcli_write(cli2->tree, fnum2, 0, &c, 0, 1);
1978
1979         /* We expect two breaks */
1980         torture_wait_for_oplock_break(tctx);
1981         torture_wait_for_oplock_break(tctx);
1982
1983         CHECK_VAL(break_info.count, 2);
1984         CHECK_VAL(break_info.level, 0);
1985         CHECK_VAL(break_info.failures, 0);
1986
1987         smbcli_close(cli1->tree, fnum);
1988         smbcli_close(cli2->tree, fnum2);
1989
1990 done:
1991         smb_raw_exit(cli1->session);
1992         smb_raw_exit(cli2->session);
1993         smbcli_deltree(cli1->tree, BASEDIR);
1994         return ret;
1995 }
1996
1997 static bool test_raw_oplock_batch10(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
1998 {
1999         const char *fname = BASEDIR "\\test_batch10.dat";
2000         NTSTATUS status;
2001         bool ret = true;
2002         union smb_open io;
2003         uint16_t fnum=0, fnum2=0;
2004
2005         if (!torture_setup_dir(cli1, BASEDIR)) {
2006                 return false;
2007         }
2008
2009         /* cleanup */
2010         smbcli_unlink(cli1->tree, fname);
2011
2012         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2013
2014         /*
2015           base ntcreatex parms
2016         */
2017         io.generic.level = RAW_OPEN_NTCREATEX;
2018         io.ntcreatex.in.root_fid.fnum = 0;
2019         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2020         io.ntcreatex.in.alloc_size = 0;
2021         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2022         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2023         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2024         io.ntcreatex.in.create_options = 0;
2025         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2026         io.ntcreatex.in.security_flags = 0;
2027         io.ntcreatex.in.fname = fname;
2028
2029         torture_comment(tctx, "BATCH10: Open with oplock after a non-oplock open should grant level2\n");
2030         ZERO_STRUCT(break_info);
2031         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
2032         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2033         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2034                 NTCREATEX_SHARE_ACCESS_WRITE|
2035                 NTCREATEX_SHARE_ACCESS_DELETE;
2036         status = smb_raw_open(cli1->tree, tctx, &io);
2037         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2038         fnum = io.ntcreatex.out.file.fnum;
2039         torture_wait_for_oplock_break(tctx);
2040         CHECK_VAL(break_info.count, 0);
2041         CHECK_VAL(break_info.failures, 0);
2042         CHECK_VAL(io.ntcreatex.out.oplock_level, 0);
2043
2044         {
2045                 union smb_write wr;
2046                 wr.write.level = RAW_WRITE_WRITE;
2047                 wr.write.in.file.fnum = fnum;
2048                 wr.write.in.count = 1;
2049                 wr.write.in.offset = 0;
2050                 wr.write.in.remaining = 0;
2051                 wr.write.in.data = (const uint8_t *)"x";
2052                 status = smb_raw_write(cli1->tree, &wr);
2053                 CHECK_STATUS(tctx, status, NT_STATUS_OK);
2054         }
2055
2056         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
2057
2058         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2059                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2060                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2061         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2062         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2063                 NTCREATEX_SHARE_ACCESS_WRITE|
2064                 NTCREATEX_SHARE_ACCESS_DELETE;
2065         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
2066         status = smb_raw_open(cli2->tree, tctx, &io);
2067         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2068         fnum2 = io.ntcreatex.out.file.fnum;
2069         torture_wait_for_oplock_break(tctx);
2070         CHECK_VAL(break_info.count, 0);
2071         CHECK_VAL(break_info.failures, 0);
2072         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
2073
2074         torture_comment(tctx, "write should trigger a break to none\n");
2075         {
2076                 union smb_write wr;
2077                 wr.write.level = RAW_WRITE_WRITE;
2078                 wr.write.in.file.fnum = fnum;
2079                 wr.write.in.count = 1;
2080                 wr.write.in.offset = 0;
2081                 wr.write.in.remaining = 0;
2082                 wr.write.in.data = (const uint8_t *)"x";
2083                 status = smb_raw_write(cli1->tree, &wr);
2084                 CHECK_STATUS(tctx, status, NT_STATUS_OK);
2085         }
2086
2087         torture_wait_for_oplock_break(tctx);
2088
2089         CHECK_VAL(break_info.count, 1);
2090         CHECK_VAL(break_info.fnum, fnum2);
2091         CHECK_VAL(break_info.level, 0);
2092         CHECK_VAL(break_info.failures, 0);
2093
2094         smbcli_close(cli1->tree, fnum);
2095         smbcli_close(cli2->tree, fnum2);
2096
2097 done:
2098         smb_raw_exit(cli1->session);
2099         smb_raw_exit(cli2->session);
2100         smbcli_deltree(cli1->tree, BASEDIR);
2101         return ret;
2102 }
2103
2104 static bool test_raw_oplock_batch11(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2105 {
2106         const char *fname = BASEDIR "\\test_batch11.dat";
2107         NTSTATUS status;
2108         bool ret = true;
2109         union smb_open io;
2110         union smb_setfileinfo sfi;
2111         uint16_t fnum=0;
2112
2113         if (!torture_setup_dir(cli1, BASEDIR)) {
2114                 return false;
2115         }
2116
2117         /* cleanup */
2118         smbcli_unlink(cli1->tree, fname);
2119
2120         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2121
2122         /*
2123           base ntcreatex parms
2124         */
2125         io.generic.level = RAW_OPEN_NTCREATEX;
2126         io.ntcreatex.in.root_fid.fnum = 0;
2127         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2128         io.ntcreatex.in.alloc_size = 0;
2129         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2130         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_WRITE;
2131         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2132         io.ntcreatex.in.create_options = 0;
2133         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2134         io.ntcreatex.in.security_flags = 0;
2135         io.ntcreatex.in.fname = fname;
2136
2137         /* Test if a set-eof on pathname breaks an exclusive oplock. */
2138         torture_comment(tctx, "BATCH11: Test if setpathinfo set EOF breaks oplocks.\n");
2139
2140         ZERO_STRUCT(break_info);
2141
2142         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2143                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2144                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2145         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2146         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2147                 NTCREATEX_SHARE_ACCESS_WRITE|
2148                 NTCREATEX_SHARE_ACCESS_DELETE;
2149         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
2150         status = smb_raw_open(cli1->tree, tctx, &io);
2151         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2152         fnum = io.ntcreatex.out.file.fnum;
2153         torture_wait_for_oplock_break(tctx);
2154         CHECK_VAL(break_info.count, 0);
2155         CHECK_VAL(break_info.failures, 0);
2156         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2157
2158         ZERO_STRUCT(sfi);
2159         sfi.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
2160         sfi.generic.in.file.path = fname;
2161         sfi.end_of_file_info.in.size = 100;
2162
2163         status = smb_raw_setpathinfo(cli2->tree, &sfi);
2164         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2165
2166         torture_wait_for_oplock_break(tctx);
2167         CHECK_VAL(break_info.count, get_setinfo_break_count(tctx));
2168         CHECK_VAL(break_info.failures, 0);
2169         CHECK_VAL(break_info.level, 0);
2170
2171         smbcli_close(cli1->tree, fnum);
2172
2173 done:
2174         smb_raw_exit(cli1->session);
2175         smb_raw_exit(cli2->session);
2176         smbcli_deltree(cli1->tree, BASEDIR);
2177         return ret;
2178 }
2179
2180 static bool test_raw_oplock_batch12(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2181 {
2182         const char *fname = BASEDIR "\\test_batch12.dat";
2183         NTSTATUS status;
2184         bool ret = true;
2185         union smb_open io;
2186         union smb_setfileinfo sfi;
2187         uint16_t fnum=0;
2188
2189         if (!torture_setup_dir(cli1, BASEDIR)) {
2190                 return false;
2191         }
2192
2193         /* cleanup */
2194         smbcli_unlink(cli1->tree, fname);
2195
2196         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2197
2198         /*
2199           base ntcreatex parms
2200         */
2201         io.generic.level = RAW_OPEN_NTCREATEX;
2202         io.ntcreatex.in.root_fid.fnum = 0;
2203         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2204         io.ntcreatex.in.alloc_size = 0;
2205         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2206         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2207         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2208         io.ntcreatex.in.create_options = 0;
2209         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2210         io.ntcreatex.in.security_flags = 0;
2211         io.ntcreatex.in.fname = fname;
2212
2213         /* Test if a set-allocation size on pathname breaks an exclusive oplock. */
2214         torture_comment(tctx, "BATCH12: Test if setpathinfo allocation size breaks oplocks.\n");
2215
2216         ZERO_STRUCT(break_info);
2217         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2218
2219         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2220                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2221                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2222         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2223         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2224                 NTCREATEX_SHARE_ACCESS_WRITE|
2225                 NTCREATEX_SHARE_ACCESS_DELETE;
2226         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
2227         status = smb_raw_open(cli1->tree, tctx, &io);
2228         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2229         fnum = io.ntcreatex.out.file.fnum;
2230         torture_wait_for_oplock_break(tctx);
2231         CHECK_VAL(break_info.count, 0);
2232         CHECK_VAL(break_info.failures, 0);
2233         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2234
2235         ZERO_STRUCT(sfi);
2236         sfi.generic.level = SMB_SFILEINFO_ALLOCATION_INFORMATION;
2237         sfi.generic.in.file.path = fname;
2238         sfi.allocation_info.in.alloc_size = 65536 * 8;
2239
2240         status = smb_raw_setpathinfo(cli2->tree, &sfi);
2241         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2242
2243         torture_wait_for_oplock_break(tctx);
2244         CHECK_VAL(break_info.count, get_setinfo_break_count(tctx));
2245         CHECK_VAL(break_info.failures, 0);
2246         CHECK_VAL(break_info.level, 0);
2247
2248         smbcli_close(cli1->tree, fnum);
2249
2250 done:
2251         smb_raw_exit(cli1->session);
2252         smb_raw_exit(cli2->session);
2253         smbcli_deltree(cli1->tree, BASEDIR);
2254         return ret;
2255 }
2256
2257 static bool test_raw_oplock_batch13(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2258 {
2259         const char *fname = BASEDIR "\\test_batch13.dat";
2260         NTSTATUS status;
2261         bool ret = true;
2262         union smb_open io;
2263         uint16_t fnum=0, fnum2=0;
2264
2265         if (!torture_setup_dir(cli1, BASEDIR)) {
2266                 return false;
2267         }
2268
2269         /* cleanup */
2270         smbcli_unlink(cli1->tree, fname);
2271
2272         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2273         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli1->tree);
2274
2275         /*
2276           base ntcreatex parms
2277         */
2278         io.generic.level = RAW_OPEN_NTCREATEX;
2279         io.ntcreatex.in.root_fid.fnum = 0;
2280         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2281         io.ntcreatex.in.alloc_size = 0;
2282         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2283         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2284         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2285         io.ntcreatex.in.create_options = 0;
2286         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2287         io.ntcreatex.in.security_flags = 0;
2288         io.ntcreatex.in.fname = fname;
2289
2290         torture_comment(tctx, "BATCH13: open with batch oplock\n");
2291         ZERO_STRUCT(break_info);
2292
2293         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2294                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2295                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2296         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2297                 NTCREATEX_SHARE_ACCESS_WRITE|
2298                 NTCREATEX_SHARE_ACCESS_DELETE;
2299         status = smb_raw_open(cli1->tree, tctx, &io);
2300         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2301         fnum = io.ntcreatex.out.file.fnum;
2302         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2303
2304         ZERO_STRUCT(break_info);
2305
2306         torture_comment(tctx, "second open with attributes only and NTCREATEX_DISP_OVERWRITE dispostion causes oplock break\n");
2307
2308         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2309                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2310                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2311         io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
2312         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2313                 NTCREATEX_SHARE_ACCESS_WRITE|
2314                 NTCREATEX_SHARE_ACCESS_DELETE;
2315         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE;
2316         status = smb_raw_open(cli2->tree, tctx, &io);
2317         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2318         fnum2 = io.ntcreatex.out.file.fnum;
2319         torture_wait_for_oplock_break(tctx);
2320         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
2321         CHECK_VAL(break_info.count, get_break_level1_to_none_count(tctx));
2322         CHECK_VAL(break_info.failures, 0);
2323
2324         smbcli_close(cli1->tree, fnum);
2325         smbcli_close(cli2->tree, fnum2);
2326
2327 done:
2328         smb_raw_exit(cli1->session);
2329         smb_raw_exit(cli2->session);
2330         smbcli_deltree(cli1->tree, BASEDIR);
2331         return ret;
2332 }
2333
2334 static bool test_raw_oplock_batch14(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2335 {
2336         const char *fname = BASEDIR "\\test_batch14.dat";
2337         NTSTATUS status;
2338         bool ret = true;
2339         union smb_open io;
2340         uint16_t fnum=0, fnum2=0;
2341
2342         if (!torture_setup_dir(cli1, BASEDIR)) {
2343                 return false;
2344         }
2345
2346         /* cleanup */
2347         smbcli_unlink(cli1->tree, fname);
2348
2349         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2350
2351         /*
2352           base ntcreatex parms
2353         */
2354         io.generic.level = RAW_OPEN_NTCREATEX;
2355         io.ntcreatex.in.root_fid.fnum = 0;
2356         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2357         io.ntcreatex.in.alloc_size = 0;
2358         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2359         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2360         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2361         io.ntcreatex.in.create_options = 0;
2362         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2363         io.ntcreatex.in.security_flags = 0;
2364         io.ntcreatex.in.fname = fname;
2365
2366         torture_comment(tctx, "BATCH14: open with batch oplock\n");
2367         ZERO_STRUCT(break_info);
2368
2369         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2370                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2371                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2372         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2373                 NTCREATEX_SHARE_ACCESS_WRITE|
2374                 NTCREATEX_SHARE_ACCESS_DELETE;
2375         status = smb_raw_open(cli1->tree, tctx, &io);
2376         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2377         fnum = io.ntcreatex.out.file.fnum;
2378         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2379
2380         ZERO_STRUCT(break_info);
2381
2382         torture_comment(tctx, "second open with attributes only and NTCREATEX_DISP_SUPERSEDE dispostion causes oplock break\n");
2383
2384         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2385                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2386                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2387         io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
2388         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2389                 NTCREATEX_SHARE_ACCESS_WRITE|
2390                 NTCREATEX_SHARE_ACCESS_DELETE;
2391         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE;
2392         status = smb_raw_open(cli2->tree, tctx, &io);
2393         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2394         fnum2 = io.ntcreatex.out.file.fnum;
2395         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
2396
2397         torture_wait_for_oplock_break(tctx);
2398         CHECK_VAL(break_info.count, get_break_level1_to_none_count(tctx));
2399         CHECK_VAL(break_info.failures, 0);
2400
2401         smbcli_close(cli1->tree, fnum);
2402         smbcli_close(cli2->tree, fnum2);
2403 done:
2404         smb_raw_exit(cli1->session);
2405         smb_raw_exit(cli2->session);
2406         smbcli_deltree(cli1->tree, BASEDIR);
2407         return ret;
2408 }
2409
2410 static bool test_raw_oplock_batch15(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2411 {
2412         const char *fname = BASEDIR "\\test_batch15.dat";
2413         NTSTATUS status;
2414         bool ret = true;
2415         union smb_open io;
2416         union smb_fileinfo qfi;
2417         uint16_t fnum=0;
2418
2419         if (!torture_setup_dir(cli1, BASEDIR)) {
2420                 return false;
2421         }
2422
2423         /* cleanup */
2424         smbcli_unlink(cli1->tree, fname);
2425
2426         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2427
2428         /*
2429           base ntcreatex parms
2430         */
2431         io.generic.level = RAW_OPEN_NTCREATEX;
2432         io.ntcreatex.in.root_fid.fnum = 0;
2433         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2434         io.ntcreatex.in.alloc_size = 0;
2435         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2436         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2437         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2438         io.ntcreatex.in.create_options = 0;
2439         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2440         io.ntcreatex.in.security_flags = 0;
2441         io.ntcreatex.in.fname = fname;
2442
2443         /* Test if a qpathinfo all info on pathname breaks a batch oplock. */
2444         torture_comment(tctx, "BATCH15: Test if qpathinfo all info breaks a batch oplock (should not).\n");
2445
2446         ZERO_STRUCT(break_info);
2447
2448         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2449                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2450                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2451         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2452         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2453                 NTCREATEX_SHARE_ACCESS_WRITE|
2454                 NTCREATEX_SHARE_ACCESS_DELETE;
2455         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2456         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
2457         status = smb_raw_open(cli1->tree, tctx, &io);
2458         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2459         fnum = io.ntcreatex.out.file.fnum;
2460
2461         torture_wait_for_oplock_break(tctx);
2462         CHECK_VAL(break_info.count, 0);
2463         CHECK_VAL(break_info.failures, 0);
2464         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2465
2466         ZERO_STRUCT(qfi);
2467         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
2468         qfi.generic.in.file.path = fname;
2469
2470         status = smb_raw_pathinfo(cli2->tree, tctx, &qfi);
2471         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2472
2473         torture_wait_for_oplock_break(tctx);
2474         CHECK_VAL(break_info.count, 0);
2475
2476         smbcli_close(cli1->tree, fnum);
2477
2478 done:
2479         smb_raw_exit(cli1->session);
2480         smb_raw_exit(cli2->session);
2481         smbcli_deltree(cli1->tree, BASEDIR);
2482         return ret;
2483 }
2484
2485 static bool test_raw_oplock_batch16(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2486 {
2487         const char *fname = BASEDIR "\\test_batch16.dat";
2488         NTSTATUS status;
2489         bool ret = true;
2490         union smb_open io;
2491         uint16_t fnum=0, fnum2=0;
2492
2493         if (!torture_setup_dir(cli1, BASEDIR)) {
2494                 return false;
2495         }
2496
2497         /* cleanup */
2498         smbcli_unlink(cli1->tree, fname);
2499
2500         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2501         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli1->tree);
2502
2503         /*
2504           base ntcreatex parms
2505         */
2506         io.generic.level = RAW_OPEN_NTCREATEX;
2507         io.ntcreatex.in.root_fid.fnum = 0;
2508         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2509         io.ntcreatex.in.alloc_size = 0;
2510         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2511         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2512         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2513         io.ntcreatex.in.create_options = 0;
2514         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2515         io.ntcreatex.in.security_flags = 0;
2516         io.ntcreatex.in.fname = fname;
2517
2518         torture_comment(tctx, "BATCH16: open with batch oplock\n");
2519         ZERO_STRUCT(break_info);
2520
2521         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2522                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2523                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2524         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2525                 NTCREATEX_SHARE_ACCESS_WRITE|
2526                 NTCREATEX_SHARE_ACCESS_DELETE;
2527         status = smb_raw_open(cli1->tree, tctx, &io);
2528         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2529         fnum = io.ntcreatex.out.file.fnum;
2530         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2531
2532         ZERO_STRUCT(break_info);
2533
2534         torture_comment(tctx, "second open with attributes only and NTCREATEX_DISP_OVERWRITE_IF dispostion causes oplock break\n");
2535
2536         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2537                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2538                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2539         io.ntcreatex.in.access_mask = SEC_FILE_READ_ATTRIBUTE|SEC_FILE_WRITE_ATTRIBUTE|SEC_STD_SYNCHRONIZE;
2540         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
2541                 NTCREATEX_SHARE_ACCESS_WRITE|
2542                 NTCREATEX_SHARE_ACCESS_DELETE;
2543         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OVERWRITE_IF;
2544         status = smb_raw_open(cli2->tree, tctx, &io);
2545         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2546         fnum2 = io.ntcreatex.out.file.fnum;
2547         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
2548
2549         torture_wait_for_oplock_break(tctx);
2550         CHECK_VAL(break_info.count, get_break_level1_to_none_count(tctx));
2551         CHECK_VAL(break_info.failures, 0);
2552
2553         smbcli_close(cli1->tree, fnum);
2554         smbcli_close(cli2->tree, fnum2);
2555
2556 done:
2557         smb_raw_exit(cli1->session);
2558         smb_raw_exit(cli2->session);
2559         smbcli_deltree(cli1->tree, BASEDIR);
2560         return ret;
2561 }
2562
2563 static bool test_raw_oplock_batch17(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2564 {
2565         const char *fname1 = BASEDIR "\\test_batch17_1.dat";
2566         const char *fname2 = BASEDIR "\\test_batch17_2.dat";
2567         NTSTATUS status;
2568         bool ret = true;
2569         union smb_open io;
2570         union smb_rename rn;
2571         uint16_t fnum=0;
2572
2573         if (!torture_setup_dir(cli1, BASEDIR)) {
2574                 return false;
2575         }
2576
2577         /* cleanup */
2578         smbcli_unlink(cli1->tree, fname1);
2579         smbcli_unlink(cli1->tree, fname2);
2580
2581         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2582
2583         /*
2584           base ntcreatex parms
2585         */
2586         io.generic.level = RAW_OPEN_NTCREATEX;
2587         io.ntcreatex.in.root_fid.fnum = 0;
2588         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2589         io.ntcreatex.in.alloc_size = 0;
2590         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2591         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2592         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2593         io.ntcreatex.in.create_options = 0;
2594         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2595         io.ntcreatex.in.security_flags = 0;
2596         io.ntcreatex.in.fname = fname1;
2597
2598         torture_comment(tctx, "BATCH17: open a file with an batch oplock (share mode: none)\n");
2599
2600         ZERO_STRUCT(break_info);
2601         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2602                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2603                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2604
2605         status = smb_raw_open(cli1->tree, tctx, &io);
2606         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2607         fnum = io.ntcreatex.out.file.fnum;
2608         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2609
2610         torture_comment(tctx, "rename should trigger a break\n");
2611         ZERO_STRUCT(rn);
2612         rn.generic.level = RAW_RENAME_RENAME;
2613         rn.rename.in.pattern1 = fname1;
2614         rn.rename.in.pattern2 = fname2;
2615         rn.rename.in.attrib = 0;
2616
2617         torture_comment(tctx, "trying rename while first file open\n");
2618         status = smb_raw_rename(cli2->tree, &rn);
2619         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
2620
2621         torture_wait_for_oplock_break(tctx);
2622         CHECK_VAL(break_info.count, 1);
2623         CHECK_VAL(break_info.failures, 0);
2624         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
2625
2626         smbcli_close(cli1->tree, fnum);
2627
2628 done:
2629         smb_raw_exit(cli1->session);
2630         smb_raw_exit(cli2->session);
2631         smbcli_deltree(cli1->tree, BASEDIR);
2632         return ret;
2633 }
2634
2635 static bool test_raw_oplock_batch18(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2636 {
2637         const char *fname1 = BASEDIR "\\test_batch18_1.dat";
2638         const char *fname2 = BASEDIR "\\test_batch18_2.dat";
2639         NTSTATUS status;
2640         bool ret = true;
2641         union smb_open io;
2642         union smb_rename rn;
2643         uint16_t fnum=0;
2644
2645         if (!torture_setup_dir(cli1, BASEDIR)) {
2646                 return false;
2647         }
2648
2649         /* cleanup */
2650         smbcli_unlink(cli1->tree, fname1);
2651         smbcli_unlink(cli1->tree, fname2);
2652
2653         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2654
2655         /*
2656           base ntcreatex parms
2657         */
2658         io.generic.level = RAW_OPEN_NTCREATEX;
2659         io.ntcreatex.in.root_fid.fnum = 0;
2660         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2661         io.ntcreatex.in.alloc_size = 0;
2662         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2663         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2664         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2665         io.ntcreatex.in.create_options = 0;
2666         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2667         io.ntcreatex.in.security_flags = 0;
2668         io.ntcreatex.in.fname = fname1;
2669
2670         torture_comment(tctx, "BATCH18: open a file with an batch oplock (share mode: none)\n");
2671
2672         ZERO_STRUCT(break_info);
2673         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2674                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2675                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2676
2677         status = smb_raw_open(cli1->tree, tctx, &io);
2678         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2679         fnum = io.ntcreatex.out.file.fnum;
2680         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2681
2682         torture_comment(tctx, "ntrename should trigger a break\n");
2683         ZERO_STRUCT(rn);
2684         rn.generic.level = RAW_RENAME_NTRENAME;
2685         rn.ntrename.in.attrib   = 0;
2686         rn.ntrename.in.flags    = RENAME_FLAG_RENAME;
2687         rn.ntrename.in.old_name = fname1;
2688         rn.ntrename.in.new_name = fname2;
2689         torture_comment(tctx, "trying rename while first file open\n");
2690         status = smb_raw_rename(cli2->tree, &rn);
2691         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
2692
2693         torture_wait_for_oplock_break(tctx);
2694         CHECK_VAL(break_info.count, 1);
2695         CHECK_VAL(break_info.failures, 0);
2696         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
2697
2698         smbcli_close(cli1->tree, fnum);
2699
2700 done:
2701         smb_raw_exit(cli1->session);
2702         smb_raw_exit(cli2->session);
2703         smbcli_deltree(cli1->tree, BASEDIR);
2704         return ret;
2705 }
2706
2707 static bool test_raw_oplock_batch19(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2708 {
2709         const char *fname1 = BASEDIR "\\test_batch19_1.dat";
2710         const char *fname2 = BASEDIR "\\test_batch19_2.dat";
2711         const char *fname3 = BASEDIR "\\test_batch19_3.dat";
2712         NTSTATUS status;
2713         bool ret = true;
2714         union smb_open io;
2715         union smb_fileinfo qfi;
2716         union smb_setfileinfo sfi;
2717         uint16_t fnum=0;
2718
2719         if (!torture_setup_dir(cli1, BASEDIR)) {
2720                 return false;
2721         }
2722
2723         /* cleanup */
2724         smbcli_unlink(cli1->tree, fname1);
2725         smbcli_unlink(cli1->tree, fname2);
2726         smbcli_unlink(cli1->tree, fname3);
2727
2728         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2729
2730         /*
2731           base ntcreatex parms
2732         */
2733         io.generic.level = RAW_OPEN_NTCREATEX;
2734         io.ntcreatex.in.root_fid.fnum = 0;
2735         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2736         io.ntcreatex.in.alloc_size = 0;
2737         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2738         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
2739             NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
2740         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2741         io.ntcreatex.in.create_options = 0;
2742         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2743         io.ntcreatex.in.security_flags = 0;
2744         io.ntcreatex.in.fname = fname1;
2745
2746         torture_comment(tctx, "BATCH19: open a file with an batch oplock (share mode: none)\n");
2747         ZERO_STRUCT(break_info);
2748         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2749                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
2750                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
2751         status = smb_raw_open(cli1->tree, tctx, &io);
2752         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2753         fnum = io.ntcreatex.out.file.fnum;
2754         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2755
2756         torture_comment(tctx, "setpathinfo rename info should trigger a break "
2757             "to none\n");
2758         ZERO_STRUCT(sfi);
2759         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
2760         sfi.generic.in.file.path = fname1;
2761         sfi.rename_information.in.overwrite     = 0;
2762         sfi.rename_information.in.root_fid      = 0;
2763         sfi.rename_information.in.new_name      = fname2+strlen(BASEDIR)+1;
2764
2765         status = smb_raw_setpathinfo(cli2->tree, &sfi);
2766         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2767
2768         torture_wait_for_oplock_break(tctx);
2769
2770         CHECK_VAL(break_info.failures, 0);
2771
2772         if (TARGET_IS_WINXP(tctx) || TARGET_IS_W2K12(tctx)) {
2773                 /* Win XP breaks to level2. */
2774                 CHECK_VAL(break_info.count, 1);
2775                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
2776         } else if (TARGET_IS_W2K3(tctx) || TARGET_IS_W2K8(tctx) ||
2777             TARGET_IS_SAMBA3(tctx) || TARGET_IS_SAMBA4(tctx)) {
2778                 /* Win2K3/2k8 incorrectly doesn't break at all. */
2779                 CHECK_VAL(break_info.count, 0);
2780         } else {
2781                 /* win7/2k8r2 break to none. */
2782                 CHECK_VAL(break_info.count, 1);
2783                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
2784         }
2785
2786         ZERO_STRUCT(qfi);
2787         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
2788         qfi.generic.in.file.fnum = fnum;
2789
2790         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
2791         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2792         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname2);
2793
2794         /* Close and re-open file with oplock. */
2795         smbcli_close(cli1->tree, fnum);
2796         status = smb_raw_open(cli1->tree, tctx, &io);
2797         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2798         fnum = io.ntcreatex.out.file.fnum;
2799         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
2800
2801         torture_comment(tctx, "setfileinfo rename info on a client's own fid "
2802             "should not trigger a break nor a violation\n");
2803         ZERO_STRUCT(break_info);
2804         ZERO_STRUCT(sfi);
2805         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
2806         sfi.generic.in.file.fnum = fnum;
2807         sfi.rename_information.in.overwrite     = 0;
2808         sfi.rename_information.in.root_fid      = 0;
2809         sfi.rename_information.in.new_name      = fname3+strlen(BASEDIR)+1;
2810
2811         status = smb_raw_setfileinfo(cli1->tree, &sfi);
2812         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2813
2814         torture_wait_for_oplock_break(tctx);
2815         if (TARGET_IS_WINXP(tctx)) {
2816                 /* XP incorrectly breaks to level2. */
2817                 CHECK_VAL(break_info.count, 1);
2818                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
2819         } else {
2820                 CHECK_VAL(break_info.count, 0);
2821         }
2822
2823         ZERO_STRUCT(qfi);
2824         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
2825         qfi.generic.in.file.fnum = fnum;
2826
2827         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
2828         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2829         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname3);
2830
2831 done:
2832         smbcli_close(cli1->tree, fnum);
2833         smb_raw_exit(cli1->session);
2834         smb_raw_exit(cli2->session);
2835         smbcli_deltree(cli1->tree, BASEDIR);
2836         return ret;
2837 }
2838
2839 /****************************************************
2840  Called from raw-rename - we need oplock handling for
2841  this test so this is why it's in oplock.c, not rename.c
2842 ****************************************************/
2843
2844 bool test_trans2rename(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
2845 {
2846         const char *fname1 = BASEDIR "\\test_trans2rename_1.dat";
2847         const char *fname2 = BASEDIR "\\test_trans2rename_2.dat";
2848         const char *fname3 = BASEDIR "\\test_trans2rename_3.dat";
2849         NTSTATUS status;
2850         bool ret = true;
2851         union smb_open io;
2852         union smb_fileinfo qfi;
2853         union smb_setfileinfo sfi;
2854         uint16_t fnum=0;
2855
2856         if (!torture_setup_dir(cli1, BASEDIR)) {
2857                 return false;
2858         }
2859
2860         /* cleanup */
2861         smbcli_unlink(cli1->tree, fname1);
2862         smbcli_unlink(cli1->tree, fname2);
2863         smbcli_unlink(cli1->tree, fname3);
2864
2865         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2866
2867         /*
2868           base ntcreatex parms
2869         */
2870         io.generic.level = RAW_OPEN_NTCREATEX;
2871         io.ntcreatex.in.root_fid.fnum = 0;
2872         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2873         io.ntcreatex.in.alloc_size = 0;
2874         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2875         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
2876             NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
2877         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2878         io.ntcreatex.in.create_options = 0;
2879         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2880         io.ntcreatex.in.security_flags = 0;
2881         io.ntcreatex.in.fname = fname1;
2882
2883         torture_comment(tctx, "open a file with an exclusive oplock (share mode: none)\n");
2884         ZERO_STRUCT(break_info);
2885         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2886                 NTCREATEX_FLAGS_REQUEST_OPLOCK;
2887         status = smb_raw_open(cli1->tree, tctx, &io);
2888         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2889         fnum = io.ntcreatex.out.file.fnum;
2890         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
2891
2892         torture_comment(tctx, "setpathinfo rename info should not trigger a break nor a violation\n");
2893         ZERO_STRUCT(sfi);
2894         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
2895         sfi.generic.in.file.path = fname1;
2896         sfi.rename_information.in.overwrite     = 0;
2897         sfi.rename_information.in.root_fid      = 0;
2898         sfi.rename_information.in.new_name      = fname2+strlen(BASEDIR)+1;
2899
2900         status = smb_raw_setpathinfo(cli2->tree, &sfi);
2901
2902         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2903
2904         torture_wait_for_oplock_break(tctx);
2905         CHECK_VAL(break_info.count, 0);
2906
2907         ZERO_STRUCT(qfi);
2908         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
2909         qfi.generic.in.file.fnum = fnum;
2910
2911         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
2912         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2913         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname2);
2914
2915         torture_comment(tctx, "setfileinfo rename info should not trigger a break nor a violation\n");
2916         ZERO_STRUCT(sfi);
2917         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
2918         sfi.generic.in.file.fnum = fnum;
2919         sfi.rename_information.in.overwrite     = 0;
2920         sfi.rename_information.in.root_fid      = 0;
2921         sfi.rename_information.in.new_name      = fname3+strlen(BASEDIR)+1;
2922
2923         status = smb_raw_setfileinfo(cli1->tree, &sfi);
2924         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2925
2926         torture_wait_for_oplock_break(tctx);
2927         CHECK_VAL(break_info.count, 0);
2928
2929         ZERO_STRUCT(qfi);
2930         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
2931         qfi.generic.in.file.fnum = fnum;
2932
2933         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
2934         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2935         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname3);
2936
2937 done:
2938         smbcli_close(cli1->tree, fnum);
2939         smb_raw_exit(cli1->session);
2940         smb_raw_exit(cli2->session);
2941         smbcli_deltree(cli1->tree, BASEDIR);
2942         return ret;
2943 }
2944
2945 /****************************************************
2946  Called from raw-rename - we need oplock handling for
2947  this test so this is why it's in oplock.c, not rename.c
2948 ****************************************************/
2949
2950 bool test_nttransrename(struct torture_context *tctx, struct smbcli_state *cli1)
2951 {
2952         const char *fname1 = BASEDIR "\\test_nttransrename_1.dat";
2953         const char *fname2 = BASEDIR "\\test_nttransrename_2.dat";
2954         NTSTATUS status;
2955         bool ret = true;
2956         union smb_open io;
2957         union smb_fileinfo qfi, qpi;
2958         union smb_rename rn;
2959         uint16_t fnum=0;
2960
2961         if (!torture_setup_dir(cli1, BASEDIR)) {
2962                 return false;
2963         }
2964
2965         /* cleanup */
2966         smbcli_unlink(cli1->tree, fname1);
2967         smbcli_unlink(cli1->tree, fname2);
2968
2969         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
2970
2971         /*
2972           base ntcreatex parms
2973         */
2974         io.generic.level = RAW_OPEN_NTCREATEX;
2975         io.ntcreatex.in.root_fid.fnum = 0;
2976         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
2977         io.ntcreatex.in.alloc_size = 0;
2978         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
2979         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
2980         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
2981         io.ntcreatex.in.create_options = 0;
2982         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
2983         io.ntcreatex.in.security_flags = 0;
2984         io.ntcreatex.in.fname = fname1;
2985
2986         torture_comment(tctx, "nttrans_rename: open a file with an exclusive oplock (share mode: none)\n");
2987         ZERO_STRUCT(break_info);
2988         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
2989                 NTCREATEX_FLAGS_REQUEST_OPLOCK;
2990         status = smb_raw_open(cli1->tree, tctx, &io);
2991         CHECK_STATUS(tctx, status, NT_STATUS_OK);
2992         fnum = io.ntcreatex.out.file.fnum;
2993         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
2994
2995         torture_comment(tctx, "nttrans_rename: should not trigger a break nor a share mode violation\n");
2996         ZERO_STRUCT(rn);
2997         rn.generic.level = RAW_RENAME_NTTRANS;
2998         rn.nttrans.in.file.fnum = fnum;
2999         rn.nttrans.in.flags     = 0;
3000         rn.nttrans.in.new_name  = fname2+strlen(BASEDIR)+1;
3001
3002         status = smb_raw_rename(cli1->tree, &rn);
3003         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3004
3005         torture_wait_for_oplock_break(tctx);
3006         CHECK_VAL(break_info.count, 0);
3007
3008         /* w2k3 does nothing, it doesn't rename the file */
3009         torture_comment(tctx, "nttrans_rename: the server should have done nothing\n");
3010         ZERO_STRUCT(qfi);
3011         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
3012         qfi.generic.in.file.fnum = fnum;
3013
3014         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
3015         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3016         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname1);
3017
3018         ZERO_STRUCT(qpi);
3019         qpi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
3020         qpi.generic.in.file.path = fname1;
3021
3022         status = smb_raw_pathinfo(cli1->tree, tctx, &qpi);
3023         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3024         CHECK_STRMATCH(qpi.all_info.out.fname.s, fname1);
3025
3026         ZERO_STRUCT(qpi);
3027         qpi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
3028         qpi.generic.in.file.path = fname2;
3029
3030         status = smb_raw_pathinfo(cli1->tree, tctx, &qpi);
3031         CHECK_STATUS(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
3032
3033         torture_comment(tctx, "nttrans_rename: after closing the file the file is still not renamed\n");
3034         status = smbcli_close(cli1->tree, fnum);
3035         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3036
3037         ZERO_STRUCT(qpi);
3038         qpi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
3039         qpi.generic.in.file.path = fname1;
3040
3041         status = smb_raw_pathinfo(cli1->tree, tctx, &qpi);
3042         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3043         CHECK_STRMATCH(qpi.all_info.out.fname.s, fname1);
3044
3045         ZERO_STRUCT(qpi);
3046         qpi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
3047         qpi.generic.in.file.path = fname2;
3048
3049         status = smb_raw_pathinfo(cli1->tree, tctx, &qpi);
3050         CHECK_STATUS(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
3051
3052         torture_comment(tctx, "nttrans_rename: rename with an invalid handle gives NT_STATUS_INVALID_HANDLE\n");
3053         ZERO_STRUCT(rn);
3054         rn.generic.level = RAW_RENAME_NTTRANS;
3055         rn.nttrans.in.file.fnum = fnum+1;
3056         rn.nttrans.in.flags     = 0;
3057         rn.nttrans.in.new_name  = fname2+strlen(BASEDIR)+1;
3058
3059         status = smb_raw_rename(cli1->tree, &rn);
3060
3061         CHECK_STATUS(tctx, status, NT_STATUS_INVALID_HANDLE);
3062
3063 done:
3064         smb_raw_exit(cli1->session);
3065         smbcli_deltree(cli1->tree, BASEDIR);
3066         return ret;
3067 }
3068
3069
3070 static bool test_raw_oplock_batch20(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
3071 {
3072         const char *fname1 = BASEDIR "\\test_batch20_1.dat";
3073         const char *fname2 = BASEDIR "\\test_batch20_2.dat";
3074         const char *fname3 = BASEDIR "\\test_batch20_3.dat";
3075         NTSTATUS status;
3076         bool ret = true;
3077         union smb_open io;
3078         union smb_fileinfo qfi;
3079         union smb_setfileinfo sfi;
3080         uint16_t fnum=0,fnum2=0;
3081
3082         if (!torture_setup_dir(cli1, BASEDIR)) {
3083                 return false;
3084         }
3085
3086         /* cleanup */
3087         smbcli_unlink(cli1->tree, fname1);
3088         smbcli_unlink(cli1->tree, fname2);
3089         smbcli_unlink(cli1->tree, fname3);
3090
3091         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
3092
3093         /*
3094           base ntcreatex parms
3095         */
3096         io.generic.level = RAW_OPEN_NTCREATEX;
3097         io.ntcreatex.in.root_fid.fnum = 0;
3098         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
3099         io.ntcreatex.in.alloc_size = 0;
3100         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3101         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
3102         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
3103         io.ntcreatex.in.create_options = 0;
3104         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3105         io.ntcreatex.in.security_flags = 0;
3106         io.ntcreatex.in.fname = fname1;
3107
3108         torture_comment(tctx, "BATCH20: open a file with an batch oplock (share mode: all)\n");
3109         ZERO_STRUCT(break_info);
3110         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3111                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
3112                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3113         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
3114                 NTCREATEX_SHARE_ACCESS_WRITE|
3115                 NTCREATEX_SHARE_ACCESS_DELETE;
3116         status = smb_raw_open(cli1->tree, tctx, &io);
3117         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3118         fnum = io.ntcreatex.out.file.fnum;
3119         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3120
3121         ZERO_STRUCT(sfi);
3122         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
3123         sfi.generic.in.file.path = fname1;
3124         sfi.rename_information.in.overwrite     = 0;
3125         sfi.rename_information.in.root_fid      = 0;
3126         sfi.rename_information.in.new_name      = fname2+strlen(BASEDIR)+1;
3127
3128         status = smb_raw_setpathinfo(cli2->tree, &sfi);
3129         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3130
3131         torture_wait_for_oplock_break(tctx);
3132         CHECK_VAL(break_info.failures, 0);
3133
3134         if (TARGET_IS_WINXP(tctx) || TARGET_IS_W2K12(tctx)) {
3135                 /* Win XP breaks to level2. */
3136                 CHECK_VAL(break_info.count, 1);
3137                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
3138         } else if (TARGET_IS_W2K3(tctx) || TARGET_IS_W2K8(tctx) ||
3139             TARGET_IS_SAMBA3(tctx) || TARGET_IS_SAMBA4(tctx)) {
3140                 /* Win2K3/2k8 incorrectly doesn't break at all. */
3141                 CHECK_VAL(break_info.count, 0);
3142         } else {
3143                 /* win7/2k8r2 break to none. */
3144                 CHECK_VAL(break_info.count, 1);
3145                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
3146         }
3147
3148         ZERO_STRUCT(qfi);
3149         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
3150         qfi.generic.in.file.fnum = fnum;
3151
3152         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
3153         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3154         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname2);
3155
3156         torture_comment(tctx, "open a file with the new name an batch oplock (share mode: all)\n");
3157         ZERO_STRUCT(break_info);
3158         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3159                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
3160                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3161         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
3162                 NTCREATEX_SHARE_ACCESS_WRITE|
3163                 NTCREATEX_SHARE_ACCESS_DELETE;
3164         io.ntcreatex.in.fname = fname2;
3165         status = smb_raw_open(cli2->tree, tctx, &io);
3166         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3167         fnum2 = io.ntcreatex.out.file.fnum;
3168         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
3169
3170         torture_wait_for_oplock_break(tctx);
3171
3172         if (TARGET_IS_WINXP(tctx)) {
3173                 /* XP broke to level2, and doesn't break again. */
3174                 CHECK_VAL(break_info.count, 0);
3175         } else if (TARGET_IS_W2K3(tctx) || TARGET_IS_W2K8(tctx) ||
3176             TARGET_IS_SAMBA3(tctx) || TARGET_IS_SAMBA4(tctx)) {
3177                 /* Win2K3 incorrectly didn't break before so break now. */
3178                 CHECK_VAL(break_info.count, 1);
3179                 CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
3180         } else {
3181                 /* win7/2k8r2 broke to none, and doesn't break again. */
3182                 CHECK_VAL(break_info.count, 0);
3183         }
3184
3185         ZERO_STRUCT(break_info);
3186
3187         ZERO_STRUCT(sfi);
3188         sfi.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
3189         sfi.generic.in.file.fnum = fnum;
3190         sfi.rename_information.in.overwrite     = 0;
3191         sfi.rename_information.in.root_fid      = 0;
3192         sfi.rename_information.in.new_name      = fname3+strlen(BASEDIR)+1;
3193
3194         status = smb_raw_setfileinfo(cli1->tree, &sfi);
3195         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3196
3197         torture_wait_for_oplock_break(tctx);
3198         CHECK_VAL(break_info.count, 0);
3199
3200         ZERO_STRUCT(qfi);
3201         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
3202         qfi.generic.in.file.fnum = fnum;
3203
3204         status = smb_raw_fileinfo(cli1->tree, tctx, &qfi);
3205         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3206         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname3);
3207
3208         ZERO_STRUCT(qfi);
3209         qfi.generic.level = RAW_FILEINFO_ALL_INFORMATION;
3210         qfi.generic.in.file.fnum = fnum2;
3211
3212         status = smb_raw_fileinfo(cli2->tree, tctx, &qfi);
3213         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3214         CHECK_STRMATCH(qfi.all_info.out.fname.s, fname3);
3215
3216
3217 done:
3218         smbcli_close(cli1->tree, fnum);
3219         smbcli_close(cli2->tree, fnum2);
3220         smb_raw_exit(cli1->session);
3221         smb_raw_exit(cli2->session);
3222         smbcli_deltree(cli1->tree, BASEDIR);
3223         return ret;
3224 }
3225
3226 static bool test_raw_oplock_batch21(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
3227 {
3228         const char *fname = BASEDIR "\\test_batch21.dat";
3229         NTSTATUS status;
3230         bool ret = true;
3231         union smb_open io;
3232         struct smb_echo e;
3233         uint16_t fnum=0;
3234         char c = 0;
3235         ssize_t wr;
3236
3237         if (!torture_setup_dir(cli1, BASEDIR)) {
3238                 return false;
3239         }
3240
3241         /* cleanup */
3242         smbcli_unlink(cli1->tree, fname);
3243
3244         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
3245
3246         /*
3247           base ntcreatex parms
3248         */
3249         io.generic.level = RAW_OPEN_NTCREATEX;
3250         io.ntcreatex.in.root_fid.fnum = 0;
3251         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
3252         io.ntcreatex.in.alloc_size = 0;
3253         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3254         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
3255         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
3256         io.ntcreatex.in.create_options = 0;
3257         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3258         io.ntcreatex.in.security_flags = 0;
3259         io.ntcreatex.in.fname = fname;
3260
3261         /*
3262           with a batch oplock we get a break
3263         */
3264         torture_comment(tctx, "BATCH21: open with batch oplock\n");
3265         ZERO_STRUCT(break_info);
3266         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3267                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
3268                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3269         status = smb_raw_open(cli1->tree, tctx, &io);
3270         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3271         fnum = io.ntcreatex.out.file.fnum;
3272         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3273
3274         torture_comment(tctx, "writing should not generate a break\n");
3275         wr = smbcli_write(cli1->tree, fnum, 0, &c, 0, 1);
3276         CHECK_VAL(wr, 1);
3277         CHECK_STATUS(tctx, smbcli_nt_error(cli1->tree), NT_STATUS_OK);
3278
3279         ZERO_STRUCT(e);
3280         e.in.repeat_count = 1;
3281         status = smb_raw_echo(cli1->transport, &e);
3282         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3283
3284         torture_wait_for_oplock_break(tctx);
3285         CHECK_VAL(break_info.count, 0);
3286
3287         smbcli_close(cli1->tree, fnum);
3288
3289 done:
3290         smb_raw_exit(cli1->session);
3291         smb_raw_exit(cli2->session);
3292         smbcli_deltree(cli1->tree, BASEDIR);
3293         return ret;
3294 }
3295
3296 static bool test_raw_oplock_batch22(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
3297 {
3298         const char *fname = BASEDIR "\\test_batch22.dat";
3299         NTSTATUS status;
3300         bool ret = true;
3301         union smb_open io;
3302         uint16_t fnum = 0, fnum2 = 0, fnum3 = 0;
3303         struct timeval tv;
3304         int timeout = torture_setting_int(tctx, "oplocktimeout", 30);
3305         int te;
3306
3307         if (!torture_setup_dir(cli1, BASEDIR)) {
3308                 return false;
3309         }
3310
3311         /* cleanup */
3312         smbcli_unlink(cli1->tree, fname);
3313
3314         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
3315         /*
3316           base ntcreatex parms
3317         */
3318         io.generic.level = RAW_OPEN_NTCREATEX;
3319         io.ntcreatex.in.root_fid.fnum = 0;
3320         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
3321         io.ntcreatex.in.alloc_size = 0;
3322         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3323         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
3324         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
3325         io.ntcreatex.in.create_options = 0;
3326         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3327         io.ntcreatex.in.security_flags = 0;
3328         io.ntcreatex.in.fname = fname;
3329
3330         /*
3331           with a batch oplock we get a break
3332         */
3333         torture_comment(tctx, "BATCH22: open with batch oplock\n");
3334         ZERO_STRUCT(break_info);
3335         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3336                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
3337                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3338         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
3339                 NTCREATEX_SHARE_ACCESS_WRITE|
3340                 NTCREATEX_SHARE_ACCESS_DELETE;
3341         status = smb_raw_open(cli1->tree, tctx, &io);
3342         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3343         fnum = io.ntcreatex.out.file.fnum;
3344         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3345
3346         torture_comment(tctx, "a 2nd open should not succeed after the oplock "
3347                         "break timeout\n");
3348         tv = timeval_current();
3349         smbcli_oplock_handler(cli1->transport, oplock_handler_timeout, cli1->tree);
3350         status = smb_raw_open(cli1->tree, tctx, &io);
3351
3352         if (TARGET_IS_W2K3(tctx)) {
3353                 /* 2k3 has an issue here. xp/win7 are ok. */
3354                 CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
3355         } else {
3356                 CHECK_STATUS(tctx, status, NT_STATUS_OK);
3357         }
3358
3359         fnum2 = io.ntcreatex.out.file.fnum;
3360
3361         torture_wait_for_oplock_break(tctx);
3362         te = (int)timeval_elapsed(&tv);
3363
3364         /*
3365          * Some servers detect clients that let oplocks timeout, so this check
3366          * only shows a warning message instead failing the test to eliminate
3367          * failures from repeated runs of the test.  This isn't ideal, but
3368          * it's better than not running the test at all.
3369          */
3370         CHECK_RANGE(te, timeout - 1, timeout + 15);
3371
3372         CHECK_VAL(break_info.count, 1);
3373         CHECK_VAL(break_info.fnum, fnum);
3374         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
3375         CHECK_VAL(break_info.failures, 0);
3376         ZERO_STRUCT(break_info);
3377
3378         torture_comment(tctx, "a 2nd open should succeed after the oplock "
3379                         "release without break\n");
3380         tv = timeval_current();
3381         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
3382         status = smb_raw_open(cli1->tree, tctx, &io);
3383         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3384 #if 0
3385         /* Samba 3.6.0 and above behave as Windows. */
3386         if (TARGET_IS_SAMBA3(tctx)) {
3387                 /* samba3 doesn't grant additional oplocks to bad clients. */
3388                 CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
3389         } else {
3390                 CHECK_VAL(io.ntcreatex.out.oplock_level,
3391                         LEVEL_II_OPLOCK_RETURN);
3392         }
3393 #else
3394         CHECK_VAL(io.ntcreatex.out.oplock_level,
3395                   LEVEL_II_OPLOCK_RETURN);
3396 #endif
3397         torture_wait_for_oplock_break(tctx);
3398         te = (int)timeval_elapsed(&tv);
3399         /* it should come in without delay */
3400         CHECK_RANGE(te+1, 0, timeout);
3401         fnum3 = io.ntcreatex.out.file.fnum;
3402
3403         CHECK_VAL(break_info.count, 0);
3404
3405         smbcli_close(cli1->tree, fnum);
3406         smbcli_close(cli1->tree, fnum2);
3407         smbcli_close(cli1->tree, fnum3);
3408
3409 done:
3410         smb_raw_exit(cli1->session);
3411         smb_raw_exit(cli2->session);
3412         smbcli_deltree(cli1->tree, BASEDIR);
3413         return ret;
3414 }
3415
3416 static bool test_raw_oplock_batch23(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
3417 {
3418         const char *fname = BASEDIR "\\test_batch23.dat";
3419         NTSTATUS status;
3420         bool ret = true;
3421         union smb_open io;
3422         uint16_t fnum=0, fnum2=0,fnum3=0;
3423         struct smbcli_state *cli3 = NULL;
3424
3425         if (!torture_setup_dir(cli1, BASEDIR)) {
3426                 return false;
3427         }
3428
3429         /* cleanup */
3430         smbcli_unlink(cli1->tree, fname);
3431
3432         ret = open_connection_no_level2_oplocks(tctx, &cli3);
3433         CHECK_VAL(ret, true);
3434
3435         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
3436         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
3437         smbcli_oplock_handler(cli3->transport, oplock_handler_ack_to_given, cli3->tree);
3438
3439         /*
3440           base ntcreatex parms
3441         */
3442         io.generic.level = RAW_OPEN_NTCREATEX;
3443         io.ntcreatex.in.root_fid.fnum = 0;
3444         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
3445         io.ntcreatex.in.alloc_size = 0;
3446         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3447         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
3448         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
3449         io.ntcreatex.in.create_options = 0;
3450         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3451         io.ntcreatex.in.security_flags = 0;
3452         io.ntcreatex.in.fname = fname;
3453
3454         torture_comment(tctx, "BATCH23: a open and ask for a batch oplock\n");
3455         ZERO_STRUCT(break_info);
3456
3457         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_WRITE;
3458         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
3459         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3460                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
3461                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3462         status = smb_raw_open(cli1->tree, tctx, &io);
3463         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3464         fnum = io.ntcreatex.out.file.fnum;
3465         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3466
3467         ZERO_STRUCT(break_info);
3468
3469         torture_comment(tctx, "a 2nd open without level2 oplock support should generate a break to level2\n");
3470         status = smb_raw_open(cli3->tree, tctx, &io);
3471         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3472         fnum3 = io.ntcreatex.out.file.fnum;
3473         CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
3474
3475         torture_wait_for_oplock_break(tctx);
3476         CHECK_VAL(break_info.count, 1);
3477         CHECK_VAL(break_info.fnum, fnum);
3478         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
3479         CHECK_VAL(break_info.failures, 0);
3480
3481         ZERO_STRUCT(break_info);
3482
3483         torture_comment(tctx, "a 3rd open with level2 oplock support should not generate a break\n");
3484         status = smb_raw_open(cli2->tree, tctx, &io);
3485         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3486         fnum2 = io.ntcreatex.out.file.fnum;
3487         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
3488
3489         torture_wait_for_oplock_break(tctx);
3490         CHECK_VAL(break_info.count, 0);
3491
3492         smbcli_close(cli1->tree, fnum);
3493         smbcli_close(cli2->tree, fnum2);
3494         smbcli_close(cli3->tree, fnum3);
3495
3496 done:
3497         smb_raw_exit(cli1->session);
3498         smb_raw_exit(cli2->session);
3499         smb_raw_exit(cli3->session);
3500         smbcli_deltree(cli1->tree, BASEDIR);
3501         return ret;
3502 }
3503
3504 static bool test_raw_oplock_batch24(struct torture_context *tctx, struct smbcli_state *cli1, struct smbcli_state *cli2)
3505 {
3506         const char *fname = BASEDIR "\\test_batch24.dat";
3507         NTSTATUS status;
3508         bool ret = true;
3509         union smb_open io;
3510         uint16_t fnum2=0,fnum3=0;
3511         struct smbcli_state *cli3 = NULL;
3512
3513         if (!torture_setup_dir(cli1, BASEDIR)) {
3514                 return false;
3515         }
3516
3517         /* cleanup */
3518         smbcli_unlink(cli1->tree, fname);
3519
3520         ret = open_connection_no_level2_oplocks(tctx, &cli3);
3521         CHECK_VAL(ret, true);
3522
3523         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
3524         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
3525         smbcli_oplock_handler(cli3->transport, oplock_handler_ack_to_given, cli3->tree);
3526
3527         /*
3528           base ntcreatex parms
3529         */
3530         io.generic.level = RAW_OPEN_NTCREATEX;
3531         io.ntcreatex.in.root_fid.fnum = 0;
3532         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
3533         io.ntcreatex.in.alloc_size = 0;
3534         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3535         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
3536         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
3537         io.ntcreatex.in.create_options = 0;
3538         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3539         io.ntcreatex.in.security_flags = 0;
3540         io.ntcreatex.in.fname = fname;
3541
3542         torture_comment(tctx, "BATCH24: a open without level support and ask for a batch oplock\n");
3543         ZERO_STRUCT(break_info);
3544
3545         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ | SEC_RIGHTS_FILE_WRITE;
3546         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ | NTCREATEX_SHARE_ACCESS_WRITE;
3547         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3548                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
3549                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3550         status = smb_raw_open(cli3->tree, tctx, &io);
3551         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3552         fnum3 = io.ntcreatex.out.file.fnum;
3553         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3554
3555         ZERO_STRUCT(break_info);
3556
3557         torture_comment(tctx, "a 2nd open with level2 oplock support should generate a break to none\n");
3558         status = smb_raw_open(cli2->tree, tctx, &io);
3559         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3560         fnum2 = io.ntcreatex.out.file.fnum;
3561         CHECK_VAL(io.ntcreatex.out.oplock_level, LEVEL_II_OPLOCK_RETURN);
3562
3563         torture_wait_for_oplock_break(tctx);
3564         CHECK_VAL(break_info.count, 1);
3565         CHECK_VAL(break_info.fnum, fnum3);
3566         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
3567         CHECK_VAL(break_info.failures, 0);
3568
3569         smbcli_close(cli3->tree, fnum3);
3570         smbcli_close(cli2->tree, fnum2);
3571
3572 done:
3573         smb_raw_exit(cli1->session);
3574         smb_raw_exit(cli2->session);
3575         smb_raw_exit(cli3->session);
3576         smbcli_deltree(cli1->tree, BASEDIR);
3577         return ret;
3578 }
3579
3580 static bool test_raw_oplock_batch25(struct torture_context *tctx,
3581                                     struct smbcli_state *cli1,
3582                                     struct smbcli_state *cli2)
3583 {
3584         const char *fname = BASEDIR "\\test_batch25.dat";
3585         NTSTATUS status;
3586         bool ret = true;
3587         union smb_open io;
3588         union smb_setfileinfo sfi;
3589         uint16_t fnum=0;
3590
3591         if (!torture_setup_dir(cli1, BASEDIR)) {
3592                 return false;
3593         }
3594
3595         /* cleanup */
3596         smbcli_unlink(cli1->tree, fname);
3597
3598         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
3599
3600         /*
3601           base ntcreatex parms
3602         */
3603         io.generic.level = RAW_OPEN_NTCREATEX;
3604         io.ntcreatex.in.root_fid.fnum = 0;
3605         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
3606         io.ntcreatex.in.alloc_size = 0;
3607         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3608         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
3609         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
3610         io.ntcreatex.in.create_options = 0;
3611         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3612         io.ntcreatex.in.security_flags = 0;
3613         io.ntcreatex.in.fname = fname;
3614
3615         torture_comment(tctx, "BATCH25: open a file with an batch oplock "
3616                         "(share mode: none)\n");
3617
3618         ZERO_STRUCT(break_info);
3619         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3620                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
3621                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3622         status = smb_raw_open(cli1->tree, tctx, &io);
3623         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3624         fnum = io.ntcreatex.out.file.fnum;
3625         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3626
3627         torture_comment(tctx, "setpathinfo attribute info should not trigger "
3628                         "a break nor a violation\n");
3629         ZERO_STRUCT(sfi);
3630         sfi.generic.level = RAW_SFILEINFO_SETATTR;
3631         sfi.generic.in.file.path        = fname;
3632         sfi.setattr.in.attrib           = FILE_ATTRIBUTE_HIDDEN;
3633         sfi.setattr.in.write_time       = 0;
3634
3635         status = smb_raw_setpathinfo(cli2->tree, &sfi);
3636         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3637
3638         torture_wait_for_oplock_break(tctx);
3639         CHECK_VAL(break_info.count, 0);
3640
3641         smbcli_close(cli1->tree, fnum);
3642
3643 done:
3644         smb_raw_exit(cli1->session);
3645         smb_raw_exit(cli2->session);
3646         smbcli_deltree(cli1->tree, BASEDIR);
3647         return ret;
3648 }
3649
3650 /**
3651  * Similar to batch17/18, but test with open share mode rather than
3652  * share_none.
3653  */
3654 static bool test_raw_oplock_batch26(struct torture_context *tctx,
3655     struct smbcli_state *cli1, struct smbcli_state *cli2)
3656 {
3657         const char *fname1 = BASEDIR "\\test_batch26_1.dat";
3658         const char *fname2 = BASEDIR "\\test_batch26_2.dat";
3659         NTSTATUS status;
3660         bool ret = true;
3661         union smb_open io;
3662         union smb_rename rn;
3663         uint16_t fnum=0;
3664
3665         if (!torture_setup_dir(cli1, BASEDIR)) {
3666                 return false;
3667         }
3668
3669         /* cleanup */
3670         smbcli_unlink(cli1->tree, fname1);
3671         smbcli_unlink(cli1->tree, fname2);
3672
3673         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
3674             cli1->tree);
3675
3676         /*
3677           base ntcreatex parms
3678         */
3679         io.generic.level = RAW_OPEN_NTCREATEX;
3680         io.ntcreatex.in.root_fid.fnum = 0;
3681         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
3682         io.ntcreatex.in.alloc_size = 0;
3683         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3684         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
3685             NTCREATEX_SHARE_ACCESS_WRITE | NTCREATEX_SHARE_ACCESS_DELETE;
3686         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
3687         io.ntcreatex.in.create_options = 0;
3688         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3689         io.ntcreatex.in.security_flags = 0;
3690         io.ntcreatex.in.fname = fname1;
3691
3692         torture_comment(tctx,
3693                         "BATCH26: open a file with an batch oplock "
3694                         "(share mode: all)\n");
3695
3696         ZERO_STRUCT(break_info);
3697         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3698                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
3699                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3700
3701
3702         status = smb_raw_open(cli1->tree, tctx, &io);
3703         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3704         fnum = io.ntcreatex.out.file.fnum;
3705         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3706
3707         torture_comment(tctx, "rename should trigger a break\n");
3708         ZERO_STRUCT(rn);
3709         rn.generic.level = RAW_RENAME_RENAME;
3710         rn.rename.in.pattern1 = fname1;
3711         rn.rename.in.pattern2 = fname2;
3712         rn.rename.in.attrib = 0;
3713
3714         torture_comment(tctx, "trying rename while first file open\n");
3715         status = smb_raw_rename(cli2->tree, &rn);
3716         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
3717
3718         torture_wait_for_oplock_break(tctx);
3719         CHECK_VAL(break_info.count, 1);
3720         CHECK_VAL(break_info.failures, 0);
3721         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
3722
3723         /* Close and reopen with batch again. */
3724         smbcli_close(cli1->tree, fnum);
3725         ZERO_STRUCT(break_info);
3726
3727         status = smb_raw_open(cli1->tree, tctx, &io);
3728         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3729         fnum = io.ntcreatex.out.file.fnum;
3730         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3731
3732         /* Now try ntrename. */
3733         torture_comment(tctx, "ntrename should trigger a break\n");
3734         ZERO_STRUCT(rn);
3735         rn.generic.level = RAW_RENAME_NTRENAME;
3736         rn.ntrename.in.attrib   = 0;
3737         rn.ntrename.in.flags    = RENAME_FLAG_RENAME;
3738         rn.ntrename.in.old_name = fname1;
3739         rn.ntrename.in.new_name = fname2;
3740         torture_comment(tctx, "trying rename while first file open\n");
3741         status = smb_raw_rename(cli2->tree, &rn);
3742         CHECK_STATUS(tctx, status, NT_STATUS_SHARING_VIOLATION);
3743
3744         torture_wait_for_oplock_break(tctx);
3745         CHECK_VAL(break_info.count, 1);
3746         CHECK_VAL(break_info.failures, 0);
3747         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
3748
3749         smbcli_close(cli1->tree, fnum);
3750
3751 done:
3752         smb_raw_exit(cli1->session);
3753         smb_raw_exit(cli2->session);
3754         smbcli_deltree(cli1->tree, BASEDIR);
3755         return ret;
3756 }
3757
3758 /* Test how oplocks work on streams. */
3759 static bool test_raw_oplock_stream1(struct torture_context *tctx,
3760                                     struct smbcli_state *cli1,
3761                                     struct smbcli_state *cli2)
3762 {
3763         NTSTATUS status;
3764         union smb_open io;
3765         const char *fname_base = BASEDIR "\\test_stream1.txt";
3766         const char *stream = "Stream One:$DATA";
3767         const char *fname_stream, *fname_default_stream;
3768         const char *default_stream = "::$DATA";
3769         bool ret = true;
3770         int fnum = -1;
3771         int i;
3772         int stream_fnum = -1;
3773         uint32_t batch_req = NTCREATEX_FLAGS_REQUEST_OPLOCK |
3774             NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK | NTCREATEX_FLAGS_EXTENDED;
3775         uint32_t exclusive_req = NTCREATEX_FLAGS_REQUEST_OPLOCK |
3776             NTCREATEX_FLAGS_EXTENDED;
3777
3778 #define NSTREAM_OPLOCK_RESULTS 8
3779         struct {
3780                 const char **fname;
3781                 bool open_base_file;
3782                 uint32_t oplock_req;
3783                 uint32_t oplock_granted;
3784         } stream_oplock_results[NSTREAM_OPLOCK_RESULTS] = {
3785                 /* Request oplock on stream without the base file open. */
3786                 {&fname_stream, false, batch_req, NO_OPLOCK_RETURN},
3787                 {&fname_default_stream, false, batch_req, NO_OPLOCK_RETURN},
3788                 {&fname_stream, false, exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
3789                 {&fname_default_stream, false,  exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
3790
3791                 /* Request oplock on stream with the base file open. */
3792                 {&fname_stream, true, batch_req, NO_OPLOCK_RETURN},
3793                 {&fname_default_stream, true, batch_req, NO_OPLOCK_RETURN},
3794                 {&fname_stream, true, exclusive_req, EXCLUSIVE_OPLOCK_RETURN},
3795                 {&fname_default_stream, true,  exclusive_req, LEVEL_II_OPLOCK_RETURN},
3796
3797         };
3798
3799
3800         /* Only passes against windows at the moment. */
3801         if (torture_setting_bool(tctx, "samba3", false) ||
3802             torture_setting_bool(tctx, "samba4", false)) {
3803                 torture_skip(tctx, "STREAM1 disabled against samba3+4\n");
3804         }
3805
3806         fname_stream = talloc_asprintf(tctx, "%s:%s", fname_base, stream);
3807         fname_default_stream = talloc_asprintf(tctx, "%s%s", fname_base,
3808                                                default_stream);
3809
3810         if (!torture_setup_dir(cli1, BASEDIR)) {
3811                 return false;
3812         }
3813         smbcli_unlink(cli1->tree, fname_base);
3814
3815         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given, cli1->tree);
3816         smbcli_oplock_handler(cli2->transport, oplock_handler_ack_to_given, cli2->tree);
3817
3818         /* Setup generic open parameters. */
3819         io.generic.level = RAW_OPEN_NTCREATEX;
3820         io.ntcreatex.in.root_fid.fnum = 0;
3821         io.ntcreatex.in.access_mask = (SEC_FILE_READ_DATA|SEC_FILE_WRITE_DATA|
3822             SEC_FILE_APPEND_DATA|SEC_STD_READ_CONTROL);
3823         io.ntcreatex.in.create_options = 0;
3824         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3825         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
3826             NTCREATEX_SHARE_ACCESS_WRITE;
3827         io.ntcreatex.in.alloc_size = 0;
3828         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3829         io.ntcreatex.in.security_flags = 0;
3830
3831         /* Create the file with a stream */
3832         io.ntcreatex.in.fname = fname_stream;
3833         io.ntcreatex.in.flags = 0;
3834         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_CREATE;
3835         status = smb_raw_open(cli1->tree, tctx, &io);
3836         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3837         smbcli_close(cli1->tree, io.ntcreatex.out.file.fnum);
3838
3839         /* Change the disposition to open now that the file has been created. */
3840         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
3841
3842         /* Try some permutations of taking oplocks on streams. */
3843         for (i = 0; i < NSTREAM_OPLOCK_RESULTS; i++) {
3844                 const char *fname = *stream_oplock_results[i].fname;
3845                 bool open_base_file = stream_oplock_results[i].open_base_file;
3846                 uint32_t oplock_req = stream_oplock_results[i].oplock_req;
3847                 uint32_t oplock_granted =
3848                     stream_oplock_results[i].oplock_granted;
3849                 int base_fnum = -1;
3850
3851                 if (open_base_file) {
3852                         torture_comment(tctx, "Opening base file: %s with "
3853                             "%d\n", fname_base, batch_req);
3854                         io.ntcreatex.in.fname = fname_base;
3855                         io.ntcreatex.in.flags = batch_req;
3856                         status = smb_raw_open(cli2->tree, tctx, &io);
3857                         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3858                         CHECK_VAL(io.ntcreatex.out.oplock_level,
3859                             BATCH_OPLOCK_RETURN);
3860                         base_fnum = io.ntcreatex.out.file.fnum;
3861                 }
3862
3863                 torture_comment(tctx, "%d: Opening stream: %s with %d\n", i,
3864                     fname, oplock_req);
3865                 io.ntcreatex.in.fname = fname;
3866                 io.ntcreatex.in.flags = oplock_req;
3867
3868                 /* Do the open with the desired oplock on the stream. */
3869                 status = smb_raw_open(cli1->tree, tctx, &io);
3870                 CHECK_STATUS(tctx, status, NT_STATUS_OK);
3871                 CHECK_VAL(io.ntcreatex.out.oplock_level, oplock_granted);
3872                 smbcli_close(cli1->tree, io.ntcreatex.out.file.fnum);
3873
3874                 /* Cleanup the base file if it was opened. */
3875                 if (base_fnum != -1) {
3876                         smbcli_close(cli2->tree, base_fnum);
3877                 }
3878         }
3879
3880         /* Open the stream with an exclusive oplock. */
3881         torture_comment(tctx, "Opening stream: %s with %d\n",
3882             fname_stream, exclusive_req);
3883         io.ntcreatex.in.fname = fname_stream;
3884         io.ntcreatex.in.flags = exclusive_req;
3885         status = smb_raw_open(cli1->tree, tctx, &io);
3886         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3887         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
3888         stream_fnum = io.ntcreatex.out.file.fnum;
3889
3890         /* Open the base file and see if it contends. */
3891         ZERO_STRUCT(break_info);
3892         torture_comment(tctx, "Opening base file: %s with "
3893             "%d\n", fname_base, batch_req);
3894         io.ntcreatex.in.fname = fname_base;
3895         io.ntcreatex.in.flags = batch_req;
3896         status = smb_raw_open(cli2->tree, tctx, &io);
3897         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3898         CHECK_VAL(io.ntcreatex.out.oplock_level,
3899             BATCH_OPLOCK_RETURN);
3900         smbcli_close(cli2->tree, io.ntcreatex.out.file.fnum);
3901
3902         torture_wait_for_oplock_break(tctx);
3903         CHECK_VAL(break_info.count, 0);
3904         CHECK_VAL(break_info.failures, 0);
3905
3906         /* Open the stream again to see if it contends. */
3907         ZERO_STRUCT(break_info);
3908         torture_comment(tctx, "Opening stream again: %s with "
3909             "%d\n", fname_base, batch_req);
3910         io.ntcreatex.in.fname = fname_stream;
3911         io.ntcreatex.in.flags = exclusive_req;
3912         status = smb_raw_open(cli2->tree, tctx, &io);
3913         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3914         CHECK_VAL(io.ntcreatex.out.oplock_level,
3915             LEVEL_II_OPLOCK_RETURN);
3916         smbcli_close(cli2->tree, io.ntcreatex.out.file.fnum);
3917
3918         torture_wait_for_oplock_break(tctx);
3919         CHECK_VAL(break_info.count, 1);
3920         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
3921         CHECK_VAL(break_info.failures, 0);
3922
3923         /* Close the stream. */
3924         if (stream_fnum != -1) {
3925                 smbcli_close(cli1->tree, stream_fnum);
3926         }
3927
3928  done:
3929         smbcli_close(cli1->tree, fnum);
3930         smb_raw_exit(cli1->session);
3931         smb_raw_exit(cli2->session);
3932         smbcli_deltree(cli1->tree, BASEDIR);
3933         return ret;
3934 }
3935
3936 static bool test_raw_oplock_doc(struct torture_context *tctx,
3937                                 struct smbcli_state *cli,
3938                                 struct smbcli_state *cli2)
3939 {
3940         const char *fname = BASEDIR "\\test_oplock_doc.dat";
3941         NTSTATUS status;
3942         bool ret = true;
3943         union smb_open io;
3944         uint16_t fnum=0;
3945
3946         torture_assert(tctx, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
3947
3948         /* cleanup */
3949         smbcli_unlink(cli->tree, fname);
3950
3951         smbcli_oplock_handler(cli->transport, oplock_handler_ack_to_given,
3952                               cli->tree);
3953
3954         /*
3955           base ntcreatex parms
3956         */
3957         io.generic.level = RAW_OPEN_NTCREATEX;
3958         io.ntcreatex.in.root_fid.fnum = 0;
3959         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
3960         io.ntcreatex.in.alloc_size = 0;
3961         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
3962         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ|
3963                 NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE;
3964         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
3965         io.ntcreatex.in.create_options = 0;
3966         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
3967         io.ntcreatex.in.security_flags = 0;
3968         io.ntcreatex.in.fname = fname;
3969
3970         torture_comment(tctx, "open a file with a batch oplock\n");
3971         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
3972             NTCREATEX_FLAGS_REQUEST_OPLOCK |
3973             NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
3974
3975         status = smb_raw_open(cli->tree, tctx, &io);
3976         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3977         fnum = io.ntcreatex.out.file.fnum;
3978         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
3979
3980         torture_comment(tctx, "Set delete-on-close\n");
3981         status = smbcli_nt_delete_on_close(cli->tree, fnum, true);
3982         CHECK_STATUS(tctx, status, NT_STATUS_OK);
3983
3984         torture_comment(tctx, "2nd open should not break and get "
3985                         "DELETE_PENDING\n");
3986         ZERO_STRUCT(break_info);
3987         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN;
3988         io.ntcreatex.in.create_options = 0;
3989         io.ntcreatex.in.access_mask = SEC_FILE_READ_DATA;
3990         status = smb_raw_open(cli2->tree, tctx, &io);
3991         CHECK_STATUS(tctx, status, NT_STATUS_DELETE_PENDING);
3992         CHECK_VAL(break_info.count, 0);
3993
3994         smbcli_close(cli->tree, fnum);
3995
3996 done:
3997         smb_raw_exit(cli->session);
3998         smbcli_deltree(cli->tree, BASEDIR);
3999         return ret;
4000 }
4001
4002 /* Open a file with a batch oplock, then open it again from a second client
4003  * requesting no oplock. Having two open file handles should break our own
4004  * oplock during BRL acquisition.
4005  */
4006 static bool test_raw_oplock_brl1(struct torture_context *tctx,
4007                                  struct smbcli_state *cli1,
4008                                  struct smbcli_state *cli2)
4009 {
4010         const char *fname = BASEDIR "\\test_batch_brl.dat";
4011         /*int fname, f;*/
4012         bool ret = true;
4013         uint8_t buf[1000];
4014         union smb_open io;
4015         NTSTATUS status;
4016         uint16_t fnum=0;
4017         uint16_t fnum2=0;
4018
4019         if (!torture_setup_dir(cli1, BASEDIR)) {
4020                 return false;
4021         }
4022
4023         /* cleanup */
4024         smbcli_unlink(cli1->tree, fname);
4025
4026         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
4027                               cli1->tree);
4028
4029         /*
4030           base ntcreatex parms
4031         */
4032         io.generic.level = RAW_OPEN_NTCREATEX;
4033         io.ntcreatex.in.root_fid.fnum = 0;
4034         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ |
4035                                       SEC_RIGHTS_FILE_WRITE;
4036         io.ntcreatex.in.alloc_size = 0;
4037         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
4038         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
4039                                        NTCREATEX_SHARE_ACCESS_WRITE;
4040         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
4041         io.ntcreatex.in.create_options = 0;
4042         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
4043         io.ntcreatex.in.security_flags = 0;
4044         io.ntcreatex.in.fname = fname;
4045
4046         /*
4047           with a batch oplock we get a break
4048         */
4049         torture_comment(tctx, "open with batch oplock\n");
4050         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
4051                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
4052                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
4053
4054         status = smb_raw_open(cli1->tree, tctx, &io);
4055         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4056         fnum = io.ntcreatex.out.file.fnum;
4057         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
4058         /* create a file with bogus data */
4059         memset(buf, 0, sizeof(buf));
4060
4061         if (smbcli_write(cli1->tree, fnum, 0, buf, 0, sizeof(buf)) !=
4062                          sizeof(buf))
4063         {
4064                 torture_comment(tctx, "Failed to create file\n");
4065                 goto done;
4066         }
4067
4068         torture_comment(tctx, "a 2nd open should give a break\n");
4069         ZERO_STRUCT(break_info);
4070
4071         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
4072         status = smb_raw_open(cli2->tree, tctx, &io);
4073         fnum2 = io.ntcreatex.out.file.fnum;
4074         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4075         CHECK_VAL(break_info.count, 1);
4076         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
4077         CHECK_VAL(break_info.failures, 0);
4078         CHECK_VAL(break_info.fnum, fnum);
4079
4080         ZERO_STRUCT(break_info);
4081
4082         torture_comment(tctx, "a self BRL acquisition should break to none\n");
4083
4084         status = smbcli_lock(cli1->tree, fnum, 0, 4, 0, WRITE_LOCK);
4085         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4086
4087         torture_wait_for_oplock_break(tctx);
4088         CHECK_VAL(break_info.count, 1);
4089         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
4090         CHECK_VAL(break_info.fnum, fnum);
4091         CHECK_VAL(break_info.failures, 0);
4092
4093         /* expect no oplock break */
4094         ZERO_STRUCT(break_info);
4095         status = smbcli_lock(cli1->tree, fnum, 2, 4, 0, WRITE_LOCK);
4096         CHECK_STATUS(tctx, status, NT_STATUS_LOCK_NOT_GRANTED);
4097
4098         torture_wait_for_oplock_break(tctx);
4099         CHECK_VAL(break_info.count, 0);
4100         CHECK_VAL(break_info.level, 0);
4101         CHECK_VAL(break_info.fnum, 0);
4102         CHECK_VAL(break_info.failures, 0);
4103
4104         smbcli_close(cli1->tree, fnum);
4105         smbcli_close(cli2->tree, fnum2);
4106
4107 done:
4108         smb_raw_exit(cli1->session);
4109         smb_raw_exit(cli2->session);
4110         smbcli_deltree(cli1->tree, BASEDIR);
4111         return ret;
4112
4113 }
4114
4115 /* Open a file with a batch oplock on one client and then acquire a brl.
4116  * We should not contend our own oplock.
4117  */
4118 static bool test_raw_oplock_brl2(struct torture_context *tctx, struct smbcli_state *cli1)
4119 {
4120         const char *fname = BASEDIR "\\test_batch_brl.dat";
4121         /*int fname, f;*/
4122         bool ret = true;
4123         uint8_t buf[1000];
4124         union smb_open io;
4125         NTSTATUS status;
4126         uint16_t fnum=0;
4127
4128         if (!torture_setup_dir(cli1, BASEDIR)) {
4129                 return false;
4130         }
4131
4132         /* cleanup */
4133         smbcli_unlink(cli1->tree, fname);
4134
4135         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
4136                               cli1->tree);
4137
4138         /*
4139           base ntcreatex parms
4140         */
4141         io.generic.level = RAW_OPEN_NTCREATEX;
4142         io.ntcreatex.in.root_fid.fnum = 0;
4143         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ |
4144                                       SEC_RIGHTS_FILE_WRITE;
4145         io.ntcreatex.in.alloc_size = 0;
4146         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
4147         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
4148                                        NTCREATEX_SHARE_ACCESS_WRITE;
4149         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
4150         io.ntcreatex.in.create_options = 0;
4151         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
4152         io.ntcreatex.in.security_flags = 0;
4153         io.ntcreatex.in.fname = fname;
4154
4155         /*
4156           with a batch oplock we get a break
4157         */
4158         torture_comment(tctx, "open with batch oplock\n");
4159         ZERO_STRUCT(break_info);
4160         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
4161                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
4162                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
4163
4164         status = smb_raw_open(cli1->tree, tctx, &io);
4165         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4166         fnum = io.ntcreatex.out.file.fnum;
4167         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
4168
4169         /* create a file with bogus data */
4170         memset(buf, 0, sizeof(buf));
4171
4172         if (smbcli_write(cli1->tree, fnum, 0, buf, 0, sizeof(buf)) !=
4173                          sizeof(buf))
4174         {
4175                 torture_comment(tctx, "Failed to create file\n");
4176                 goto done;
4177         }
4178
4179         torture_comment(tctx, "a self BRL acquisition should not break to "
4180                         "none\n");
4181
4182         status = smbcli_lock(cli1->tree, fnum, 0, 4, 0, WRITE_LOCK);
4183         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4184
4185         status = smbcli_lock(cli1->tree, fnum, 2, 4, 0, WRITE_LOCK);
4186         CHECK_STATUS(tctx, status, NT_STATUS_LOCK_NOT_GRANTED);
4187
4188         /* With one file handle open a BRL should not contend our oplock.
4189          * Thus, no oplock break will be received and the entire break_info
4190          * struct will be 0 */
4191         torture_wait_for_oplock_break(tctx);
4192         CHECK_VAL(break_info.fnum, 0);
4193         CHECK_VAL(break_info.count, 0);
4194         CHECK_VAL(break_info.level, 0);
4195         CHECK_VAL(break_info.failures, 0);
4196
4197         smbcli_close(cli1->tree, fnum);
4198
4199 done:
4200         smb_raw_exit(cli1->session);
4201         smbcli_deltree(cli1->tree, BASEDIR);
4202         return ret;
4203 }
4204
4205 /* Open a file with a batch oplock twice from one client and then acquire a
4206  * brl. BRL acquisition should break our own oplock.
4207  */
4208 static bool test_raw_oplock_brl3(struct torture_context *tctx,
4209                                  struct smbcli_state *cli1)
4210 {
4211         const char *fname = BASEDIR "\\test_batch_brl.dat";
4212         bool ret = true;
4213         uint8_t buf[1000];
4214         union smb_open io;
4215         NTSTATUS status;
4216         uint16_t fnum=0;
4217         uint16_t fnum2=0;
4218
4219         if (!torture_setup_dir(cli1, BASEDIR)) {
4220                 return false;
4221         }
4222
4223         /* cleanup */
4224         smbcli_unlink(cli1->tree, fname);
4225
4226         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
4227                               cli1->tree);
4228
4229         /*
4230           base ntcreatex parms
4231         */
4232         io.generic.level = RAW_OPEN_NTCREATEX;
4233         io.ntcreatex.in.root_fid.fnum = 0;
4234         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ |
4235                                       SEC_RIGHTS_FILE_WRITE;
4236         io.ntcreatex.in.alloc_size = 0;
4237         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
4238         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
4239                                        NTCREATEX_SHARE_ACCESS_WRITE;
4240         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
4241         io.ntcreatex.in.create_options = 0;
4242         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
4243         io.ntcreatex.in.security_flags = 0;
4244         io.ntcreatex.in.fname = fname;
4245
4246         /*
4247           with a batch oplock we get a break
4248         */
4249         torture_comment(tctx, "open with batch oplock\n");
4250         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
4251                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
4252                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
4253
4254         status = smb_raw_open(cli1->tree, tctx, &io);
4255         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4256         fnum = io.ntcreatex.out.file.fnum;
4257         CHECK_VAL(io.ntcreatex.out.oplock_level, BATCH_OPLOCK_RETURN);
4258
4259         /* create a file with bogus data */
4260         memset(buf, 0, sizeof(buf));
4261
4262         if (smbcli_write(cli1->tree, fnum, 0, buf, 0, sizeof(buf)) !=
4263                          sizeof(buf))
4264         {
4265                 torture_comment(tctx, "Failed to create file\n");
4266                 ret = false;
4267                 goto done;
4268         }
4269
4270         torture_comment(tctx, "a 2nd open should give a break\n");
4271         ZERO_STRUCT(break_info);
4272
4273         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED;
4274         status = smb_raw_open(cli1->tree, tctx, &io);
4275         fnum2 = io.ntcreatex.out.file.fnum;
4276         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4277         CHECK_VAL(break_info.count, 1);
4278         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
4279         CHECK_VAL(break_info.failures, 0);
4280         CHECK_VAL(break_info.fnum, fnum);
4281
4282         ZERO_STRUCT(break_info);
4283
4284         torture_comment(tctx, "a self BRL acquisition should break to none\n");
4285
4286         status = smbcli_lock(cli1->tree, fnum, 0, 4, 0, WRITE_LOCK);
4287         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4288
4289         torture_wait_for_oplock_break(tctx);
4290         CHECK_VAL(break_info.count, 1);
4291         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_NONE);
4292         CHECK_VAL(break_info.fnum, fnum);
4293         CHECK_VAL(break_info.failures, 0);
4294
4295         /* expect no oplock break */
4296         ZERO_STRUCT(break_info);
4297         status = smbcli_lock(cli1->tree, fnum, 2, 4, 0, WRITE_LOCK);
4298         CHECK_STATUS(tctx, status, NT_STATUS_LOCK_NOT_GRANTED);
4299
4300         torture_wait_for_oplock_break(tctx);
4301         CHECK_VAL(break_info.count, 0);
4302         CHECK_VAL(break_info.level, 0);
4303         CHECK_VAL(break_info.fnum, 0);
4304         CHECK_VAL(break_info.failures, 0);
4305
4306         smbcli_close(cli1->tree, fnum);
4307         smbcli_close(cli1->tree, fnum2);
4308
4309 done:
4310         smb_raw_exit(cli1->session);
4311         smbcli_deltree(cli1->tree, BASEDIR);
4312         return ret;
4313 }
4314
4315 /*
4316  * Open a file with an exclusive oplock from the 1st client and acquire a
4317  * brl. Then open the same file from the 2nd client that should give oplock
4318  * break with level2 to the 1st and return no oplock to the 2nd.
4319  */
4320 static bool test_raw_oplock_brl4(struct torture_context *tctx,
4321                                  struct smbcli_state *cli1,
4322                                  struct smbcli_state *cli2)
4323 {
4324         const char *fname = BASEDIR "\\test_batch_brl.dat";
4325         bool ret = true;
4326         uint8_t buf[1000];
4327         union smb_open io;
4328         NTSTATUS status;
4329         uint16_t fnum = 0;
4330         uint16_t fnum2 = 0;
4331
4332         if (!torture_setup_dir(cli1, BASEDIR)) {
4333                 return false;
4334         }
4335
4336         /* cleanup */
4337         smbcli_unlink(cli1->tree, fname);
4338
4339         smbcli_oplock_handler(cli1->transport, oplock_handler_ack_to_given,
4340                               cli1->tree);
4341
4342         /*
4343           base ntcreatex parms
4344         */
4345         io.generic.level = RAW_OPEN_NTCREATEX;
4346         io.ntcreatex.in.root_fid.fnum = 0;
4347         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_READ |
4348                                       SEC_RIGHTS_FILE_WRITE;
4349         io.ntcreatex.in.alloc_size = 0;
4350         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
4351         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
4352                                        NTCREATEX_SHARE_ACCESS_WRITE;
4353         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
4354         io.ntcreatex.in.create_options = 0;
4355         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
4356         io.ntcreatex.in.security_flags = 0;
4357         io.ntcreatex.in.fname = fname;
4358
4359         torture_comment(tctx, "open with exclusive oplock\n");
4360         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
4361                 NTCREATEX_FLAGS_REQUEST_OPLOCK;
4362
4363         status = smb_raw_open(cli1->tree, tctx, &io);
4364
4365         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4366         fnum = io.ntcreatex.out.file.fnum;
4367         CHECK_VAL(io.ntcreatex.out.oplock_level, EXCLUSIVE_OPLOCK_RETURN);
4368
4369         /* create a file with bogus data */
4370         memset(buf, 0, sizeof(buf));
4371
4372         if (smbcli_write(cli1->tree, fnum, 0, buf, 0, sizeof(buf)) !=
4373                          sizeof(buf))
4374         {
4375                 torture_comment(tctx, "Failed to create file\n");
4376                 goto done;
4377         }
4378
4379         status = smbcli_lock(cli1->tree, fnum, 0, 1, 0, WRITE_LOCK);
4380         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4381
4382         torture_comment(tctx, "a 2nd open should give a break to the 1st\n");
4383         ZERO_STRUCT(break_info);
4384
4385         status = smb_raw_open(cli2->tree, tctx, &io);
4386
4387         CHECK_STATUS(tctx, status, NT_STATUS_OK);
4388         CHECK_VAL(break_info.count, 1);
4389         CHECK_VAL(break_info.level, OPLOCK_BREAK_TO_LEVEL_II);
4390         CHECK_VAL(break_info.failures, 0);
4391         CHECK_VAL(break_info.fnum, fnum);
4392
4393         torture_comment(tctx, "and return no oplock to the 2nd\n");
4394         fnum2 = io.ntcreatex.out.file.fnum;
4395         CHECK_VAL(io.ntcreatex.out.oplock_level, NO_OPLOCK_RETURN);
4396
4397         smbcli_close(cli1->tree, fnum);
4398         smbcli_close(cli2->tree, fnum2);
4399
4400 done:
4401         smb_raw_exit(cli1->session);
4402         smb_raw_exit(cli2->session);
4403         smbcli_deltree(cli1->tree, BASEDIR);
4404         return ret;
4405 }
4406
4407 /*
4408    basic testing of oplocks
4409 */
4410 struct torture_suite *torture_raw_oplock(TALLOC_CTX *mem_ctx)
4411 {
4412         struct torture_suite *suite = torture_suite_create(mem_ctx, "oplock");
4413
4414         torture_suite_add_2smb_test(suite, "exclusive1", test_raw_oplock_exclusive1);
4415         torture_suite_add_2smb_test(suite, "exclusive2", test_raw_oplock_exclusive2);
4416         torture_suite_add_2smb_test(suite, "exclusive3", test_raw_oplock_exclusive3);
4417         torture_suite_add_2smb_test(suite, "exclusive4", test_raw_oplock_exclusive4);
4418         torture_suite_add_2smb_test(suite, "exclusive5", test_raw_oplock_exclusive5);
4419         torture_suite_add_2smb_test(suite, "exclusive6", test_raw_oplock_exclusive6);
4420         torture_suite_add_2smb_test(suite, "exclusive7", test_raw_oplock_exclusive7);
4421         torture_suite_add_2smb_test(suite, "exclusive8",
4422                                     test_raw_oplock_exclusive8);
4423         torture_suite_add_2smb_test(suite, "exclusive9",
4424                                     test_raw_oplock_exclusive9);
4425         torture_suite_add_2smb_test(suite, "level_ii_1",
4426                                     test_raw_oplock_level_ii_1);
4427         torture_suite_add_2smb_test(suite, "batch1", test_raw_oplock_batch1);
4428         torture_suite_add_2smb_test(suite, "batch2", test_raw_oplock_batch2);
4429         torture_suite_add_2smb_test(suite, "batch3", test_raw_oplock_batch3);
4430         torture_suite_add_2smb_test(suite, "batch4", test_raw_oplock_batch4);
4431         torture_suite_add_2smb_test(suite, "batch5", test_raw_oplock_batch5);
4432         torture_suite_add_2smb_test(suite, "batch6", test_raw_oplock_batch6);
4433         torture_suite_add_2smb_test(suite, "batch7", test_raw_oplock_batch7);
4434         torture_suite_add_2smb_test(suite, "batch8", test_raw_oplock_batch8);
4435         torture_suite_add_2smb_test(suite, "batch9", test_raw_oplock_batch9);
4436         torture_suite_add_2smb_test(suite, "batch9a", test_raw_oplock_batch9a);
4437         torture_suite_add_2smb_test(suite, "batch10", test_raw_oplock_batch10);
4438         torture_suite_add_2smb_test(suite, "batch11", test_raw_oplock_batch11);
4439         torture_suite_add_2smb_test(suite, "batch12", test_raw_oplock_batch12);
4440         torture_suite_add_2smb_test(suite, "batch13", test_raw_oplock_batch13);
4441         torture_suite_add_2smb_test(suite, "batch14", test_raw_oplock_batch14);
4442         torture_suite_add_2smb_test(suite, "batch15", test_raw_oplock_batch15);
4443         torture_suite_add_2smb_test(suite, "batch16", test_raw_oplock_batch16);
4444         torture_suite_add_2smb_test(suite, "batch17", test_raw_oplock_batch17);
4445         torture_suite_add_2smb_test(suite, "batch18", test_raw_oplock_batch18);
4446         torture_suite_add_2smb_test(suite, "batch19", test_raw_oplock_batch19);
4447         torture_suite_add_2smb_test(suite, "batch20", test_raw_oplock_batch20);
4448         torture_suite_add_2smb_test(suite, "batch21", test_raw_oplock_batch21);
4449         torture_suite_add_2smb_test(suite, "batch22", test_raw_oplock_batch22);
4450         torture_suite_add_2smb_test(suite, "batch23", test_raw_oplock_batch23);
4451         torture_suite_add_2smb_test(suite, "batch24", test_raw_oplock_batch24);
4452         torture_suite_add_2smb_test(suite, "batch25", test_raw_oplock_batch25);
4453         torture_suite_add_2smb_test(suite, "batch26", test_raw_oplock_batch26);
4454         torture_suite_add_2smb_test(suite, "stream1", test_raw_oplock_stream1);
4455         torture_suite_add_2smb_test(suite, "doc1", test_raw_oplock_doc);
4456         torture_suite_add_2smb_test(suite, "brl1", test_raw_oplock_brl1);
4457         torture_suite_add_1smb_test(suite, "brl2", test_raw_oplock_brl2);
4458         torture_suite_add_1smb_test(suite, "brl3", test_raw_oplock_brl3);
4459         torture_suite_add_2smb_test(suite, "brl4", test_raw_oplock_brl4);
4460
4461         return suite;
4462 }
4463
4464 /*
4465    stress testing of oplocks
4466 */
4467 bool torture_bench_oplock(struct torture_context *torture)
4468 {
4469         struct smbcli_state **cli;
4470         bool ret = true;
4471         TALLOC_CTX *mem_ctx = talloc_new(torture);
4472         int torture_nprocs = torture_setting_int(torture, "nprocs", 4);
4473         int i, count=0;
4474         int timelimit = torture_setting_int(torture, "timelimit", 10);
4475         union smb_open io;
4476         struct timeval tv;
4477
4478         cli = talloc_array(mem_ctx, struct smbcli_state *, torture_nprocs);
4479
4480         torture_comment(torture, "Opening %d connections\n", torture_nprocs);
4481         for (i=0;i<torture_nprocs;i++) {
4482                 if (!torture_open_connection_ev(&cli[i], i, torture, torture->ev)) {
4483                         return false;
4484                 }
4485                 talloc_steal(mem_ctx, cli[i]);
4486                 smbcli_oplock_handler(cli[i]->transport, oplock_handler_close,
4487                                       cli[i]->tree);
4488         }
4489
4490         if (!torture_setup_dir(cli[0], BASEDIR)) {
4491                 ret = false;
4492                 goto done;
4493         }
4494
4495         io.ntcreatex.level = RAW_OPEN_NTCREATEX;
4496         io.ntcreatex.in.root_fid.fnum = 0;
4497         io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
4498         io.ntcreatex.in.alloc_size = 0;
4499         io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
4500         io.ntcreatex.in.share_access = NTCREATEX_SHARE_ACCESS_NONE;
4501         io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
4502         io.ntcreatex.in.create_options = 0;
4503         io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
4504         io.ntcreatex.in.security_flags = 0;
4505         io.ntcreatex.in.fname = BASEDIR "\\test.dat";
4506         io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
4507                 NTCREATEX_FLAGS_REQUEST_OPLOCK |
4508                 NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
4509
4510         tv = timeval_current();
4511
4512         /*
4513           we open the same file with SHARE_ACCESS_NONE from all the
4514           connections in a round robin fashion. Each open causes an
4515           oplock break on the previous connection, which is answered
4516           by the oplock_handler_close() to close the file.
4517
4518           This measures how fast we can pass on oplocks, and stresses
4519           the oplock handling code
4520         */
4521         torture_comment(torture, "Running for %d seconds\n", timelimit);
4522         while (timeval_elapsed(&tv) < timelimit) {
4523                 for (i=0;i<torture_nprocs;i++) {
4524                         NTSTATUS status;
4525
4526                         status = smb_raw_open(cli[i]->tree, mem_ctx, &io);
4527                         CHECK_STATUS(torture, status, NT_STATUS_OK);
4528                         count++;
4529                 }
4530
4531                 if (torture_setting_bool(torture, "progress", true)) {
4532                         torture_comment(torture, "%.2f ops/second\r", count/timeval_elapsed(&tv));
4533                 }
4534         }
4535
4536         torture_comment(torture, "%.2f ops/second\n", count/timeval_elapsed(&tv));
4537
4538         smb_raw_exit(cli[torture_nprocs-1]->session);
4539
4540 done:
4541         smb_raw_exit(cli[0]->session);
4542         smbcli_deltree(cli[0]->tree, BASEDIR);
4543         talloc_free(mem_ctx);
4544         return ret;
4545 }
4546
4547
4548 static struct hold_oplock_info {
4549         const char *fname;
4550         bool close_on_break;
4551         uint32_t share_access;
4552         uint16_t fnum;
4553 } hold_info[] = {
4554         {
4555                 .fname          = BASEDIR "\\notshared_close",
4556                 .close_on_break = true,
4557                 .share_access   = NTCREATEX_SHARE_ACCESS_NONE,
4558         },
4559         {
4560                 .fname          = BASEDIR "\\notshared_noclose",
4561                 .close_on_break = false,
4562                 .share_access   = NTCREATEX_SHARE_ACCESS_NONE,
4563         },
4564         {
4565                 .fname          = BASEDIR "\\shared_close",
4566                 .close_on_break = true,
4567                 .share_access   = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
4568         },
4569         {
4570                 .fname          = BASEDIR "\\shared_noclose",
4571                 .close_on_break = false,
4572                 .share_access   = NTCREATEX_SHARE_ACCESS_READ|NTCREATEX_SHARE_ACCESS_WRITE|NTCREATEX_SHARE_ACCESS_DELETE,
4573         },
4574 };
4575
4576 static bool oplock_handler_hold(struct smbcli_transport *transport,
4577                                 uint16_t tid, uint16_t fnum, uint8_t level,
4578                                 void *private_data)
4579 {
4580         struct smbcli_tree *tree = (struct smbcli_tree *)private_data;
4581         struct hold_oplock_info *info;
4582         int i;
4583
4584         for (i=0;i<ARRAY_SIZE(hold_info);i++) {
4585                 if (hold_info[i].fnum == fnum) break;
4586         }
4587
4588         if (i == ARRAY_SIZE(hold_info)) {
4589                 printf("oplock break for unknown fnum %u\n", fnum);
4590                 return false;
4591         }
4592
4593         info = &hold_info[i];
4594
4595         if (info->close_on_break) {
4596                 printf("oplock break on %s - closing\n",
4597                        info->fname);
4598                 oplock_handler_close(transport, tid, fnum, level, private_data);
4599                 return true;
4600         }
4601
4602         printf("oplock break on %s - acking break\n", info->fname);
4603
4604         return smbcli_oplock_ack(tree, fnum, OPLOCK_BREAK_TO_NONE);
4605 }
4606
4607
4608 /*
4609    used for manual testing of oplocks - especially interaction with
4610    other filesystems (such as NFS and local access)
4611 */
4612 bool torture_hold_oplock(struct torture_context *torture,
4613                          struct smbcli_state *cli)
4614 {
4615         struct tevent_context *ev = torture->ev;
4616         int i;
4617
4618         printf("Setting up open files with oplocks in %s\n", BASEDIR);
4619
4620         torture_assert(torture, torture_setup_dir(cli, BASEDIR), "Failed to setup up test directory: " BASEDIR);
4621
4622         smbcli_oplock_handler(cli->transport, oplock_handler_hold, cli->tree);
4623
4624         /* setup the files */
4625         for (i=0;i<ARRAY_SIZE(hold_info);i++) {
4626                 union smb_open io;
4627                 NTSTATUS status;
4628                 char c = 1;
4629
4630                 io.generic.level = RAW_OPEN_NTCREATEX;
4631                 io.ntcreatex.in.root_fid.fnum = 0;
4632                 io.ntcreatex.in.access_mask = SEC_RIGHTS_FILE_ALL;
4633                 io.ntcreatex.in.alloc_size = 0;
4634                 io.ntcreatex.in.file_attr = FILE_ATTRIBUTE_NORMAL;
4635                 io.ntcreatex.in.share_access = hold_info[i].share_access;
4636                 io.ntcreatex.in.open_disposition = NTCREATEX_DISP_OPEN_IF;
4637                 io.ntcreatex.in.create_options = 0;
4638                 io.ntcreatex.in.impersonation = NTCREATEX_IMPERSONATION_ANONYMOUS;
4639                 io.ntcreatex.in.security_flags = 0;
4640                 io.ntcreatex.in.fname = hold_info[i].fname;
4641                 io.ntcreatex.in.flags = NTCREATEX_FLAGS_EXTENDED |
4642                         NTCREATEX_FLAGS_REQUEST_OPLOCK |
4643                         NTCREATEX_FLAGS_REQUEST_BATCH_OPLOCK;
4644                 printf("opening %s\n", hold_info[i].fname);
4645
4646                 status = smb_raw_open(cli->tree, cli, &io);
4647                 if (!NT_STATUS_IS_OK(status)) {
4648                         printf("Failed to open %s - %s\n",
4649                                hold_info[i].fname, nt_errstr(status));
4650                         return false;
4651                 }
4652
4653                 if (io.ntcreatex.out.oplock_level != BATCH_OPLOCK_RETURN) {
4654                         printf("Oplock not granted for %s - expected %d but got %d\n",
4655                                hold_info[i].fname, BATCH_OPLOCK_RETURN,
4656                                 io.ntcreatex.out.oplock_level);
4657                         return false;
4658                 }
4659                 hold_info[i].fnum = io.ntcreatex.out.file.fnum;
4660
4661                 /* make the file non-zero size */
4662                 if (smbcli_write(cli->tree, hold_info[i].fnum, 0, &c, 0, 1) != 1) {
4663                         printf("Failed to write to file\n");
4664                         return false;
4665                 }
4666         }
4667
4668         printf("Waiting for oplock events\n");
4669         tevent_loop_wait(ev);
4670
4671         return true;
4672 }