?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:torture:smb2: add new durable-open.reopen1a test
[Samba.git] / source4 / torture / smb2 / durable_open.c
blob23425c8e44dade92257adf2126f5afa3b8d4f24b
1 /*
2 Unix SMB/CIFS implementation.
3
4 test suite for SMB2 durable opens
5
6 Copyright (C) Stefan Metzmacher 2008
7 Copyright (C) Michael Adam 2011-2012
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "libcli/smb2/smb2.h"
25 #include "libcli/smb2/smb2_calls.h"
26 #include "../libcli/smb/smbXcli_base.h"
27 #include "torture/torture.h"
28 #include "torture/smb2/proto.h"
29 #include "../libcli/smb/smbXcli_base.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%llx - should be 0x%llx\n", \
34 __location__, #v, (unsigned long long)v, (unsigned long long)correct); \
35 ret = false; \
36 }} while (0)
37
38 #define CHECK_NOT_VAL(v, correct) do { \
39 if ((v) == (correct)) { \
40 torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s got 0x%llx - should not be 0x%llx\n", \
41 __location__, #v, (unsigned long long)v, (unsigned long long)correct); \
42 ret = false; \
43 }} while (0)
44
45 #define CHECK_STATUS(status, correct) do { \
46 if (!NT_STATUS_EQUAL(status, correct)) { \
47 torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
48 nt_errstr(status), nt_errstr(correct)); \
49 ret = false; \
50 goto done; \
51 }} while (0)
52
53 #define CHECK_CREATED(__io, __created, __attribute) \
54 do { \
55 CHECK_VAL((__io)->out.create_action, NTCREATEX_ACTION_ ## __created); \
56 CHECK_VAL((__io)->out.alloc_size, 0); \
57 CHECK_VAL((__io)->out.size, 0); \
58 CHECK_VAL((__io)->out.file_attr, (__attribute)); \
59 CHECK_VAL((__io)->out.reserved2, 0); \
60 } while(0)
61
62 #define CHECK_CREATED_SIZE(__io, __created, __attribute, __alloc_size, __size) \
63 do { \
64 CHECK_VAL((__io)->out.create_action, NTCREATEX_ACTION_ ## __created); \
65 CHECK_VAL((__io)->out.alloc_size, (__alloc_size)); \
66 CHECK_VAL((__io)->out.size, (__size)); \
67 CHECK_VAL((__io)->out.file_attr, (__attribute)); \
68 CHECK_VAL((__io)->out.reserved2, 0); \
69 } while(0)
70
71
72
73 /**
74 * basic durable_open test.
75 * durable state should only be granted when requested
76 * along with a batch oplock or a handle lease.
77 *
78 * This test tests durable open with all possible oplock types.
79 */
80
81 struct durable_open_vs_oplock {
82 const char *level;
83 const char *share_mode;
84 bool expected;
85 };
86
87 #define NUM_OPLOCK_TYPES 4
88 #define NUM_SHARE_MODES 8
89 #define NUM_OPLOCK_OPEN_TESTS ( NUM_OPLOCK_TYPES * NUM_SHARE_MODES )
90 static struct durable_open_vs_oplock durable_open_vs_oplock_table[NUM_OPLOCK_OPEN_TESTS] =
91 {
92 { "", "", false },
93 { "", "R", false },
94 { "", "W", false },
95 { "", "D", false },
96 { "", "RD", false },
97 { "", "RW", false },
98 { "", "WD", false },
99 { "", "RWD", false },
100
101 { "s", "", false },
102 { "s", "R", false },
103 { "s", "W", false },
104 { "s", "D", false },
105 { "s", "RD", false },
106 { "s", "RW", false },
107 { "s", "WD", false },
108 { "s", "RWD", false },
109
110 { "x", "", false },
111 { "x", "R", false },
112 { "x", "W", false },
113 { "x", "D", false },
114 { "x", "RD", false },
115 { "x", "RW", false },
116 { "x", "WD", false },
117 { "x", "RWD", false },
118
119 { "b", "", true },
120 { "b", "R", true },
121 { "b", "W", true },
122 { "b", "D", true },
123 { "b", "RD", true },
124 { "b", "RW", true },
125 { "b", "WD", true },
126 { "b", "RWD", true },
127 };
128
129 static bool test_one_durable_open_open_oplock(struct torture_context *tctx,
130 struct smb2_tree *tree,
131 const char *fname,
132 struct durable_open_vs_oplock test)
133 {
134 NTSTATUS status;
135 TALLOC_CTX *mem_ctx = talloc_new(tctx);
136 struct smb2_handle _h;
137 struct smb2_handle *h = NULL;
138 bool ret = true;
139 struct smb2_create io;
140
141 smb2_util_unlink(tree, fname);
142
143 smb2_oplock_create_share(&io, fname,
144 smb2_util_share_access(test.share_mode),
145 smb2_util_oplock_level(test.level));
146 io.in.durable_open = true;
147
148 status = smb2_create(tree, mem_ctx, &io);
149 CHECK_STATUS(status, NT_STATUS_OK);
150 _h = io.out.file.handle;
151 h = &_h;
152 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
153 CHECK_VAL(io.out.durable_open, test.expected);
154 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(test.level));
155
156 done:
157 if (h != NULL) {
158 smb2_util_close(tree, *h);
159 }
160 smb2_util_unlink(tree, fname);
161 talloc_free(mem_ctx);
162
163 return ret;
164 }
165
166 static bool test_durable_open_open_oplock(struct torture_context *tctx,
167 struct smb2_tree *tree)
168 {
169 TALLOC_CTX *mem_ctx = talloc_new(tctx);
170 char fname[256];
171 bool ret = true;
172 int i;
173
174 /* Choose a random name in case the state is left a little funky. */
175 snprintf(fname, 256, "durable_open_open_oplock_%s.dat", generate_random_str(tctx, 8));
176
177 smb2_util_unlink(tree, fname);
178
179 /* test various oplock levels with durable open */
180
181 for (i = 0; i < NUM_OPLOCK_OPEN_TESTS; i++) {
182 ret = test_one_durable_open_open_oplock(tctx,
183 tree,
184 fname,
185 durable_open_vs_oplock_table[i]);
186 if (ret == false) {
187 goto done;
188 }
189 }
190
191 done:
192 smb2_util_unlink(tree, fname);
193 talloc_free(tree);
194 talloc_free(mem_ctx);
195
196 return ret;
197 }
198
199 /**
200 * basic durable_open test.
201 * durable state should only be granted when requested
202 * along with a batch oplock or a handle lease.
203 *
204 * This test tests durable open with all valid lease types.
205 */
206
207 struct durable_open_vs_lease {
208 const char *type;
209 const char *share_mode;
210 bool expected;
211 };
212
213 #define NUM_LEASE_TYPES 5
214 #define NUM_LEASE_OPEN_TESTS ( NUM_LEASE_TYPES * NUM_SHARE_MODES )
215 static struct durable_open_vs_lease durable_open_vs_lease_table[NUM_LEASE_OPEN_TESTS] =
216 {
217 { "", "", false },
218 { "", "R", false },
219 { "", "W", false },
220 { "", "D", false },
221 { "", "RW", false },
222 { "", "RD", false },
223 { "", "WD", false },
224 { "", "RWD", false },
225
226 { "R", "", false },
227 { "R", "R", false },
228 { "R", "W", false },
229 { "R", "D", false },
230 { "R", "RW", false },
231 { "R", "RD", false },
232 { "R", "DW", false },
233 { "R", "RWD", false },
234
235 { "RW", "", false },
236 { "RW", "R", false },
237 { "RW", "W", false },
238 { "RW", "D", false },
239 { "RW", "RW", false },
240 { "RW", "RD", false },
241 { "RW", "WD", false },
242 { "RW", "RWD", false },
243
244 { "RH", "", true },
245 { "RH", "R", true },
246 { "RH", "W", true },
247 { "RH", "D", true },
248 { "RH", "RW", true },
249 { "RH", "RD", true },
250 { "RH", "WD", true },
251 { "RH", "RWD", true },
252
253 { "RHW", "", true },
254 { "RHW", "R", true },
255 { "RHW", "W", true },
256 { "RHW", "D", true },
257 { "RHW", "RW", true },
258 { "RHW", "RD", true },
259 { "RHW", "WD", true },
260 { "RHW", "RWD", true },
261 };
262
263 static bool test_one_durable_open_open_lease(struct torture_context *tctx,
264 struct smb2_tree *tree,
265 const char *fname,
266 struct durable_open_vs_lease test)
267 {
268 NTSTATUS status;
269 TALLOC_CTX *mem_ctx = talloc_new(tctx);
270 struct smb2_handle _h;
271 struct smb2_handle *h = NULL;
272 bool ret = true;
273 struct smb2_create io;
274 struct smb2_lease ls;
275 uint64_t lease;
276 uint32_t caps;
277
278 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
279 if (!(caps & SMB2_CAP_LEASING)) {
280 torture_skip(tctx, "leases are not supported");
281 }
282
283 smb2_util_unlink(tree, fname);
284
285 lease = random();
286
287 smb2_lease_create_share(&io, &ls, false /* dir */, fname,
288 smb2_util_share_access(test.share_mode),
289 lease,
290 smb2_util_lease_state(test.type));
291 io.in.durable_open = true;
292
293 status = smb2_create(tree, mem_ctx, &io);
294 CHECK_STATUS(status, NT_STATUS_OK);
295 _h = io.out.file.handle;
296 h = &_h;
297 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
298 CHECK_VAL(io.out.durable_open, test.expected);
299 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
300 CHECK_VAL(io.out.lease_response.lease_key.data[0], lease);
301 CHECK_VAL(io.out.lease_response.lease_key.data[1], ~lease);
302 CHECK_VAL(io.out.lease_response.lease_state,
303 smb2_util_lease_state(test.type));
304 done:
305 if (h != NULL) {
306 smb2_util_close(tree, *h);
307 }
308 smb2_util_unlink(tree, fname);
309 talloc_free(mem_ctx);
310
311 return ret;
312 }
313
314 static bool test_durable_open_open_lease(struct torture_context *tctx,
315 struct smb2_tree *tree)
316 {
317 TALLOC_CTX *mem_ctx = talloc_new(tctx);
318 char fname[256];
319 bool ret = true;
320 int i;
321 uint32_t caps;
322
323 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
324 if (!(caps & SMB2_CAP_LEASING)) {
325 torture_skip(tctx, "leases are not supported");
326 }
327
328 /* Choose a random name in case the state is left a little funky. */
329 snprintf(fname, 256, "durable_open_open_lease_%s.dat", generate_random_str(tctx, 8));
330
331 smb2_util_unlink(tree, fname);
332
333
334 /* test various oplock levels with durable open */
335
336 for (i = 0; i < NUM_LEASE_OPEN_TESTS; i++) {
337 ret = test_one_durable_open_open_lease(tctx,
338 tree,
339 fname,
340 durable_open_vs_lease_table[i]);
341 if (ret == false) {
342 goto done;
343 }
344 }
345
346 done:
347 smb2_util_unlink(tree, fname);
348 talloc_free(tree);
349 talloc_free(mem_ctx);
350
351 return ret;
352 }
353
354 /**
355 * basic test for doing a durable open
356 * and do a durable reopen on the same connection
357 * while the first open is still active (fails)
358 */
359 static bool test_durable_open_reopen1(struct torture_context *tctx,
360 struct smb2_tree *tree)
361 {
362 NTSTATUS status;
363 TALLOC_CTX *mem_ctx = talloc_new(tctx);
364 char fname[256];
365 struct smb2_handle _h;
366 struct smb2_handle *h = NULL;
367 struct smb2_create io1, io2;
368 bool ret = true;
369
370 /* Choose a random name in case the state is left a little funky. */
371 snprintf(fname, 256, "durable_open_reopen1_%s.dat",
372 generate_random_str(tctx, 8));
373
374 smb2_util_unlink(tree, fname);
375
376 smb2_oplock_create_share(&io1, fname,
377 smb2_util_share_access(""),
378 smb2_util_oplock_level("b"));
379 io1.in.durable_open = true;
380
381 status = smb2_create(tree, mem_ctx, &io1);
382 CHECK_STATUS(status, NT_STATUS_OK);
383 _h = io1.out.file.handle;
384 h = &_h;
385 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
386 CHECK_VAL(io1.out.durable_open, true);
387 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
388
389 /* try a durable reconnect while the file is still open */
390 ZERO_STRUCT(io2);
391 io2.in.fname = fname;
392 io2.in.durable_handle = h;
393
394 status = smb2_create(tree, mem_ctx, &io2);
395 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
396
397 done:
398 if (h != NULL) {
399 smb2_util_close(tree, *h);
400 }
401
402 smb2_util_unlink(tree, fname);
403
404 talloc_free(tree);
405
406 talloc_free(mem_ctx);
407
408 return ret;
409 }
410
411 /**
412 * Basic test for doing a durable open
413 * and do a session reconnect while the first
414 * session is still active and the handle is
415 * still open in the client.
416 * This closes the original session and a
417 * durable reconnect on the new session succeeds.
418 */
419 static bool test_durable_open_reopen1a(struct torture_context *tctx,
420 struct smb2_tree *tree)
421 {
422 NTSTATUS status;
423 TALLOC_CTX *mem_ctx = talloc_new(tctx);
424 char fname[256];
425 struct smb2_handle _h;
426 struct smb2_handle *h = NULL;
427 struct smb2_create io1, io2;
428 bool ret = true;
429 struct smb2_tree *tree2 = NULL;
430 uint64_t previous_session_id;
431 struct smbcli_options options;
432
433 options = tree->session->transport->options;
434
435 /* Choose a random name in case the state is left a little funky. */
436 snprintf(fname, 256, "durable_open_reopen1a_%s.dat",
437 generate_random_str(tctx, 8));
438
439 smb2_util_unlink(tree, fname);
440
441 smb2_oplock_create_share(&io1, fname,
442 smb2_util_share_access(""),
443 smb2_util_oplock_level("b"));
444 io1.in.durable_open = true;
445
446 status = smb2_create(tree, mem_ctx, &io1);
447 CHECK_STATUS(status, NT_STATUS_OK);
448 _h = io1.out.file.handle;
449 h = &_h;
450 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
451 CHECK_VAL(io1.out.durable_open, true);
452 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
453
454 /*
455 * a session reconnect on a second tcp connection
456 */
457
458 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
459
460 if (!torture_smb2_connection_ext(tctx, previous_session_id,
461 &options, &tree2))
462 {
463 torture_warning(tctx, "couldn't reconnect, bailing\n");
464 ret = false;
465 goto done;
466 }
467
468 /*
469 * check that this has deleted the old session
470 */
471
472 ZERO_STRUCT(io2);
473 io2.in.fname = fname;
474 io2.in.durable_handle = h;
475
476 status = smb2_create(tree, mem_ctx, &io2);
477 CHECK_STATUS(status, NT_STATUS_USER_SESSION_DELETED);
478
479 /*
480 * but a durable reconnect on the new session succeeds:
481 */
482
483 ZERO_STRUCT(io2);
484 io2.in.fname = fname;
485 io2.in.durable_handle = h;
486
487 status = smb2_create(tree2, mem_ctx, &io2);
488 CHECK_STATUS(status, NT_STATUS_OK);
489 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
490 CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));
491 _h = io2.out.file.handle;
492 h = &_h;
493
494 done:
495 if (h != NULL) {
496 smb2_util_close(tree2, *h);
497 }
498
499 smb2_util_unlink(tree2, fname);
500
501 talloc_free(tree2);
502
503 talloc_free(tree);
504
505 talloc_free(mem_ctx);
506
507 return ret;
508 }
509
510 /**
511 * basic test for doing a durable open
512 * tcp disconnect, reconnect, do a durable reopen (succeeds)
513 */
514 static bool test_durable_open_reopen2(struct torture_context *tctx,
515 struct smb2_tree *tree)
516 {
517 NTSTATUS status;
518 TALLOC_CTX *mem_ctx = talloc_new(tctx);
519 char fname[256];
520 struct smb2_handle _h;
521 struct smb2_handle *h = NULL;
522 struct smb2_create io;
523 bool ret = true;
524
525 /* Choose a random name in case the state is left a little funky. */
526 snprintf(fname, 256, "durable_open_reopen2_%s.dat",
527 generate_random_str(tctx, 8));
528
529 smb2_util_unlink(tree, fname);
530
531 smb2_oplock_create_share(&io, fname,
532 smb2_util_share_access(""),
533 smb2_util_oplock_level("b"));
534 io.in.durable_open = true;
535
536 status = smb2_create(tree, mem_ctx, &io);
537 CHECK_STATUS(status, NT_STATUS_OK);
538 _h = io.out.file.handle;
539 h = &_h;
540 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
541 CHECK_VAL(io.out.durable_open, true);
542 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
543
544 /* disconnect, leaving the durable in place */
545 TALLOC_FREE(tree);
546
547 if (!torture_smb2_connection(tctx, &tree)) {
548 torture_warning(tctx, "couldn't reconnect, bailing\n");
549 ret = false;
550 goto done;
551 }
552
553 ZERO_STRUCT(io);
554 /* the path name is ignored by the server */
555 io.in.fname = fname;
556 io.in.durable_handle = h; /* durable v1 reconnect request */
557 h = NULL;
558
559 status = smb2_create(tree, mem_ctx, &io);
560 CHECK_STATUS(status, NT_STATUS_OK);
561 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
562 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
563 _h = io.out.file.handle;
564 h = &_h;
565
566 /* disconnect again, leaving the durable in place */
567 TALLOC_FREE(tree);
568
569 if (!torture_smb2_connection(tctx, &tree)) {
570 torture_warning(tctx, "couldn't reconnect, bailing\n");
571 ret = false;
572 goto done;
573 }
574
575 /*
576 * show that the filename and many other fields
577 * are ignored. only the reconnect request blob
578 * is important.
579 */
580 ZERO_STRUCT(io);
581 /* the path name is ignored by the server */
582 io.in.security_flags = 0x78;
583 io.in.oplock_level = 0x78;
584 io.in.impersonation_level = 0x12345678;
585 io.in.create_flags = 0x12345678;
586 io.in.reserved = 0x12345678;
587 io.in.desired_access = 0x12345678;
588 io.in.file_attributes = 0x12345678;
589 io.in.share_access = 0x12345678;
590 io.in.create_disposition = 0x12345678;
591 io.in.create_options = 0x12345678;
592 io.in.fname = "__non_existing_fname__";
593 io.in.durable_handle = h; /* durable v1 reconnect request */
594 h = NULL;
595
596 status = smb2_create(tree, mem_ctx, &io);
597 CHECK_STATUS(status, NT_STATUS_OK);
598 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
599 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
600 _h = io.out.file.handle;
601 h = &_h;
602
603 /* disconnect, leaving the durable in place */
604 TALLOC_FREE(tree);
605
606 if (!torture_smb2_connection(tctx, &tree)) {
607 torture_warning(tctx, "couldn't reconnect, bailing\n");
608 ret = false;
609 goto done;
610 }
611
612 /*
613 * show that an additionally specified durable v1 request
614 * is ignored by the server.
615 * See MS-SMB2, 3.3.5.9.7
616 * Handling the SMB2_CREATE_DURABLE_HANDLE_RECONNECT Create Context
617 */
618 ZERO_STRUCT(io);
619 /* the path name is ignored by the server */
620 io.in.fname = fname;
621 io.in.durable_handle = h; /* durable v1 reconnect request */
622 io.in.durable_open = true; /* durable v1 handle request */
623 h = NULL;
624
625 status = smb2_create(tree, mem_ctx, &io);
626 CHECK_STATUS(status, NT_STATUS_OK);
627 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
628 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
629 _h = io.out.file.handle;
630 h = &_h;
631
632 done:
633 if (tree != NULL) {
634 if (h != NULL) {
635 smb2_util_close(tree, *h);
636 }
637
638 smb2_util_unlink(tree, fname);
639
640 talloc_free(tree);
641 }
642
643 talloc_free(mem_ctx);
644
645 return ret;
646 }
647
648 /**
649 * lease variant of reopen2
650 * basic test for doing a durable open
651 * tcp disconnect, reconnect, do a durable reopen (succeeds)
652 */
653 static bool test_durable_open_reopen2_lease(struct torture_context *tctx,
654 struct smb2_tree *tree)
655 {
656 NTSTATUS status;
657 TALLOC_CTX *mem_ctx = talloc_new(tctx);
658 char fname[256];
659 struct smb2_handle _h;
660 struct smb2_handle *h = NULL;
661 struct smb2_create io;
662 struct smb2_lease ls;
663 uint64_t lease_key;
664 bool ret = true;
665 struct smbcli_options options;
666 uint32_t caps;
667
668 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
669 if (!(caps & SMB2_CAP_LEASING)) {
670 torture_skip(tctx, "leases are not supported");
671 }
672
673 options = tree->session->transport->options;
674
675 /* Choose a random name in case the state is left a little funky. */
676 snprintf(fname, 256, "durable_open_reopen2_%s.dat",
677 generate_random_str(tctx, 8));
678
679 smb2_util_unlink(tree, fname);
680
681 lease_key = random();
682 smb2_lease_create(&io, &ls, false /* dir */, fname, lease_key,
683 smb2_util_lease_state("RWH"));
684 io.in.durable_open = true;
685
686 status = smb2_create(tree, mem_ctx, &io);
687 CHECK_STATUS(status, NT_STATUS_OK);
688 _h = io.out.file.handle;
689 h = &_h;
690 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
691
692 CHECK_VAL(io.out.durable_open, true);
693 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
694 CHECK_VAL(io.out.lease_response.lease_key.data[0], lease_key);
695 CHECK_VAL(io.out.lease_response.lease_key.data[1], ~lease_key);
696 CHECK_VAL(io.out.lease_response.lease_state,
697 smb2_util_lease_state("RWH"));
698 CHECK_VAL(io.out.lease_response.lease_flags, 0);
699 CHECK_VAL(io.out.lease_response.lease_duration, 0);
700
701 /* disconnect, reconnect and then do durable reopen */
702 TALLOC_FREE(tree);
703
704 if (!torture_smb2_connection_ext(tctx, 0, &options, &tree)) {
705 torture_warning(tctx, "couldn't reconnect, bailing\n");
706 ret = false;
707 goto done;
708 }
709
710
711 /* a few failure tests: */
712
713 /*
714 * several attempts without lease attached:
715 * all fail with NT_STATUS_OBJECT_NAME_NOT_FOUND
716 * irrespective of file name provided
717 */
718
719 ZERO_STRUCT(io);
720 io.in.fname = "";
721 io.in.durable_handle = h;
722 status = smb2_create(tree, mem_ctx, &io);
723 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
724
725 ZERO_STRUCT(io);
726 io.in.fname = "__non_existing_fname__";
727 io.in.durable_handle = h;
728 status = smb2_create(tree, mem_ctx, &io);
729 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
730
731 ZERO_STRUCT(io);
732 io.in.fname = fname;
733 io.in.durable_handle = h;
734 status = smb2_create(tree, mem_ctx, &io);
735 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
736
737 /*
738 * attempt with lease provided, but
739 * with a changed lease key. => fails
740 */
741 ZERO_STRUCT(io);
742 io.in.fname = fname;
743 io.in.durable_open = false;
744 io.in.durable_handle = h;
745 io.in.lease_request = &ls;
746 io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
747 /* a wrong lease key lets the request fail */
748 ls.lease_key.data[0]++;
749
750 status = smb2_create(tree, mem_ctx, &io);
751 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
752
753 /* restore the correct lease key */
754 ls.lease_key.data[0]--;
755
756 /*
757 * this last failing attempt is almost correct:
758 * only problem is: we use the wrong filename...
759 * Note that this gives INVALID_PARAMETER.
760 * This is different from oplocks!
761 */
762 ZERO_STRUCT(io);
763 io.in.fname = "__non_existing_fname__";
764 io.in.durable_open = false;
765 io.in.durable_handle = h;
766 io.in.lease_request = &ls;
767 io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
768
769 status = smb2_create(tree, mem_ctx, &io);
770 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
771
772 /*
773 * Now for a succeeding reconnect:
774 */
775
776 ZERO_STRUCT(io);
777 io.in.fname = fname;
778 io.in.durable_open = false;
779 io.in.durable_handle = h;
780 io.in.lease_request = &ls;
781 io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
782
783 /* the requested lease state is irrelevant */
784 ls.lease_state = smb2_util_lease_state("");
785
786 h = NULL;
787
788 status = smb2_create(tree, mem_ctx, &io);
789 CHECK_STATUS(status, NT_STATUS_OK);
790
791 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
792 CHECK_VAL(io.out.durable_open, false);
793 CHECK_VAL(io.out.durable_open_v2, false); /* no dh2q response blob */
794 CHECK_VAL(io.out.persistent_open, false);
795 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
796 CHECK_VAL(io.out.lease_response.lease_key.data[0], lease_key);
797 CHECK_VAL(io.out.lease_response.lease_key.data[1], ~lease_key);
798 CHECK_VAL(io.out.lease_response.lease_state,
799 smb2_util_lease_state("RWH"));
800 CHECK_VAL(io.out.lease_response.lease_flags, 0);
801 CHECK_VAL(io.out.lease_response.lease_duration, 0);
802 _h = io.out.file.handle;
803 h = &_h;
804
805 /* disconnect one more time */
806 TALLOC_FREE(tree);
807
808 if (!torture_smb2_connection_ext(tctx, 0, &options, &tree)) {
809 torture_warning(tctx, "couldn't reconnect, bailing\n");
810 ret = false;
811 goto done;
812 }
813
814 /*
815 * demonstrate that various parameters are ignored
816 * in the reconnect
817 */
818
819 ZERO_STRUCT(io);
820 /*
821 * These are completely ignored by the server
822 */
823 io.in.security_flags = 0x78;
824 io.in.oplock_level = 0x78;
825 io.in.impersonation_level = 0x12345678;
826 io.in.create_flags = 0x12345678;
827 io.in.reserved = 0x12345678;
828 io.in.desired_access = 0x12345678;
829 io.in.file_attributes = 0x12345678;
830 io.in.share_access = 0x12345678;
831 io.in.create_disposition = 0x12345678;
832 io.in.create_options = 0x12345678;
833
834 /*
835 * only these are checked:
836 * - io.in.fname
837 * - io.in.durable_handle,
838 * - io.in.lease_request->lease_key
839 */
840
841 io.in.fname = fname;
842 io.in.durable_open_v2 = false;
843 io.in.durable_handle_v2 = h;
844 io.in.lease_request = &ls;
845
846 /* the requested lease state is irrelevant */
847 ls.lease_state = smb2_util_lease_state("");
848
849 h = NULL;
850
851 status = smb2_create(tree, mem_ctx, &io);
852 CHECK_STATUS(status, NT_STATUS_OK);
853
854 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
855 CHECK_VAL(io.out.durable_open, false);
856 CHECK_VAL(io.out.durable_open_v2, false); /* no dh2q response blob */
857 CHECK_VAL(io.out.persistent_open, false);
858 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
859 CHECK_VAL(io.out.lease_response.lease_key.data[0], lease_key);
860 CHECK_VAL(io.out.lease_response.lease_key.data[1], ~lease_key);
861 CHECK_VAL(io.out.lease_response.lease_state,
862 smb2_util_lease_state("RWH"));
863 CHECK_VAL(io.out.lease_response.lease_flags, 0);
864 CHECK_VAL(io.out.lease_response.lease_duration, 0);
865
866 _h = io.out.file.handle;
867 h = &_h;
868
869 done:
870 if (tree != NULL) {
871 if (h != NULL) {
872 smb2_util_close(tree, *h);
873 }
874
875 smb2_util_unlink(tree, fname);
876
877 talloc_free(tree);
878 }
879
880 talloc_free(mem_ctx);
881
882 return ret;
883 }
884
885 /**
886 * lease v2 variant of reopen2
887 * basic test for doing a durable open
888 * tcp disconnect, reconnect, do a durable reopen (succeeds)
889 */
890 static bool test_durable_open_reopen2_lease_v2(struct torture_context *tctx,
891 struct smb2_tree *tree)
892 {
893 NTSTATUS status;
894 TALLOC_CTX *mem_ctx = talloc_new(tctx);
895 char fname[256];
896 struct smb2_handle _h;
897 struct smb2_handle *h = NULL;
898 struct smb2_create io;
899 struct smb2_lease ls;
900 uint64_t lease_key;
901 bool ret = true;
902 struct smbcli_options options;
903 uint32_t caps;
904
905 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
906 if (!(caps & SMB2_CAP_LEASING)) {
907 torture_skip(tctx, "leases are not supported");
908 }
909
910 options = tree->session->transport->options;
911
912 /* Choose a random name in case the state is left a little funky. */
913 snprintf(fname, 256, "durable_open_reopen2_%s.dat",
914 generate_random_str(tctx, 8));
915
916 smb2_util_unlink(tree, fname);
917
918 lease_key = random();
919 smb2_lease_v2_create(&io, &ls, false /* dir */, fname,
920 lease_key, 0, /* parent lease key */
921 smb2_util_lease_state("RWH"), 0 /* lease epoch */);
922 io.in.durable_open = true;
923
924 status = smb2_create(tree, mem_ctx, &io);
925 CHECK_STATUS(status, NT_STATUS_OK);
926 _h = io.out.file.handle;
927 h = &_h;
928 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
929
930 CHECK_VAL(io.out.durable_open, true);
931 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
932 CHECK_VAL(io.out.lease_response_v2.lease_key.data[0], lease_key);
933 CHECK_VAL(io.out.lease_response_v2.lease_key.data[1], ~lease_key);
934 CHECK_VAL(io.out.lease_response_v2.lease_state,
935 smb2_util_lease_state("RWH"));
936 CHECK_VAL(io.out.lease_response_v2.lease_flags, 0);
937 CHECK_VAL(io.out.lease_response_v2.lease_duration, 0);
938
939 /* disconnect, reconnect and then do durable reopen */
940 TALLOC_FREE(tree);
941
942 if (!torture_smb2_connection_ext(tctx, 0, &options, &tree)) {
943 torture_warning(tctx, "couldn't reconnect, bailing\n");
944 ret = false;
945 goto done;
946 }
947
948 /* a few failure tests: */
949
950 /*
951 * several attempts without lease attached:
952 * all fail with NT_STATUS_OBJECT_NAME_NOT_FOUND
953 * irrespective of file name provided
954 */
955
956 ZERO_STRUCT(io);
957 io.in.fname = "";
958 io.in.durable_handle = h;
959 status = smb2_create(tree, mem_ctx, &io);
960 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
961
962 ZERO_STRUCT(io);
963 io.in.fname = "__non_existing_fname__";
964 io.in.durable_handle = h;
965 status = smb2_create(tree, mem_ctx, &io);
966 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
967
968 ZERO_STRUCT(io);
969 io.in.fname = fname;
970 io.in.durable_handle = h;
971 status = smb2_create(tree, mem_ctx, &io);
972 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
973
974 /*
975 * attempt with lease provided, but
976 * with a changed lease key. => fails
977 */
978 ZERO_STRUCT(io);
979 io.in.fname = fname;
980 io.in.durable_open = false;
981 io.in.durable_handle = h;
982 io.in.lease_request_v2 = &ls;
983 io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
984 /* a wrong lease key lets the request fail */
985 ls.lease_key.data[0]++;
986
987 status = smb2_create(tree, mem_ctx, &io);
988 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
989
990 /* restore the correct lease key */
991 ls.lease_key.data[0]--;
992
993 /*
994 * this last failing attempt is almost correct:
995 * only problem is: we use the wrong filename...
996 * Note that this gives INVALID_PARAMETER.
997 * This is different from oplocks!
998 */
999 ZERO_STRUCT(io);
1000 io.in.fname = "__non_existing_fname__";
1001 io.in.durable_open = false;
1002 io.in.durable_handle = h;
1003 io.in.lease_request_v2 = &ls;
1004 io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
1005
1006 status = smb2_create(tree, mem_ctx, &io);
1007 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
1008
1009 /*
1010 * Now for a succeeding reconnect:
1011 */
1012
1013 ZERO_STRUCT(io);
1014 io.in.fname = fname;
1015 io.in.durable_open = false;
1016 io.in.durable_handle = h;
1017 io.in.lease_request_v2 = &ls;
1018 io.in.oplock_level = SMB2_OPLOCK_LEVEL_LEASE;
1019
1020 /* the requested lease state is irrelevant */
1021 ls.lease_state = smb2_util_lease_state("");
1022
1023 h = NULL;
1024
1025 status = smb2_create(tree, mem_ctx, &io);
1026 CHECK_STATUS(status, NT_STATUS_OK);
1027
1028 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1029 CHECK_VAL(io.out.durable_open, false);
1030 CHECK_VAL(io.out.durable_open_v2, false); /* no dh2q response blob */
1031 CHECK_VAL(io.out.persistent_open, false);
1032 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1033 CHECK_VAL(io.out.lease_response_v2.lease_key.data[0], lease_key);
1034 CHECK_VAL(io.out.lease_response_v2.lease_key.data[1], ~lease_key);
1035 CHECK_VAL(io.out.lease_response_v2.lease_state,
1036 smb2_util_lease_state("RWH"));
1037 CHECK_VAL(io.out.lease_response_v2.lease_flags, 0);
1038 CHECK_VAL(io.out.lease_response_v2.lease_duration, 0);
1039 _h = io.out.file.handle;
1040 h = &_h;
1041
1042 /* disconnect one more time */
1043 TALLOC_FREE(tree);
1044
1045 if (!torture_smb2_connection_ext(tctx, 0, &options, &tree)) {
1046 torture_warning(tctx, "couldn't reconnect, bailing\n");
1047 ret = false;
1048 goto done;
1049 }
1050
1051 /*
1052 * demonstrate that various parameters are ignored
1053 * in the reconnect
1054 */
1055
1056 ZERO_STRUCT(io);
1057 /*
1058 * These are completely ignored by the server
1059 */
1060 io.in.security_flags = 0x78;
1061 io.in.oplock_level = 0x78;
1062 io.in.impersonation_level = 0x12345678;
1063 io.in.create_flags = 0x12345678;
1064 io.in.reserved = 0x12345678;
1065 io.in.desired_access = 0x12345678;
1066 io.in.file_attributes = 0x12345678;
1067 io.in.share_access = 0x12345678;
1068 io.in.create_disposition = 0x12345678;
1069 io.in.create_options = 0x12345678;
1070
1071 /*
1072 * only these are checked:
1073 * - io.in.fname
1074 * - io.in.durable_handle,
1075 * - io.in.lease_request->lease_key
1076 */
1077
1078 io.in.fname = fname;
1079 io.in.durable_open_v2 = false;
1080 io.in.durable_handle_v2 = h;
1081 io.in.lease_request_v2 = &ls;
1082
1083 /* the requested lease state is irrelevant */
1084 ls.lease_state = smb2_util_lease_state("");
1085
1086 h = NULL;
1087
1088 status = smb2_create(tree, mem_ctx, &io);
1089 CHECK_STATUS(status, NT_STATUS_OK);
1090
1091 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1092 CHECK_VAL(io.out.durable_open, false);
1093 CHECK_VAL(io.out.durable_open_v2, false); /* no dh2q response blob */
1094 CHECK_VAL(io.out.persistent_open, false);
1095 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1096 CHECK_VAL(io.out.lease_response_v2.lease_key.data[0], lease_key);
1097 CHECK_VAL(io.out.lease_response_v2.lease_key.data[1], ~lease_key);
1098 CHECK_VAL(io.out.lease_response_v2.lease_state,
1099 smb2_util_lease_state("RWH"));
1100 CHECK_VAL(io.out.lease_response_v2.lease_flags, 0);
1101 CHECK_VAL(io.out.lease_response_v2.lease_duration, 0);
1102
1103 _h = io.out.file.handle;
1104 h = &_h;
1105
1106 done:
1107 if (tree != NULL) {
1108 if (h != NULL) {
1109 smb2_util_close(tree, *h);
1110 }
1111
1112 smb2_util_unlink(tree, fname);
1113
1114 talloc_free(tree);
1115 }
1116
1117 talloc_free(mem_ctx);
1118
1119 return ret;
1120 }
1121
1122 /**
1123 * basic test for doing a durable open
1124 * tcp disconnect, reconnect with a session reconnect and
1125 * do a durable reopen (succeeds)
1126 */
1127 static bool test_durable_open_reopen2a(struct torture_context *tctx,
1128 struct smb2_tree *tree)
1129 {
1130 NTSTATUS status;
1131 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1132 char fname[256];
1133 struct smb2_handle _h;
1134 struct smb2_handle *h = NULL;
1135 struct smb2_create io1, io2;
1136 uint64_t previous_session_id;
1137 bool ret = true;
1138 struct smbcli_options options;
1139
1140 options = tree->session->transport->options;
1141
1142 /* Choose a random name in case the state is left a little funky. */
1143 snprintf(fname, 256, "durable_open_reopen2_%s.dat",
1144 generate_random_str(tctx, 8));
1145
1146 smb2_util_unlink(tree, fname);
1147
1148 smb2_oplock_create_share(&io1, fname,
1149 smb2_util_share_access(""),
1150 smb2_util_oplock_level("b"));
1151 io1.in.durable_open = true;
1152
1153 status = smb2_create(tree, mem_ctx, &io1);
1154 CHECK_STATUS(status, NT_STATUS_OK);
1155 _h = io1.out.file.handle;
1156 h = &_h;
1157 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1158 CHECK_VAL(io1.out.durable_open, true);
1159 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
1160
1161 /* disconnect, reconnect and then do durable reopen */
1162 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
1163 talloc_free(tree);
1164 tree = NULL;
1165
1166 if (!torture_smb2_connection_ext(tctx, previous_session_id,
1167 &options, &tree))
1168 {
1169 torture_warning(tctx, "couldn't reconnect, bailing\n");
1170 ret = false;
1171 goto done;
1172 }
1173
1174 ZERO_STRUCT(io2);
1175 io2.in.fname = fname;
1176 io2.in.durable_handle = h;
1177 h = NULL;
1178
1179 status = smb2_create(tree, mem_ctx, &io2);
1180 CHECK_STATUS(status, NT_STATUS_OK);
1181 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1182 CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));
1183 _h = io2.out.file.handle;
1184 h = &_h;
1185
1186 done:
1187 if (tree != NULL) {
1188 if (h != NULL) {
1189 smb2_util_close(tree, *h);
1190 }
1191
1192 smb2_util_unlink(tree, fname);
1193
1194 talloc_free(tree);
1195 }
1196
1197 talloc_free(mem_ctx);
1198
1199 return ret;
1200 }
1201
1202
1203 /**
1204 * basic test for doing a durable open:
1205 * tdis, new tcon, try durable reopen (fails)
1206 */
1207 static bool test_durable_open_reopen3(struct torture_context *tctx,
1208 struct smb2_tree *tree)
1209 {
1210 NTSTATUS status;
1211 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1212 char fname[256];
1213 struct smb2_handle _h;
1214 struct smb2_handle *h = NULL;
1215 struct smb2_create io1, io2;
1216 bool ret = true;
1217 struct smb2_tree *tree2;
1218
1219 /* Choose a random name in case the state is left a little funky. */
1220 snprintf(fname, 256, "durable_open_reopen3_%s.dat",
1221 generate_random_str(tctx, 8));
1222
1223 smb2_util_unlink(tree, fname);
1224
1225 smb2_oplock_create_share(&io1, fname,
1226 smb2_util_share_access(""),
1227 smb2_util_oplock_level("b"));
1228 io1.in.durable_open = true;
1229
1230 status = smb2_create(tree, mem_ctx, &io1);
1231 CHECK_STATUS(status, NT_STATUS_OK);
1232 _h = io1.out.file.handle;
1233 h = &_h;
1234 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1235 CHECK_VAL(io1.out.durable_open, true);
1236 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
1237
1238 /* disconnect, reconnect and then do durable reopen */
1239 status = smb2_tdis(tree);
1240 CHECK_STATUS(status, NT_STATUS_OK);
1241
1242 if (!torture_smb2_tree_connect(tctx, tree->session, mem_ctx, &tree2)) {
1243 torture_warning(tctx, "couldn't reconnect to share, bailing\n");
1244 ret = false;
1245 goto done;
1246 }
1247
1248
1249 ZERO_STRUCT(io2);
1250 io2.in.fname = fname;
1251 io2.in.durable_handle = h;
1252
1253 status = smb2_create(tree2, mem_ctx, &io2);
1254 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1255
1256 done:
1257 if (tree != NULL) {
1258 if (h != NULL) {
1259 smb2_util_close(tree, *h);
1260 }
1261
1262 smb2_util_unlink(tree2, fname);
1263
1264 talloc_free(tree);
1265 }
1266
1267 talloc_free(mem_ctx);
1268
1269 return ret;
1270 }
1271
1272 /**
1273 * basic test for doing a durable open:
1274 * logoff, create a new session, do a durable reopen (succeeds)
1275 */
1276 static bool test_durable_open_reopen4(struct torture_context *tctx,
1277 struct smb2_tree *tree)
1278 {
1279 NTSTATUS status;
1280 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1281 char fname[256];
1282 struct smb2_handle _h;
1283 struct smb2_handle *h = NULL;
1284 struct smb2_create io1, io2;
1285 bool ret = true;
1286 struct smb2_transport *transport;
1287 struct smb2_session *session2;
1288 struct smb2_tree *tree2;
1289
1290 /* Choose a random name in case the state is left a little funky. */
1291 snprintf(fname, 256, "durable_open_reopen4_%s.dat",
1292 generate_random_str(tctx, 8));
1293
1294 smb2_util_unlink(tree, fname);
1295
1296 smb2_oplock_create_share(&io1, fname,
1297 smb2_util_share_access(""),
1298 smb2_util_oplock_level("b"));
1299 io1.in.durable_open = true;
1300 io1.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
1301
1302 status = smb2_create(tree, mem_ctx, &io1);
1303 CHECK_STATUS(status, NT_STATUS_OK);
1304 _h = io1.out.file.handle;
1305 h = &_h;
1306 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1307 CHECK_VAL(io1.out.durable_open, true);
1308 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
1309
1310 /*
1311 * do a session logoff, establish a new session and tree
1312 * connect on the same transport, and try a durable reopen
1313 */
1314 transport = tree->session->transport;
1315 status = smb2_logoff(tree->session);
1316 CHECK_STATUS(status, NT_STATUS_OK);
1317
1318 if (!torture_smb2_session_setup(tctx, transport,
1319 0, /* previous_session_id */
1320 mem_ctx, &session2))
1321 {
1322 torture_warning(tctx, "session setup failed.\n");
1323 ret = false;
1324 goto done;
1325 }
1326
1327 /*
1328 * the session setup has talloc-stolen the transport,
1329 * so we can safely free the old tree+session for clarity
1330 */
1331 TALLOC_FREE(tree);
1332
1333 if (!torture_smb2_tree_connect(tctx, session2, mem_ctx, &tree2)) {
1334 torture_warning(tctx, "tree connect failed.\n");
1335 ret = false;
1336 goto done;
1337 }
1338
1339 ZERO_STRUCT(io2);
1340 io2.in.fname = fname;
1341 io2.in.durable_handle = h;
1342 h = NULL;
1343
1344 status = smb2_create(tree2, mem_ctx, &io2);
1345 CHECK_STATUS(status, NT_STATUS_OK);
1346
1347 _h = io2.out.file.handle;
1348 h = &_h;
1349 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1350 CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));
1351
1352 done:
1353 if (tree != NULL) {
1354 if (h != NULL) {
1355 smb2_util_close(tree2, *h);
1356 }
1357
1358 smb2_util_unlink(tree2, fname);
1359
1360 talloc_free(tree);
1361 }
1362
1363 talloc_free(mem_ctx);
1364
1365 return ret;
1366 }
1367
1368 static bool test_durable_open_delete_on_close1(struct torture_context *tctx,
1369 struct smb2_tree *tree)
1370 {
1371 NTSTATUS status;
1372 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1373 char fname[256];
1374 struct smb2_handle _h;
1375 struct smb2_handle *h = NULL;
1376 struct smb2_create io1, io2;
1377 bool ret = true;
1378 uint8_t b = 0;
1379
1380 /* Choose a random name in case the state is left a little funky. */
1381 snprintf(fname, 256, "durable_open_delete_on_close1_%s.dat",
1382 generate_random_str(tctx, 8));
1383
1384 smb2_util_unlink(tree, fname);
1385
1386 smb2_oplock_create_share(&io1, fname,
1387 smb2_util_share_access(""),
1388 smb2_util_oplock_level("b"));
1389 io1.in.durable_open = true;
1390 io1.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
1391
1392 status = smb2_create(tree, mem_ctx, &io1);
1393 CHECK_STATUS(status, NT_STATUS_OK);
1394 _h = io1.out.file.handle;
1395 h = &_h;
1396 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1397 CHECK_VAL(io1.out.durable_open, true);
1398 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
1399
1400 status = smb2_util_write(tree, *h, &b, 0, 1);
1401 CHECK_STATUS(status, NT_STATUS_OK);
1402
1403 /* disconnect, leaving the durable handle in place */
1404 TALLOC_FREE(tree);
1405
1406 if (!torture_smb2_connection(tctx, &tree)) {
1407 torture_warning(tctx, "could not reconnect, bailing\n");
1408 ret = false;
1409 goto done;
1410 }
1411
1412 /*
1413 * Open the file on the new connection again
1414 * and check that it has been newly created,
1415 * i.e. delete on close was effective on the disconnected handle.
1416 * Also check that the file is really empty,
1417 * the previously written byte gone.
1418 */
1419 smb2_oplock_create_share(&io2, fname,
1420 smb2_util_share_access(""),
1421 smb2_util_oplock_level("b"));
1422 io2.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
1423
1424 status = smb2_create(tree, mem_ctx, &io2);
1425 CHECK_STATUS(status, NT_STATUS_OK);
1426 _h = io2.out.file.handle;
1427 h = &_h;
1428 CHECK_CREATED_SIZE(&io2, CREATED, FILE_ATTRIBUTE_ARCHIVE, 0, 0);
1429 CHECK_VAL(io2.out.durable_open, false);
1430 CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));
1431
1432 done:
1433 if (tree != NULL) {
1434 if (h != NULL) {
1435 smb2_util_close(tree, *h);
1436 }
1437
1438 smb2_util_unlink(tree, fname);
1439
1440 talloc_free(tree);
1441 }
1442
1443 talloc_free(mem_ctx);
1444
1445 return ret;
1446 }
1447
1448
1449 static bool test_durable_open_delete_on_close2(struct torture_context *tctx,
1450 struct smb2_tree *tree)
1451 {
1452 NTSTATUS status;
1453 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1454 char fname[256];
1455 struct smb2_handle _h;
1456 struct smb2_handle *h = NULL;
1457 struct smb2_create io;
1458 bool ret = true;
1459 uint8_t b = 0;
1460 uint64_t previous_session_id;
1461 uint64_t alloc_size_step;
1462 struct smbcli_options options;
1463
1464 options = tree->session->transport->options;
1465
1466 /* Choose a random name in case the state is left a little funky. */
1467 snprintf(fname, 256, "durable_open_delete_on_close2_%s.dat",
1468 generate_random_str(tctx, 8));
1469
1470 smb2_util_unlink(tree, fname);
1471
1472 smb2_oplock_create_share(&io, fname,
1473 smb2_util_share_access(""),
1474 smb2_util_oplock_level("b"));
1475 io.in.durable_open = true;
1476 io.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
1477
1478 status = smb2_create(tree, mem_ctx, &io);
1479 CHECK_STATUS(status, NT_STATUS_OK);
1480 _h = io.out.file.handle;
1481 h = &_h;
1482 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1483 CHECK_VAL(io.out.durable_open, true);
1484 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
1485
1486 status = smb2_util_write(tree, *h, &b, 0, 1);
1487 CHECK_STATUS(status, NT_STATUS_OK);
1488
1489 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
1490
1491 /* disconnect, leaving the durable handle in place */
1492 TALLOC_FREE(tree);
1493
1494 if (!torture_smb2_connection_ext(tctx, previous_session_id,
1495 &options, &tree))
1496 {
1497 torture_warning(tctx, "could not reconnect, bailing\n");
1498 ret = false;
1499 goto done;
1500 }
1501
1502 ZERO_STRUCT(io);
1503 io.in.fname = fname;
1504 io.in.durable_handle = h;
1505
1506 status = smb2_create(tree, mem_ctx, &io);
1507 CHECK_STATUS(status, NT_STATUS_OK);
1508 _h = io.out.file.handle;
1509 h = &_h;
1510 alloc_size_step = io.out.alloc_size;
1511 CHECK_CREATED_SIZE(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE, alloc_size_step, 1);
1512 CHECK_VAL(io.out.durable_open, false);
1513 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
1514
1515 /* close the file, thereby deleting it */
1516 smb2_util_close(tree, *h);
1517 status = smb2_logoff(tree->session);
1518 TALLOC_FREE(tree);
1519
1520 if (!torture_smb2_connection(tctx, &tree)) {
1521 torture_warning(tctx, "could not reconnect, bailing\n");
1522 ret = false;
1523 goto done;
1524 }
1525
1526 /*
1527 * Open the file on the new connection again
1528 * and check that it has been newly created,
1529 * i.e. delete on close was effective on the reconnected handle.
1530 * Also check that the file is really empty,
1531 * the previously written byte gone.
1532 */
1533 smb2_oplock_create_share(&io, fname,
1534 smb2_util_share_access(""),
1535 smb2_util_oplock_level("b"));
1536 io.in.durable_open = true;
1537 io.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
1538
1539 status = smb2_create(tree, mem_ctx, &io);
1540 CHECK_STATUS(status, NT_STATUS_OK);
1541 _h = io.out.file.handle;
1542 h = &_h;
1543 CHECK_CREATED_SIZE(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE, 0, 0);
1544 CHECK_VAL(io.out.durable_open, true);
1545 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
1546
1547 done:
1548 if (tree != NULL) {
1549 if (h != NULL) {
1550 smb2_util_close(tree, *h);
1551 }
1552
1553 smb2_util_unlink(tree, fname);
1554
1555 talloc_free(tree);
1556 }
1557
1558 talloc_free(mem_ctx);
1559
1560 return ret;
1561 }
1562
1563 /*
1564 basic testing of SMB2 durable opens
1565 regarding the position information on the handle
1566 */
1567 static bool test_durable_open_file_position(struct torture_context *tctx,
1568 struct smb2_tree *tree)
1569 {
1570 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1571 struct smb2_handle h;
1572 struct smb2_create io;
1573 NTSTATUS status;
1574 const char *fname = "durable_open_position.dat";
1575 union smb_fileinfo qfinfo;
1576 union smb_setfileinfo sfinfo;
1577 bool ret = true;
1578 uint64_t pos;
1579 uint64_t previous_session_id;
1580 struct smbcli_options options;
1581
1582 options = tree->session->transport->options;
1583
1584 smb2_util_unlink(tree, fname);
1585
1586 smb2_oplock_create(&io, fname, SMB2_OPLOCK_LEVEL_BATCH);
1587 io.in.durable_open = true;
1588
1589 status = smb2_create(tree, mem_ctx, &io);
1590 CHECK_STATUS(status, NT_STATUS_OK);
1591 h = io.out.file.handle;
1592 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1593 CHECK_VAL(io.out.durable_open, true);
1594 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1595
1596 /* TODO: check extra blob content */
1597
1598 ZERO_STRUCT(qfinfo);
1599 qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
1600 qfinfo.generic.in.file.handle = h;
1601 status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);
1602 CHECK_STATUS(status, NT_STATUS_OK);
1603 CHECK_VAL(qfinfo.position_information.out.position, 0);
1604 pos = qfinfo.position_information.out.position;
1605 torture_comment(tctx, "position: %llu\n",
1606 (unsigned long long)pos);
1607
1608 ZERO_STRUCT(sfinfo);
1609 sfinfo.generic.level = RAW_SFILEINFO_POSITION_INFORMATION;
1610 sfinfo.generic.in.file.handle = h;
1611 sfinfo.position_information.in.position = 0x1000;
1612 status = smb2_setinfo_file(tree, &sfinfo);
1613 CHECK_STATUS(status, NT_STATUS_OK);
1614
1615 ZERO_STRUCT(qfinfo);
1616 qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
1617 qfinfo.generic.in.file.handle = h;
1618 status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);
1619 CHECK_STATUS(status, NT_STATUS_OK);
1620 CHECK_VAL(qfinfo.position_information.out.position, 0x1000);
1621 pos = qfinfo.position_information.out.position;
1622 torture_comment(tctx, "position: %llu\n",
1623 (unsigned long long)pos);
1624
1625 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
1626
1627 /* tcp disconnect */
1628 talloc_free(tree);
1629 tree = NULL;
1630
1631 /* do a session reconnect */
1632 if (!torture_smb2_connection_ext(tctx, previous_session_id,
1633 &options, &tree))
1634 {
1635 torture_warning(tctx, "couldn't reconnect, bailing\n");
1636 ret = false;
1637 goto done;
1638 }
1639
1640 ZERO_STRUCT(qfinfo);
1641 qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
1642 qfinfo.generic.in.file.handle = h;
1643 status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);
1644 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
1645
1646 ZERO_STRUCT(io);
1647 io.in.fname = fname;
1648 io.in.durable_handle = &h;
1649
1650 status = smb2_create(tree, mem_ctx, &io);
1651 CHECK_STATUS(status, NT_STATUS_OK);
1652 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1653 CHECK_VAL(io.out.reserved, 0x00);
1654 CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_EXISTED);
1655 CHECK_VAL(io.out.alloc_size, 0);
1656 CHECK_VAL(io.out.size, 0);
1657 CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
1658 CHECK_VAL(io.out.reserved2, 0);
1659
1660 h = io.out.file.handle;
1661
1662 ZERO_STRUCT(qfinfo);
1663 qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
1664 qfinfo.generic.in.file.handle = h;
1665 status = smb2_getinfo_file(tree, mem_ctx, &qfinfo);
1666 CHECK_STATUS(status, NT_STATUS_OK);
1667 CHECK_VAL(qfinfo.position_information.out.position, 0x1000);
1668 pos = qfinfo.position_information.out.position;
1669 torture_comment(tctx, "position: %llu\n",
1670 (unsigned long long)pos);
1671
1672 smb2_util_close(tree, h);
1673
1674 talloc_free(mem_ctx);
1675
1676 smb2_util_unlink(tree, fname);
1677
1678 done:
1679 talloc_free(tree);
1680
1681 return ret;
1682 }
1683
1684 /*
1685 Open, disconnect, oplock break, reconnect.
1686 */
1687 static bool test_durable_open_oplock(struct torture_context *tctx,
1688 struct smb2_tree *tree1,
1689 struct smb2_tree *tree2)
1690 {
1691 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1692 struct smb2_create io1, io2;
1693 struct smb2_handle h1, h2;
1694 NTSTATUS status;
1695 char fname[256];
1696 bool ret = true;
1697
1698 /* Choose a random name in case the state is left a little funky. */
1699 snprintf(fname, 256, "durable_open_oplock_%s.dat", generate_random_str(tctx, 8));
1700
1701 /* Clean slate */
1702 smb2_util_unlink(tree1, fname);
1703
1704 /* Create with batch oplock */
1705 smb2_oplock_create(&io1, fname, SMB2_OPLOCK_LEVEL_BATCH);
1706 io1.in.durable_open = true;
1707
1708 io2 = io1;
1709 io2.in.create_disposition = NTCREATEX_DISP_OPEN;
1710
1711 status = smb2_create(tree1, mem_ctx, &io1);
1712 CHECK_STATUS(status, NT_STATUS_OK);
1713 h1 = io1.out.file.handle;
1714 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1715 CHECK_VAL(io1.out.durable_open, true);
1716 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1717
1718 /* Disconnect after getting the batch */
1719 talloc_free(tree1);
1720 tree1 = NULL;
1721
1722 /*
1723 * Windows7 (build 7000) will break a batch oplock immediately if the
1724 * original client is gone. (ZML: This seems like a bug. It should give
1725 * some time for the client to reconnect!)
1726 */
1727 status = smb2_create(tree2, mem_ctx, &io2);
1728 CHECK_STATUS(status, NT_STATUS_OK);
1729 h2 = io2.out.file.handle;
1730 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1731 CHECK_VAL(io2.out.durable_open, true);
1732 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1733
1734 /* What if tree1 tries to come back and reclaim? */
1735 if (!torture_smb2_connection(tctx, &tree1)) {
1736 torture_warning(tctx, "couldn't reconnect, bailing\n");
1737 ret = false;
1738 goto done;
1739 }
1740
1741 ZERO_STRUCT(io1);
1742 io1.in.fname = fname;
1743 io1.in.durable_handle = &h1;
1744
1745 status = smb2_create(tree1, mem_ctx, &io1);
1746 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1747
1748 done:
1749 smb2_util_close(tree2, h2);
1750 smb2_util_unlink(tree2, fname);
1751
1752 talloc_free(tree1);
1753 talloc_free(tree2);
1754
1755 return ret;
1756 }
1757
1758 /*
1759 Open, disconnect, lease break, reconnect.
1760 */
1761 static bool test_durable_open_lease(struct torture_context *tctx,
1762 struct smb2_tree *tree1,
1763 struct smb2_tree *tree2)
1764 {
1765 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1766 struct smb2_create io1, io2;
1767 struct smb2_lease ls1, ls2;
1768 struct smb2_handle h1, h2;
1769 NTSTATUS status;
1770 char fname[256];
1771 bool ret = true;
1772 uint64_t lease1, lease2;
1773 uint32_t caps;
1774
1775 caps = smb2cli_conn_server_capabilities(tree1->session->transport->conn);
1776 if (!(caps & SMB2_CAP_LEASING)) {
1777 torture_skip(tctx, "leases are not supported");
1778 }
1779
1780 /*
1781 * Choose a random name and random lease in case the state is left a
1782 * little funky.
1783 */
1784 lease1 = random();
1785 lease2 = random();
1786 snprintf(fname, 256, "durable_open_lease_%s.dat", generate_random_str(tctx, 8));
1787
1788 /* Clean slate */
1789 smb2_util_unlink(tree1, fname);
1790
1791 /* Create with lease */
1792 smb2_lease_create(&io1, &ls1, false /* dir */, fname,
1793 lease1, smb2_util_lease_state("RHW"));
1794 io1.in.durable_open = true;
1795
1796 smb2_lease_create(&io2, &ls2, false /* dir */, fname,
1797 lease2, smb2_util_lease_state("RHW"));
1798 io2.in.durable_open = true;
1799 io2.in.create_disposition = NTCREATEX_DISP_OPEN;
1800
1801 status = smb2_create(tree1, mem_ctx, &io1);
1802 CHECK_STATUS(status, NT_STATUS_OK);
1803 h1 = io1.out.file.handle;
1804 CHECK_VAL(io1.out.durable_open, true);
1805 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1806
1807 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1808 CHECK_VAL(io1.out.lease_response.lease_key.data[0], lease1);
1809 CHECK_VAL(io1.out.lease_response.lease_key.data[1], ~lease1);
1810 CHECK_VAL(io1.out.lease_response.lease_state,
1811 SMB2_LEASE_READ|SMB2_LEASE_HANDLE|SMB2_LEASE_WRITE);
1812
1813 /* Disconnect after getting the lease */
1814 talloc_free(tree1);
1815 tree1 = NULL;
1816
1817 /*
1818 * Windows7 (build 7000) will grant an RH lease immediate (not an RHW?)
1819 * even if the original client is gone. (ZML: This seems like a bug. It
1820 * should give some time for the client to reconnect! And why RH?)
1821 *
1822 * obnox: Current windows 7 and w2k8r2 grant RHW instead of RH.
1823 * Test is adapted accordingly.
1824 */
1825 status = smb2_create(tree2, mem_ctx, &io2);
1826 CHECK_STATUS(status, NT_STATUS_OK);
1827 h2 = io2.out.file.handle;
1828 CHECK_VAL(io2.out.durable_open, true);
1829 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1830
1831 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1832 CHECK_VAL(io2.out.lease_response.lease_key.data[0], lease2);
1833 CHECK_VAL(io2.out.lease_response.lease_key.data[1], ~lease2);
1834 CHECK_VAL(io2.out.lease_response.lease_state,
1835 SMB2_LEASE_READ|SMB2_LEASE_HANDLE|SMB2_LEASE_WRITE);
1836
1837 /* What if tree1 tries to come back and reclaim? */
1838 if (!torture_smb2_connection(tctx, &tree1)) {
1839 torture_warning(tctx, "couldn't reconnect, bailing\n");
1840 ret = false;
1841 goto done;
1842 }
1843
1844 ZERO_STRUCT(io1);
1845 io1.in.fname = fname;
1846 io1.in.durable_handle = &h1;
1847 io1.in.lease_request = &ls1;
1848
1849 status = smb2_create(tree1, mem_ctx, &io1);
1850 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1851
1852 done:
1853 smb2_util_close(tree2, h2);
1854 smb2_util_unlink(tree2, fname);
1855
1856 talloc_free(tree1);
1857 talloc_free(tree2);
1858
1859 return ret;
1860 }
1861
1862 static bool test_durable_open_lock_oplock(struct torture_context *tctx,
1863 struct smb2_tree *tree)
1864 {
1865 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1866 struct smb2_create io;
1867 struct smb2_handle h;
1868 struct smb2_lock lck;
1869 struct smb2_lock_element el[2];
1870 NTSTATUS status;
1871 char fname[256];
1872 bool ret = true;
1873
1874 /*
1875 */
1876 snprintf(fname, 256, "durable_open_oplock_lock_%s.dat", generate_random_str(tctx, 8));
1877
1878 /* Clean slate */
1879 smb2_util_unlink(tree, fname);
1880
1881 /* Create with oplock */
1882
1883 smb2_oplock_create_share(&io, fname,
1884 smb2_util_share_access(""),
1885 smb2_util_oplock_level("b"));
1886 io.in.durable_open = true;
1887
1888 status = smb2_create(tree, mem_ctx, &io);
1889 CHECK_STATUS(status, NT_STATUS_OK);
1890 h = io.out.file.handle;
1891 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1892
1893 CHECK_VAL(io.out.durable_open, true);
1894 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
1895
1896 ZERO_STRUCT(lck);
1897 ZERO_STRUCT(el);
1898 lck.in.locks = el;
1899 lck.in.lock_count = 0x0001;
1900 lck.in.lock_sequence = 0x00000000;
1901 lck.in.file.handle = h;
1902 el[0].offset = 0;
1903 el[0].length = 1;
1904 el[0].reserved = 0x00000000;
1905 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
1906 status = smb2_lock(tree, &lck);
1907 CHECK_STATUS(status, NT_STATUS_OK);
1908
1909 /* Disconnect/Reconnect. */
1910 talloc_free(tree);
1911 tree = NULL;
1912
1913 if (!torture_smb2_connection(tctx, &tree)) {
1914 torture_warning(tctx, "couldn't reconnect, bailing\n");
1915 ret = false;
1916 goto done;
1917 }
1918
1919 ZERO_STRUCT(io);
1920 io.in.fname = fname;
1921 io.in.durable_handle = &h;
1922
1923 status = smb2_create(tree, mem_ctx, &io);
1924 CHECK_STATUS(status, NT_STATUS_OK);
1925 h = io.out.file.handle;
1926
1927 lck.in.file.handle = h;
1928 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
1929 status = smb2_lock(tree, &lck);
1930 CHECK_STATUS(status, NT_STATUS_OK);
1931
1932 done:
1933 smb2_util_close(tree, h);
1934 smb2_util_unlink(tree, fname);
1935 talloc_free(tree);
1936
1937 return ret;
1938 }
1939
1940 /*
1941 Open, take BRL, disconnect, reconnect.
1942 */
1943 static bool test_durable_open_lock_lease(struct torture_context *tctx,
1944 struct smb2_tree *tree)
1945 {
1946 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1947 struct smb2_create io;
1948 struct smb2_lease ls;
1949 struct smb2_handle h;
1950 struct smb2_lock lck;
1951 struct smb2_lock_element el[2];
1952 NTSTATUS status;
1953 char fname[256];
1954 bool ret = true;
1955 uint64_t lease;
1956 uint32_t caps;
1957 struct smbcli_options options;
1958
1959 options = tree->session->transport->options;
1960
1961 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1962 if (!(caps & SMB2_CAP_LEASING)) {
1963 torture_skip(tctx, "leases are not supported");
1964 }
1965
1966 /*
1967 * Choose a random name and random lease in case the state is left a
1968 * little funky.
1969 */
1970 lease = random();
1971 snprintf(fname, 256, "durable_open_lease_lock_%s.dat", generate_random_str(tctx, 8));
1972
1973 /* Clean slate */
1974 smb2_util_unlink(tree, fname);
1975
1976 /* Create with lease */
1977
1978 smb2_lease_create(&io, &ls, false /* dir */, fname, lease,
1979 smb2_util_lease_state("RWH"));
1980 io.in.durable_open = true;
1981
1982 status = smb2_create(tree, mem_ctx, &io);
1983 CHECK_STATUS(status, NT_STATUS_OK);
1984 h = io.out.file.handle;
1985 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1986
1987 CHECK_VAL(io.out.durable_open, true);
1988 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1989 CHECK_VAL(io.out.lease_response.lease_key.data[0], lease);
1990 CHECK_VAL(io.out.lease_response.lease_key.data[1], ~lease);
1991 CHECK_VAL(io.out.lease_response.lease_state,
1992 SMB2_LEASE_READ|SMB2_LEASE_HANDLE|SMB2_LEASE_WRITE);
1993
1994 ZERO_STRUCT(lck);
1995 ZERO_STRUCT(el);
1996 lck.in.locks = el;
1997 lck.in.lock_count = 0x0001;
1998 lck.in.lock_sequence = 0x00000000;
1999 lck.in.file.handle = h;
2000 el[0].offset = 0;
2001 el[0].length = 1;
2002 el[0].reserved = 0x00000000;
2003 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
2004 status = smb2_lock(tree, &lck);
2005 CHECK_STATUS(status, NT_STATUS_OK);
2006
2007 /* Disconnect/Reconnect. */
2008 talloc_free(tree);
2009 tree = NULL;
2010
2011 if (!torture_smb2_connection_ext(tctx, 0, &options, &tree)) {
2012 torture_warning(tctx, "couldn't reconnect, bailing\n");
2013 ret = false;
2014 goto done;
2015 }
2016
2017 ZERO_STRUCT(io);
2018 io.in.fname = fname;
2019 io.in.durable_handle = &h;
2020 io.in.lease_request = &ls;
2021
2022 status = smb2_create(tree, mem_ctx, &io);
2023 CHECK_STATUS(status, NT_STATUS_OK);
2024 h = io.out.file.handle;
2025
2026 lck.in.file.handle = h;
2027 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
2028 status = smb2_lock(tree, &lck);
2029 CHECK_STATUS(status, NT_STATUS_OK);
2030
2031 done:
2032 smb2_util_close(tree, h);
2033 smb2_util_unlink(tree, fname);
2034 talloc_free(tree);
2035
2036 return ret;
2037 }
2038
2039 /**
2040 * Open with a RH lease, disconnect, open in another tree, reconnect.
2041 *
2042 * This test actually demonstrates a minimum level of respect for the durable
2043 * open in the face of another open. As long as this test shows an inability to
2044 * reconnect after an open, the oplock/lease tests above will certainly
2045 * demonstrate an error on reconnect.
2046 */
2047 static bool test_durable_open_open2_lease(struct torture_context *tctx,
2048 struct smb2_tree *tree1,
2049 struct smb2_tree *tree2)
2050 {
2051 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2052 struct smb2_create io1, io2;
2053 struct smb2_lease ls;
2054 struct smb2_handle h1, h2;
2055 NTSTATUS status;
2056 char fname[256];
2057 bool ret = true;
2058 uint64_t lease;
2059 uint32_t caps;
2060 struct smbcli_options options;
2061
2062 options = tree1->session->transport->options;
2063
2064 caps = smb2cli_conn_server_capabilities(tree1->session->transport->conn);
2065 if (!(caps & SMB2_CAP_LEASING)) {
2066 torture_skip(tctx, "leases are not supported");
2067 }
2068
2069 /*
2070 * Choose a random name and random lease in case the state is left a
2071 * little funky.
2072 */
2073 lease = random();
2074 snprintf(fname, 256, "durable_open_open2_lease_%s.dat",
2075 generate_random_str(tctx, 8));
2076
2077 /* Clean slate */
2078 smb2_util_unlink(tree1, fname);
2079
2080 /* Create with lease */
2081 smb2_lease_create_share(&io1, &ls, false /* dir */, fname,
2082 smb2_util_share_access(""),
2083 lease,
2084 smb2_util_lease_state("RH"));
2085 io1.in.durable_open = true;
2086
2087 status = smb2_create(tree1, mem_ctx, &io1);
2088 CHECK_STATUS(status, NT_STATUS_OK);
2089 h1 = io1.out.file.handle;
2090 CHECK_VAL(io1.out.durable_open, true);
2091 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2092
2093 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
2094 CHECK_VAL(io1.out.lease_response.lease_key.data[0], lease);
2095 CHECK_VAL(io1.out.lease_response.lease_key.data[1], ~lease);
2096 CHECK_VAL(io1.out.lease_response.lease_state,
2097 smb2_util_lease_state("RH"));
2098
2099 /* Disconnect */
2100 talloc_free(tree1);
2101 tree1 = NULL;
2102
2103 /* Open the file in tree2 */
2104 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
2105
2106 status = smb2_create(tree2, mem_ctx, &io2);
2107 CHECK_STATUS(status, NT_STATUS_OK);
2108 h2 = io2.out.file.handle;
2109 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2110
2111 /* Reconnect */
2112 if (!torture_smb2_connection_ext(tctx, 0, &options, &tree1)) {
2113 torture_warning(tctx, "couldn't reconnect, bailing\n");
2114 ret = false;
2115 goto done;
2116 }
2117
2118 ZERO_STRUCT(io1);
2119 io1.in.fname = fname;
2120 io1.in.durable_handle = &h1;
2121 io1.in.lease_request = &ls;
2122
2123 /*
2124 * Windows7 (build 7000) will give away an open immediately if the
2125 * original client is gone. (ZML: This seems like a bug. It should give
2126 * some time for the client to reconnect!)
2127 */
2128 status = smb2_create(tree1, mem_ctx, &io1);
2129 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
2130 h1 = io1.out.file.handle;
2131
2132 done:
2133 smb2_util_close(tree2, h2);
2134 smb2_util_unlink(tree2, fname);
2135 smb2_util_close(tree1, h1);
2136 smb2_util_unlink(tree1, fname);
2137
2138 talloc_free(tree1);
2139 talloc_free(tree2);
2140
2141 return ret;
2142 }
2143
2144 /**
2145 * Open with a batch oplock, disconnect, open in another tree, reconnect.
2146 *
2147 * This test actually demonstrates a minimum level of respect for the durable
2148 * open in the face of another open. As long as this test shows an inability to
2149 * reconnect after an open, the oplock/lease tests above will certainly
2150 * demonstrate an error on reconnect.
2151 */
2152 static bool test_durable_open_open2_oplock(struct torture_context *tctx,
2153 struct smb2_tree *tree1,
2154 struct smb2_tree *tree2)
2155 {
2156 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2157 struct smb2_create io1, io2;
2158 struct smb2_handle h1, h2;
2159 NTSTATUS status;
2160 char fname[256];
2161 bool ret = true;
2162
2163 /*
2164 * Choose a random name and random lease in case the state is left a
2165 * little funky.
2166 */
2167 snprintf(fname, 256, "durable_open_open2_oplock_%s.dat",
2168 generate_random_str(tctx, 8));
2169
2170 /* Clean slate */
2171 smb2_util_unlink(tree1, fname);
2172
2173 /* Create with batch oplock */
2174 smb2_oplock_create(&io1, fname, SMB2_OPLOCK_LEVEL_BATCH);
2175 io1.in.durable_open = true;
2176
2177 status = smb2_create(tree1, mem_ctx, &io1);
2178 CHECK_STATUS(status, NT_STATUS_OK);
2179 h1 = io1.out.file.handle;
2180 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2181 CHECK_VAL(io1.out.durable_open, true);
2182 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2183
2184 /* Disconnect */
2185 talloc_free(tree1);
2186 tree1 = NULL;
2187
2188 /* Open the file in tree2 */
2189 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
2190
2191 status = smb2_create(tree2, mem_ctx, &io2);
2192 CHECK_STATUS(status, NT_STATUS_OK);
2193 h2 = io2.out.file.handle;
2194 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2195
2196 /* Reconnect */
2197 if (!torture_smb2_connection(tctx, &tree1)) {
2198 torture_warning(tctx, "couldn't reconnect, bailing\n");
2199 ret = false;
2200 goto done;
2201 }
2202
2203 ZERO_STRUCT(io1);
2204 io1.in.fname = fname;
2205 io1.in.durable_handle = &h1;
2206
2207 status = smb2_create(tree1, mem_ctx, &io1);
2208 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
2209 h1 = io1.out.file.handle;
2210
2211 done:
2212 smb2_util_close(tree2, h2);
2213 smb2_util_unlink(tree2, fname);
2214 if (tree1 != NULL) {
2215 smb2_util_close(tree1, h1);
2216 smb2_util_unlink(tree1, fname);
2217 }
2218
2219 talloc_free(tree1);
2220 talloc_free(tree2);
2221
2222 return ret;
2223 }
2224
2225 /**
2226 * test behaviour with initial allocation size
2227 */
2228 static bool test_durable_open_alloc_size(struct torture_context *tctx,
2229 struct smb2_tree *tree)
2230 {
2231 NTSTATUS status;
2232 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2233 char fname[256];
2234 struct smb2_handle _h;
2235 struct smb2_handle *h = NULL;
2236 struct smb2_create io;
2237 bool ret = true;
2238 uint64_t previous_session_id;
2239 uint64_t alloc_size_step;
2240 uint64_t initial_alloc_size = 0x100;
2241 const uint8_t *b = NULL;
2242 struct smbcli_options options;
2243
2244 options = tree->session->transport->options;
2245
2246 /* Choose a random name in case the state is left a little funky. */
2247 snprintf(fname, 256, "durable_open_alloc_size_%s.dat",
2248 generate_random_str(tctx, 8));
2249
2250 smb2_util_unlink(tree, fname);
2251
2252 smb2_oplock_create_share(&io, fname,
2253 smb2_util_share_access(""),
2254 smb2_util_oplock_level("b"));
2255 io.in.durable_open = true;
2256 io.in.alloc_size = initial_alloc_size;
2257
2258 status = smb2_create(tree, mem_ctx, &io);
2259 CHECK_STATUS(status, NT_STATUS_OK);
2260 _h = io.out.file.handle;
2261 h = &_h;
2262 CHECK_NOT_VAL(io.out.alloc_size, 0);
2263 alloc_size_step = io.out.alloc_size;
2264 CHECK_CREATED_SIZE(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE,
2265 alloc_size_step, 0);
2266 CHECK_VAL(io.out.durable_open, true);
2267 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
2268
2269 /* prepare buffer */
2270 b = talloc_zero_size(mem_ctx, alloc_size_step);
2271 CHECK_NOT_VAL(b, NULL);
2272
2273 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
2274
2275 /* disconnect, reconnect and then do durable reopen */
2276 talloc_free(tree);
2277 tree = NULL;
2278
2279 if (!torture_smb2_connection_ext(tctx, previous_session_id,
2280 &options, &tree))
2281 {
2282 torture_warning(tctx, "couldn't reconnect, bailing\n");
2283 ret = false;
2284 goto done;
2285 }
2286
2287 ZERO_STRUCT(io);
2288 io.in.fname = fname;
2289 io.in.durable_handle = h;
2290 h = NULL;
2291
2292 status = smb2_create(tree, mem_ctx, &io);
2293 CHECK_STATUS(status, NT_STATUS_OK);
2294 CHECK_CREATED_SIZE(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE,
2295 alloc_size_step, 0);
2296 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
2297 _h = io.out.file.handle;
2298 h = &_h;
2299
2300 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
2301
2302 /* write one byte */
2303 status = smb2_util_write(tree, *h, b, 0, 1);
2304 CHECK_STATUS(status, NT_STATUS_OK);
2305
2306 /* disconnect, reconnect and then do durable reopen */
2307 talloc_free(tree);
2308 tree = NULL;
2309
2310 if (!torture_smb2_connection_ext(tctx, previous_session_id,
2311 &options, &tree))
2312 {
2313 torture_warning(tctx, "couldn't reconnect, bailing\n");
2314 ret = false;
2315 goto done;
2316 }
2317
2318 ZERO_STRUCT(io);
2319 io.in.fname = fname;
2320 io.in.durable_handle = h;
2321 h = NULL;
2322
2323 status = smb2_create(tree, mem_ctx, &io);
2324 CHECK_STATUS(status, NT_STATUS_OK);
2325 CHECK_CREATED_SIZE(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE,
2326 alloc_size_step, 1);
2327 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
2328 _h = io.out.file.handle;
2329 h = &_h;
2330
2331 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
2332
2333 /* write more byte than initial allocation size */
2334 status = smb2_util_write(tree, *h, b, 1, alloc_size_step);
2335
2336 /* disconnect, reconnect and then do durable reopen */
2337 talloc_free(tree);
2338 tree = NULL;
2339
2340 if (!torture_smb2_connection_ext(tctx, previous_session_id,
2341 &options, &tree))
2342 {
2343 torture_warning(tctx, "couldn't reconnect, bailing\n");
2344 ret = false;
2345 goto done;
2346 }
2347
2348 ZERO_STRUCT(io);
2349 io.in.fname = fname;
2350 io.in.durable_handle = h;
2351 h = NULL;
2352
2353 status = smb2_create(tree, mem_ctx, &io);
2354 CHECK_STATUS(status, NT_STATUS_OK);
2355 CHECK_CREATED_SIZE(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE,
2356 alloc_size_step * 2, alloc_size_step + 1);
2357 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
2358 _h = io.out.file.handle;
2359 h = &_h;
2360
2361 done:
2362 if (h != NULL) {
2363 smb2_util_close(tree, *h);
2364 }
2365
2366 smb2_util_unlink(tree, fname);
2367
2368 talloc_free(tree);
2369
2370 talloc_free(mem_ctx);
2371
2372 return ret;
2373 }
2374
2375 /**
2376 * test behaviour when a disconnect happens while creating a read-only file
2377 */
2378 static bool test_durable_open_read_only(struct torture_context *tctx,
2379 struct smb2_tree *tree)
2380 {
2381 NTSTATUS status;
2382 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2383 char fname[256];
2384 struct smb2_handle _h;
2385 struct smb2_handle *h = NULL;
2386 struct smb2_create io;
2387 bool ret = true;
2388 uint64_t previous_session_id;
2389 const uint8_t b = 0;
2390 uint64_t alloc_size = 0;
2391 struct smbcli_options options;
2392
2393 options = tree->session->transport->options;
2394
2395 /* Choose a random name in case the state is left a little funky. */
2396 snprintf(fname, 256, "durable_open_initial_alloc_%s.dat",
2397 generate_random_str(tctx, 8));
2398
2399 smb2_util_unlink(tree, fname);
2400
2401 smb2_oplock_create_share(&io, fname,
2402 smb2_util_share_access(""),
2403 smb2_util_oplock_level("b"));
2404 io.in.durable_open = true;
2405 io.in.file_attributes = FILE_ATTRIBUTE_READONLY;
2406
2407 status = smb2_create(tree, mem_ctx, &io);
2408 CHECK_STATUS(status, NT_STATUS_OK);
2409 _h = io.out.file.handle;
2410 h = &_h;
2411 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_ARCHIVE);
2412 CHECK_VAL(io.out.durable_open, true);
2413 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
2414
2415 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
2416
2417 /* write one byte */
2418 status = smb2_util_write(tree, *h, &b, 0, 1);
2419 CHECK_STATUS(status, NT_STATUS_OK);
2420
2421 /* disconnect, reconnect and then do durable reopen */
2422 talloc_free(tree);
2423 tree = NULL;
2424
2425 if (!torture_smb2_connection_ext(tctx, previous_session_id,
2426 &options, &tree))
2427 {
2428 torture_warning(tctx, "couldn't reconnect, bailing\n");
2429 ret = false;
2430 goto done;
2431 }
2432
2433 ZERO_STRUCT(io);
2434 io.in.fname = fname;
2435 io.in.durable_handle = h;
2436 h = NULL;
2437
2438 status = smb2_create(tree, mem_ctx, &io);
2439 CHECK_STATUS(status, NT_STATUS_OK);
2440 alloc_size = io.out.alloc_size;
2441 CHECK_CREATED_SIZE(&io, EXISTED,
2442 FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_ARCHIVE,
2443 alloc_size, 1);
2444 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
2445 _h = io.out.file.handle;
2446 h = &_h;
2447
2448 /* write one byte */
2449 status = smb2_util_write(tree, *h, &b, 1, 1);
2450 CHECK_STATUS(status, NT_STATUS_OK);
2451
2452 done:
2453 if (h != NULL) {
2454 union smb_setfileinfo sfinfo;
2455
2456 ZERO_STRUCT(sfinfo);
2457 sfinfo.basic_info.level = RAW_SFILEINFO_BASIC_INFORMATION;
2458 sfinfo.basic_info.in.file.handle = *h;
2459 sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_NORMAL;
2460 smb2_setinfo_file(tree, &sfinfo);
2461
2462 smb2_util_close(tree, *h);
2463 }
2464
2465 smb2_util_unlink(tree, fname);
2466
2467 talloc_free(tree);
2468
2469 talloc_free(mem_ctx);
2470
2471 return ret;
2472 }
2473
2474 /**
2475 * durable open with oplock, disconnect, exit
2476 */
2477 static bool test_durable_open_oplock_disconnect(struct torture_context *tctx,
2478 struct smb2_tree *tree)
2479 {
2480 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2481 struct smb2_create io;
2482 struct smb2_handle _h;
2483 struct smb2_handle *h = NULL;
2484 NTSTATUS status;
2485 char fname[256];
2486 bool ret = true;
2487
2488 snprintf(fname, 256, "durable_open_oplock_disconnect_%s.dat",
2489 generate_random_str(mem_ctx, 8));
2490
2491 smb2_util_unlink(tree, fname);
2492
2493 smb2_oplock_create(&io, fname, SMB2_OPLOCK_LEVEL_BATCH);
2494 io.in.durable_open = true;
2495
2496 status = smb2_create(tree, mem_ctx, &io);
2497 CHECK_STATUS(status, NT_STATUS_OK);
2498
2499 _h = io.out.file.handle;
2500 h = &_h;
2501
2502 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2503 CHECK_VAL(io.out.durable_open, true);
2504 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
2505
2506 /* disconnect */
2507 talloc_free(tree);
2508 tree = NULL;
2509
2510 done:
2511 if (tree != NULL) {
2512 if (h != NULL) {
2513 smb2_util_close(tree, *h);
2514 }
2515 smb2_util_unlink(tree, fname);
2516 }
2517 talloc_free(mem_ctx);
2518 return ret;
2519 }
2520
2521
2522 struct torture_suite *torture_smb2_durable_open_init(void)
2523 {
2524 struct torture_suite *suite =
2525 torture_suite_create(talloc_autofree_context(), "durable-open");
2526
2527 torture_suite_add_1smb2_test(suite, "open-oplock", test_durable_open_open_oplock);
2528 torture_suite_add_1smb2_test(suite, "open-lease", test_durable_open_open_lease);
2529 torture_suite_add_1smb2_test(suite, "reopen1", test_durable_open_reopen1);
2530 torture_suite_add_1smb2_test(suite, "reopen1a", test_durable_open_reopen1a);
2531 torture_suite_add_1smb2_test(suite, "reopen2", test_durable_open_reopen2);
2532 torture_suite_add_1smb2_test(suite, "reopen2-lease", test_durable_open_reopen2_lease);
2533 torture_suite_add_1smb2_test(suite, "reopen2-lease-v2", test_durable_open_reopen2_lease_v2);
2534 torture_suite_add_1smb2_test(suite, "reopen2a", test_durable_open_reopen2a);
2535 torture_suite_add_1smb2_test(suite, "reopen3", test_durable_open_reopen3);
2536 torture_suite_add_1smb2_test(suite, "reopen4", test_durable_open_reopen4);
2537 torture_suite_add_1smb2_test(suite, "delete_on_close1",
2538 test_durable_open_delete_on_close1);
2539 torture_suite_add_1smb2_test(suite, "delete_on_close2",
2540 test_durable_open_delete_on_close2);
2541 torture_suite_add_1smb2_test(suite, "file-position",
2542 test_durable_open_file_position);
2543 torture_suite_add_2smb2_test(suite, "oplock", test_durable_open_oplock);
2544 torture_suite_add_2smb2_test(suite, "lease", test_durable_open_lease);
2545 torture_suite_add_1smb2_test(suite, "lock-oplock", test_durable_open_lock_oplock);
2546 torture_suite_add_1smb2_test(suite, "lock-lease", test_durable_open_lock_lease);
2547 torture_suite_add_2smb2_test(suite, "open2-lease",
2548 test_durable_open_open2_lease);
2549 torture_suite_add_2smb2_test(suite, "open2-oplock",
2550 test_durable_open_open2_oplock);
2551 torture_suite_add_1smb2_test(suite, "alloc-size",
2552 test_durable_open_alloc_size);
2553 torture_suite_add_1smb2_test(suite, "read-only",
2554 test_durable_open_read_only);
2555
2556 suite->description = talloc_strdup(suite, "SMB2-DURABLE-OPEN tests");
2557
2558 return suite;
2559 }
2560
2561 struct torture_suite *torture_smb2_durable_open_disconnect_init(void)
2562 {
2563 struct torture_suite *suite =
2564 torture_suite_create(talloc_autofree_context(),
2565 "durable-open-disconnect");
2566
2567 torture_suite_add_1smb2_test(suite, "open-oplock-disconnect",
2568 test_durable_open_oplock_disconnect);
2569
2570 suite->description = talloc_strdup(suite,
2571 "SMB2-DURABLE-OPEN-DISCONNECT tests");
2572
2573 return suite;
2574 }
Samba GIT mirror