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