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