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