2 Unix SMB/CIFS implementation.
4 test suite for SMB2 durable opens
6 Copyright (C) Stefan Metzmacher 2008
7 Copyright (C) Michael Adam 2011-2012
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.
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.
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/>.
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"
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); \
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); \
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)); \
53 #define CHECK_CREATED(__io, __created, __attribute) \
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); \
62 #define CHECK_CREATED_SIZE(__io, __created, __attribute, __alloc_size, __size) \
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); \
74 * basic durable_open test.
75 * durable state should only be granted when requested
76 * along with a batch oplock or a handle lease.
78 * This test tests durable open with all possible oplock types.
81 struct durable_open_vs_oplock
{
83 const char *share_mode
;
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
] =
105 { "s", "RD", false },
106 { "s", "RW", false },
107 { "s", "WD", false },
108 { "s", "RWD", false },
114 { "x", "RD", false },
115 { "x", "RW", false },
116 { "x", "WD", false },
117 { "x", "RWD", false },
126 { "b", "RWD", true },
129 static bool test_one_durable_open_open_oplock(struct torture_context
*tctx
,
130 struct smb2_tree
*tree
,
132 struct durable_open_vs_oplock test
)
135 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
136 struct smb2_handle _h
;
137 struct smb2_handle
*h
= NULL
;
139 struct smb2_create io
;
141 smb2_util_unlink(tree
, fname
);
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;
148 status
= smb2_create(tree
, mem_ctx
, &io
);
149 CHECK_STATUS(status
, NT_STATUS_OK
);
150 _h
= io
.out
.file
.handle
;
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
));
158 smb2_util_close(tree
, *h
);
160 smb2_util_unlink(tree
, fname
);
161 talloc_free(mem_ctx
);
166 bool test_durable_open_open_oplock(struct torture_context
*tctx
,
167 struct smb2_tree
*tree
)
169 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
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));
177 smb2_util_unlink(tree
, fname
);
179 /* test various oplock levels with durable open */
181 for (i
= 0; i
< NUM_OPLOCK_OPEN_TESTS
; i
++) {
182 ret
= test_one_durable_open_open_oplock(tctx
,
185 durable_open_vs_oplock_table
[i
]);
192 smb2_util_unlink(tree
, fname
);
194 talloc_free(mem_ctx
);
200 * basic durable_open test.
201 * durable state should only be granted when requested
202 * along with a batch oplock or a handle lease.
204 * This test tests durable open with all valid lease types.
207 struct durable_open_vs_lease
{
209 const char *share_mode
;
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
] =
224 { "", "RWD", false },
230 { "R", "RW", false },
231 { "R", "RD", false },
232 { "R", "DW", false },
233 { "R", "RWD", 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 },
248 { "RH", "RW", true },
249 { "RH", "RD", true },
250 { "RH", "WD", true },
251 { "RH", "RWD", 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 },
263 static bool test_one_durable_open_open_lease(struct torture_context
*tctx
,
264 struct smb2_tree
*tree
,
266 struct durable_open_vs_lease test
)
269 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
270 struct smb2_handle _h
;
271 struct smb2_handle
*h
= NULL
;
273 struct smb2_create io
;
274 struct smb2_lease ls
;
278 caps
= smb2cli_conn_server_capabilities(tree
->session
->transport
->conn
);
279 if (!(caps
& SMB2_CAP_LEASING
)) {
280 torture_skip(tctx
, "leases are not supported");
283 smb2_util_unlink(tree
, fname
);
287 smb2_lease_create_share(&io
, &ls
, false /* dir */, fname
,
288 smb2_util_share_access(test
.share_mode
),
290 smb2_util_lease_state(test
.type
));
291 io
.in
.durable_open
= true;
293 status
= smb2_create(tree
, mem_ctx
, &io
);
294 CHECK_STATUS(status
, NT_STATUS_OK
);
295 _h
= io
.out
.file
.handle
;
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
));
306 smb2_util_close(tree
, *h
);
308 smb2_util_unlink(tree
, fname
);
309 talloc_free(mem_ctx
);
314 bool test_durable_open_open_lease(struct torture_context
*tctx
,
315 struct smb2_tree
*tree
)
317 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
323 caps
= smb2cli_conn_server_capabilities(tree
->session
->transport
->conn
);
324 if (!(caps
& SMB2_CAP_LEASING
)) {
325 torture_skip(tctx
, "leases are not supported");
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));
331 smb2_util_unlink(tree
, fname
);
334 /* test various oplock levels with durable open */
336 for (i
= 0; i
< NUM_LEASE_OPEN_TESTS
; i
++) {
337 ret
= test_one_durable_open_open_lease(tctx
,
340 durable_open_vs_lease_table
[i
]);
347 smb2_util_unlink(tree
, fname
);
349 talloc_free(mem_ctx
);
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)
359 bool test_durable_open_reopen1(struct torture_context
*tctx
,
360 struct smb2_tree
*tree
)
363 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
365 struct smb2_handle _h
;
366 struct smb2_handle
*h
= NULL
;
367 struct smb2_create io1
, io2
;
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));
374 smb2_util_unlink(tree
, fname
);
376 smb2_oplock_create_share(&io1
, fname
,
377 smb2_util_share_access(""),
378 smb2_util_oplock_level("b"));
379 io1
.in
.durable_open
= true;
381 status
= smb2_create(tree
, mem_ctx
, &io1
);
382 CHECK_STATUS(status
, NT_STATUS_OK
);
383 _h
= io1
.out
.file
.handle
;
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"));
389 /* try a durable reconnect while the file is still open */
391 io2
.in
.fname
= fname
;
392 io2
.in
.durable_handle
= h
;
394 status
= smb2_create(tree
, mem_ctx
, &io2
);
395 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
399 smb2_util_close(tree
, *h
);
402 smb2_util_unlink(tree
, fname
);
406 talloc_free(mem_ctx
);
412 * basic test for doing a durable open
413 * tcp disconnect, reconnect, do a durable reopen (succeeds)
415 bool test_durable_open_reopen2(struct torture_context
*tctx
,
416 struct smb2_tree
*tree
)
419 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
421 struct smb2_handle _h
;
422 struct smb2_handle
*h
= NULL
;
423 struct smb2_create io1
, io2
;
426 /* Choose a random name in case the state is left a little funky. */
427 snprintf(fname
, 256, "durable_open_reopen2_%s.dat",
428 generate_random_str(tctx
, 8));
430 smb2_util_unlink(tree
, fname
);
432 smb2_oplock_create_share(&io1
, fname
,
433 smb2_util_share_access(""),
434 smb2_util_oplock_level("b"));
435 io1
.in
.durable_open
= true;
437 status
= smb2_create(tree
, mem_ctx
, &io1
);
438 CHECK_STATUS(status
, NT_STATUS_OK
);
439 _h
= io1
.out
.file
.handle
;
441 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
442 CHECK_VAL(io1
.out
.durable_open
, true);
443 CHECK_VAL(io1
.out
.oplock_level
, smb2_util_oplock_level("b"));
445 /* disconnect, reconnect and then do durable reopen */
449 if (!torture_smb2_connection(tctx
, &tree
)) {
450 torture_warning(tctx
, "couldn't reconnect, bailing\n");
456 /* the path name is ignored by the server */
457 io2
.in
.fname
= "__non_existing_fname__";
458 io2
.in
.durable_handle
= h
;
461 status
= smb2_create(tree
, mem_ctx
, &io2
);
462 CHECK_STATUS(status
, NT_STATUS_OK
);
463 CHECK_CREATED(&io2
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
);
464 CHECK_VAL(io2
.out
.oplock_level
, smb2_util_oplock_level("b"));
465 _h
= io2
.out
.file
.handle
;
470 smb2_util_close(tree
, *h
);
473 smb2_util_unlink(tree
, fname
);
477 talloc_free(mem_ctx
);
483 * basic test for doing a durable open
484 * tcp disconnect, reconnect with a session reconnect and
485 * do a durable reopen (succeeds)
487 bool test_durable_open_reopen2a(struct torture_context
*tctx
,
488 struct smb2_tree
*tree
)
491 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
493 struct smb2_handle _h
;
494 struct smb2_handle
*h
= NULL
;
495 struct smb2_create io1
, io2
;
496 uint64_t previous_session_id
;
499 /* Choose a random name in case the state is left a little funky. */
500 snprintf(fname
, 256, "durable_open_reopen2_%s.dat",
501 generate_random_str(tctx
, 8));
503 smb2_util_unlink(tree
, fname
);
505 smb2_oplock_create_share(&io1
, fname
,
506 smb2_util_share_access(""),
507 smb2_util_oplock_level("b"));
508 io1
.in
.durable_open
= true;
510 status
= smb2_create(tree
, mem_ctx
, &io1
);
511 CHECK_STATUS(status
, NT_STATUS_OK
);
512 _h
= io1
.out
.file
.handle
;
514 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
515 CHECK_VAL(io1
.out
.durable_open
, true);
516 CHECK_VAL(io1
.out
.oplock_level
, smb2_util_oplock_level("b"));
518 /* disconnect, reconnect and then do durable reopen */
519 previous_session_id
= smb2cli_session_current_id(tree
->session
->smbXcli
);
523 if (!torture_smb2_connection_ext(tctx
, previous_session_id
, &tree
)) {
524 torture_warning(tctx
, "couldn't reconnect, bailing\n");
530 io2
.in
.fname
= fname
;
531 io2
.in
.durable_handle
= h
;
534 status
= smb2_create(tree
, mem_ctx
, &io2
);
535 CHECK_STATUS(status
, NT_STATUS_OK
);
536 CHECK_CREATED(&io2
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
);
537 CHECK_VAL(io2
.out
.oplock_level
, smb2_util_oplock_level("b"));
538 _h
= io2
.out
.file
.handle
;
543 smb2_util_close(tree
, *h
);
546 smb2_util_unlink(tree
, fname
);
550 talloc_free(mem_ctx
);
557 * basic test for doing a durable open:
558 * tdis, new tcon, try durable reopen (fails)
560 bool test_durable_open_reopen3(struct torture_context
*tctx
,
561 struct smb2_tree
*tree
)
564 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
566 struct smb2_handle _h
;
567 struct smb2_handle
*h
= NULL
;
568 struct smb2_create io1
, io2
;
570 struct smb2_tree
*tree2
;
572 /* Choose a random name in case the state is left a little funky. */
573 snprintf(fname
, 256, "durable_open_reopen3_%s.dat",
574 generate_random_str(tctx
, 8));
576 smb2_util_unlink(tree
, fname
);
578 smb2_oplock_create_share(&io1
, fname
,
579 smb2_util_share_access(""),
580 smb2_util_oplock_level("b"));
581 io1
.in
.durable_open
= true;
583 status
= smb2_create(tree
, mem_ctx
, &io1
);
584 CHECK_STATUS(status
, NT_STATUS_OK
);
585 _h
= io1
.out
.file
.handle
;
587 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
588 CHECK_VAL(io1
.out
.durable_open
, true);
589 CHECK_VAL(io1
.out
.oplock_level
, smb2_util_oplock_level("b"));
591 /* disconnect, reconnect and then do durable reopen */
592 status
= smb2_tdis(tree
);
593 CHECK_STATUS(status
, NT_STATUS_OK
);
595 if (!torture_smb2_tree_connect(tctx
, tree
->session
, mem_ctx
, &tree2
)) {
596 torture_warning(tctx
, "couldn't reconnect to share, bailing\n");
603 io2
.in
.fname
= fname
;
604 io2
.in
.durable_handle
= h
;
606 status
= smb2_create(tree2
, mem_ctx
, &io2
);
607 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
611 smb2_util_close(tree
, *h
);
614 smb2_util_unlink(tree2
, fname
);
618 talloc_free(mem_ctx
);
624 * basic test for doing a durable open:
625 * logoff, create a new session, do a durable reopen (succeeds)
627 bool test_durable_open_reopen4(struct torture_context
*tctx
,
628 struct smb2_tree
*tree
)
631 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
633 struct smb2_handle _h
;
634 struct smb2_handle
*h
= NULL
;
635 struct smb2_create io1
, io2
;
637 struct smb2_transport
*transport
;
638 struct smb2_session
*session2
;
639 struct smb2_tree
*tree2
;
641 /* Choose a random name in case the state is left a little funky. */
642 snprintf(fname
, 256, "durable_open_reopen4_%s.dat",
643 generate_random_str(tctx
, 8));
645 smb2_util_unlink(tree
, fname
);
647 smb2_oplock_create_share(&io1
, fname
,
648 smb2_util_share_access(""),
649 smb2_util_oplock_level("b"));
650 io1
.in
.durable_open
= true;
651 io1
.in
.create_options
|= NTCREATEX_OPTIONS_DELETE_ON_CLOSE
;
653 status
= smb2_create(tree
, mem_ctx
, &io1
);
654 CHECK_STATUS(status
, NT_STATUS_OK
);
655 _h
= io1
.out
.file
.handle
;
657 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
658 CHECK_VAL(io1
.out
.durable_open
, true);
659 CHECK_VAL(io1
.out
.oplock_level
, smb2_util_oplock_level("b"));
662 * do a session logoff, establish a new session and tree
663 * connect on the same transport, and try a durable reopen
665 transport
= tree
->session
->transport
;
666 status
= smb2_logoff(tree
->session
);
667 CHECK_STATUS(status
, NT_STATUS_OK
);
669 if (!torture_smb2_session_setup(tctx
, transport
,
670 0, /* previous_session_id */
673 torture_warning(tctx
, "session setup failed.\n");
679 * the session setup has talloc-stolen the transport,
680 * so we can safely free the old tree+session for clarity
684 if (!torture_smb2_tree_connect(tctx
, session2
, mem_ctx
, &tree2
)) {
685 torture_warning(tctx
, "tree connect failed.\n");
691 io2
.in
.fname
= fname
;
692 io2
.in
.durable_handle
= h
;
695 status
= smb2_create(tree2
, mem_ctx
, &io2
);
696 CHECK_STATUS(status
, NT_STATUS_OK
);
698 _h
= io2
.out
.file
.handle
;
700 CHECK_CREATED(&io2
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
);
701 CHECK_VAL(io2
.out
.oplock_level
, smb2_util_oplock_level("b"));
705 smb2_util_close(tree2
, *h
);
708 smb2_util_unlink(tree2
, fname
);
712 talloc_free(mem_ctx
);
717 bool test_durable_open_delete_on_close1(struct torture_context
*tctx
,
718 struct smb2_tree
*tree
)
721 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
723 struct smb2_handle _h
;
724 struct smb2_handle
*h
= NULL
;
725 struct smb2_create io1
, io2
;
729 /* Choose a random name in case the state is left a little funky. */
730 snprintf(fname
, 256, "durable_open_delete_on_close1_%s.dat",
731 generate_random_str(tctx
, 8));
733 smb2_util_unlink(tree
, fname
);
735 smb2_oplock_create_share(&io1
, fname
,
736 smb2_util_share_access(""),
737 smb2_util_oplock_level("b"));
738 io1
.in
.durable_open
= true;
739 io1
.in
.create_options
|= NTCREATEX_OPTIONS_DELETE_ON_CLOSE
;
741 status
= smb2_create(tree
, mem_ctx
, &io1
);
742 CHECK_STATUS(status
, NT_STATUS_OK
);
743 _h
= io1
.out
.file
.handle
;
745 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
746 CHECK_VAL(io1
.out
.durable_open
, true);
747 CHECK_VAL(io1
.out
.oplock_level
, smb2_util_oplock_level("b"));
749 status
= smb2_util_write(tree
, *h
, &b
, 0, 1);
750 CHECK_STATUS(status
, NT_STATUS_OK
);
752 /* disconnect, leaving the durable handle in place */
755 if (!torture_smb2_connection(tctx
, &tree
)) {
756 torture_warning(tctx
, "could not reconnect, bailing\n");
762 * Open the file on the new connection again
763 * and check that it has been newly created,
764 * i.e. delete on close was effective on the disconnected handle.
765 * Also check that the file is really empty,
766 * the previously written byte gone.
768 smb2_oplock_create_share(&io2
, fname
,
769 smb2_util_share_access(""),
770 smb2_util_oplock_level("b"));
771 io2
.in
.create_options
|= NTCREATEX_OPTIONS_DELETE_ON_CLOSE
;
773 status
= smb2_create(tree
, mem_ctx
, &io2
);
774 CHECK_STATUS(status
, NT_STATUS_OK
);
775 _h
= io2
.out
.file
.handle
;
777 CHECK_CREATED_SIZE(&io2
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
, 0, 0);
778 CHECK_VAL(io2
.out
.durable_open
, false);
779 CHECK_VAL(io2
.out
.oplock_level
, smb2_util_oplock_level("b"));
783 smb2_util_close(tree
, *h
);
786 smb2_util_unlink(tree
, fname
);
790 talloc_free(mem_ctx
);
796 bool test_durable_open_delete_on_close2(struct torture_context
*tctx
,
797 struct smb2_tree
*tree
)
800 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
802 struct smb2_handle _h
;
803 struct smb2_handle
*h
= NULL
;
804 struct smb2_create io
;
807 uint64_t previous_session_id
;
808 uint64_t alloc_size_step
;
810 /* Choose a random name in case the state is left a little funky. */
811 snprintf(fname
, 256, "durable_open_delete_on_close2_%s.dat",
812 generate_random_str(tctx
, 8));
814 smb2_util_unlink(tree
, fname
);
816 smb2_oplock_create_share(&io
, fname
,
817 smb2_util_share_access(""),
818 smb2_util_oplock_level("b"));
819 io
.in
.durable_open
= true;
820 io
.in
.create_options
|= NTCREATEX_OPTIONS_DELETE_ON_CLOSE
;
822 status
= smb2_create(tree
, mem_ctx
, &io
);
823 CHECK_STATUS(status
, NT_STATUS_OK
);
824 _h
= io
.out
.file
.handle
;
826 CHECK_CREATED(&io
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
827 CHECK_VAL(io
.out
.durable_open
, true);
828 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
830 status
= smb2_util_write(tree
, *h
, &b
, 0, 1);
831 CHECK_STATUS(status
, NT_STATUS_OK
);
833 previous_session_id
= smb2cli_session_current_id(tree
->session
->smbXcli
);
835 /* disconnect, leaving the durable handle in place */
838 if (!torture_smb2_connection_ext(tctx
, previous_session_id
, &tree
)) {
839 torture_warning(tctx
, "could not reconnect, bailing\n");
846 io
.in
.durable_handle
= h
;
848 status
= smb2_create(tree
, mem_ctx
, &io
);
849 CHECK_STATUS(status
, NT_STATUS_OK
);
850 _h
= io
.out
.file
.handle
;
852 alloc_size_step
= io
.out
.alloc_size
;
853 CHECK_CREATED_SIZE(&io
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
, alloc_size_step
, 1);
854 CHECK_VAL(io
.out
.durable_open
, false);
855 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
857 /* close the file, thereby deleting it */
858 smb2_util_close(tree
, *h
);
859 status
= smb2_logoff(tree
->session
);
862 if (!torture_smb2_connection(tctx
, &tree
)) {
863 torture_warning(tctx
, "could not reconnect, bailing\n");
869 * Open the file on the new connection again
870 * and check that it has been newly created,
871 * i.e. delete on close was effective on the reconnected handle.
872 * Also check that the file is really empty,
873 * the previously written byte gone.
875 smb2_oplock_create_share(&io
, fname
,
876 smb2_util_share_access(""),
877 smb2_util_oplock_level("b"));
878 io
.in
.durable_open
= true;
879 io
.in
.create_options
|= NTCREATEX_OPTIONS_DELETE_ON_CLOSE
;
881 status
= smb2_create(tree
, mem_ctx
, &io
);
882 CHECK_STATUS(status
, NT_STATUS_OK
);
883 _h
= io
.out
.file
.handle
;
885 CHECK_CREATED_SIZE(&io
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
, 0, 0);
886 CHECK_VAL(io
.out
.durable_open
, true);
887 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
891 smb2_util_close(tree
, *h
);
894 smb2_util_unlink(tree
, fname
);
898 talloc_free(mem_ctx
);
904 basic testing of SMB2 durable opens
905 regarding the position information on the handle
907 bool test_durable_open_file_position(struct torture_context
*tctx
,
908 struct smb2_tree
*tree
)
910 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
911 struct smb2_handle h
;
912 struct smb2_create io
;
914 const char *fname
= "durable_open_position.dat";
915 union smb_fileinfo qfinfo
;
916 union smb_setfileinfo sfinfo
;
919 uint64_t previous_session_id
;
921 smb2_util_unlink(tree
, fname
);
923 smb2_oplock_create(&io
, fname
, SMB2_OPLOCK_LEVEL_BATCH
);
924 io
.in
.durable_open
= true;
926 status
= smb2_create(tree
, mem_ctx
, &io
);
927 CHECK_STATUS(status
, NT_STATUS_OK
);
928 h
= io
.out
.file
.handle
;
929 CHECK_CREATED(&io
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
930 CHECK_VAL(io
.out
.durable_open
, true);
931 CHECK_VAL(io
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_BATCH
);
933 /* TODO: check extra blob content */
936 qfinfo
.generic
.level
= RAW_FILEINFO_POSITION_INFORMATION
;
937 qfinfo
.generic
.in
.file
.handle
= h
;
938 status
= smb2_getinfo_file(tree
, mem_ctx
, &qfinfo
);
939 CHECK_STATUS(status
, NT_STATUS_OK
);
940 CHECK_VAL(qfinfo
.position_information
.out
.position
, 0);
941 pos
= qfinfo
.position_information
.out
.position
;
942 torture_comment(tctx
, "position: %llu\n",
943 (unsigned long long)pos
);
946 sfinfo
.generic
.level
= RAW_SFILEINFO_POSITION_INFORMATION
;
947 sfinfo
.generic
.in
.file
.handle
= h
;
948 sfinfo
.position_information
.in
.position
= 0x1000;
949 status
= smb2_setinfo_file(tree
, &sfinfo
);
950 CHECK_STATUS(status
, NT_STATUS_OK
);
953 qfinfo
.generic
.level
= RAW_FILEINFO_POSITION_INFORMATION
;
954 qfinfo
.generic
.in
.file
.handle
= h
;
955 status
= smb2_getinfo_file(tree
, mem_ctx
, &qfinfo
);
956 CHECK_STATUS(status
, NT_STATUS_OK
);
957 CHECK_VAL(qfinfo
.position_information
.out
.position
, 0x1000);
958 pos
= qfinfo
.position_information
.out
.position
;
959 torture_comment(tctx
, "position: %llu\n",
960 (unsigned long long)pos
);
962 previous_session_id
= smb2cli_session_current_id(tree
->session
->smbXcli
);
968 /* do a session reconnect */
969 if (!torture_smb2_connection_ext(tctx
, previous_session_id
, &tree
)) {
970 torture_warning(tctx
, "couldn't reconnect, bailing\n");
976 qfinfo
.generic
.level
= RAW_FILEINFO_POSITION_INFORMATION
;
977 qfinfo
.generic
.in
.file
.handle
= h
;
978 status
= smb2_getinfo_file(tree
, mem_ctx
, &qfinfo
);
979 CHECK_STATUS(status
, NT_STATUS_FILE_CLOSED
);
983 io
.in
.durable_handle
= &h
;
985 status
= smb2_create(tree
, mem_ctx
, &io
);
986 CHECK_STATUS(status
, NT_STATUS_OK
);
987 CHECK_VAL(io
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_BATCH
);
988 CHECK_VAL(io
.out
.reserved
, 0x00);
989 CHECK_VAL(io
.out
.create_action
, NTCREATEX_ACTION_EXISTED
);
990 CHECK_VAL(io
.out
.alloc_size
, 0);
991 CHECK_VAL(io
.out
.size
, 0);
992 CHECK_VAL(io
.out
.file_attr
, FILE_ATTRIBUTE_ARCHIVE
);
993 CHECK_VAL(io
.out
.reserved2
, 0);
995 h
= io
.out
.file
.handle
;
998 qfinfo
.generic
.level
= RAW_FILEINFO_POSITION_INFORMATION
;
999 qfinfo
.generic
.in
.file
.handle
= h
;
1000 status
= smb2_getinfo_file(tree
, mem_ctx
, &qfinfo
);
1001 CHECK_STATUS(status
, NT_STATUS_OK
);
1002 CHECK_VAL(qfinfo
.position_information
.out
.position
, 0x1000);
1003 pos
= qfinfo
.position_information
.out
.position
;
1004 torture_comment(tctx
, "position: %llu\n",
1005 (unsigned long long)pos
);
1007 smb2_util_close(tree
, h
);
1009 talloc_free(mem_ctx
);
1011 smb2_util_unlink(tree
, fname
);
1020 Open, disconnect, oplock break, reconnect.
1022 bool test_durable_open_oplock(struct torture_context
*tctx
,
1023 struct smb2_tree
*tree1
,
1024 struct smb2_tree
*tree2
)
1026 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1027 struct smb2_create io1
, io2
;
1028 struct smb2_handle h1
, h2
;
1033 /* Choose a random name in case the state is left a little funky. */
1034 snprintf(fname
, 256, "durable_open_oplock_%s.dat", generate_random_str(tctx
, 8));
1037 smb2_util_unlink(tree1
, fname
);
1039 /* Create with batch oplock */
1040 smb2_oplock_create(&io1
, fname
, SMB2_OPLOCK_LEVEL_BATCH
);
1041 io1
.in
.durable_open
= true;
1044 io2
.in
.create_disposition
= NTCREATEX_DISP_OPEN
;
1046 status
= smb2_create(tree1
, mem_ctx
, &io1
);
1047 CHECK_STATUS(status
, NT_STATUS_OK
);
1048 h1
= io1
.out
.file
.handle
;
1049 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1050 CHECK_VAL(io1
.out
.durable_open
, true);
1051 CHECK_VAL(io1
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_BATCH
);
1053 /* Disconnect after getting the batch */
1058 * Windows7 (build 7000) will break a batch oplock immediately if the
1059 * original client is gone. (ZML: This seems like a bug. It should give
1060 * some time for the client to reconnect!)
1062 status
= smb2_create(tree2
, mem_ctx
, &io2
);
1063 CHECK_STATUS(status
, NT_STATUS_OK
);
1064 h2
= io2
.out
.file
.handle
;
1065 CHECK_CREATED(&io2
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
);
1066 CHECK_VAL(io2
.out
.durable_open
, true);
1067 CHECK_VAL(io2
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_BATCH
);
1069 /* What if tree1 tries to come back and reclaim? */
1070 if (!torture_smb2_connection(tctx
, &tree1
)) {
1071 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1077 io1
.in
.fname
= fname
;
1078 io1
.in
.durable_handle
= &h1
;
1080 status
= smb2_create(tree1
, mem_ctx
, &io1
);
1081 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
1084 smb2_util_close(tree2
, h2
);
1085 smb2_util_unlink(tree2
, fname
);
1094 Open, disconnect, lease break, reconnect.
1096 bool test_durable_open_lease(struct torture_context
*tctx
,
1097 struct smb2_tree
*tree1
,
1098 struct smb2_tree
*tree2
)
1100 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1101 struct smb2_create io1
, io2
;
1102 struct smb2_lease ls1
, ls2
;
1103 struct smb2_handle h1
, h2
;
1107 uint64_t lease1
, lease2
;
1110 caps
= smb2cli_conn_server_capabilities(tree1
->session
->transport
->conn
);
1111 if (!(caps
& SMB2_CAP_LEASING
)) {
1112 torture_skip(tctx
, "leases are not supported");
1116 * Choose a random name and random lease in case the state is left a
1121 snprintf(fname
, 256, "durable_open_lease_%s.dat", generate_random_str(tctx
, 8));
1124 smb2_util_unlink(tree1
, fname
);
1126 /* Create with lease */
1127 smb2_lease_create(&io1
, &ls1
, false /* dir */, fname
,
1128 lease1
, smb2_util_lease_state("RHW"));
1129 io1
.in
.durable_open
= true;
1131 smb2_lease_create(&io2
, &ls2
, false /* dir */, fname
,
1132 lease2
, smb2_util_lease_state("RHW"));
1133 io2
.in
.durable_open
= true;
1134 io2
.in
.create_disposition
= NTCREATEX_DISP_OPEN
;
1136 status
= smb2_create(tree1
, mem_ctx
, &io1
);
1137 CHECK_STATUS(status
, NT_STATUS_OK
);
1138 h1
= io1
.out
.file
.handle
;
1139 CHECK_VAL(io1
.out
.durable_open
, true);
1140 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1142 CHECK_VAL(io1
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_LEASE
);
1143 CHECK_VAL(io1
.out
.lease_response
.lease_key
.data
[0], lease1
);
1144 CHECK_VAL(io1
.out
.lease_response
.lease_key
.data
[1], ~lease1
);
1145 CHECK_VAL(io1
.out
.lease_response
.lease_state
,
1146 SMB2_LEASE_READ
|SMB2_LEASE_HANDLE
|SMB2_LEASE_WRITE
);
1148 /* Disconnect after getting the lease */
1153 * Windows7 (build 7000) will grant an RH lease immediate (not an RHW?)
1154 * even if the original client is gone. (ZML: This seems like a bug. It
1155 * should give some time for the client to reconnect! And why RH?)
1157 * obnox: Current windows 7 and w2k8r2 grant RHW instead of RH.
1158 * Test is adapted accordingly.
1160 status
= smb2_create(tree2
, mem_ctx
, &io2
);
1161 CHECK_STATUS(status
, NT_STATUS_OK
);
1162 h2
= io2
.out
.file
.handle
;
1163 CHECK_VAL(io2
.out
.durable_open
, true);
1164 CHECK_CREATED(&io2
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
);
1166 CHECK_VAL(io2
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_LEASE
);
1167 CHECK_VAL(io2
.out
.lease_response
.lease_key
.data
[0], lease2
);
1168 CHECK_VAL(io2
.out
.lease_response
.lease_key
.data
[1], ~lease2
);
1169 CHECK_VAL(io2
.out
.lease_response
.lease_state
,
1170 SMB2_LEASE_READ
|SMB2_LEASE_HANDLE
|SMB2_LEASE_WRITE
);
1172 /* What if tree1 tries to come back and reclaim? */
1173 if (!torture_smb2_connection(tctx
, &tree1
)) {
1174 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1180 io1
.in
.fname
= fname
;
1181 io1
.in
.durable_handle
= &h1
;
1182 io1
.in
.lease_request
= &ls1
;
1184 status
= smb2_create(tree1
, mem_ctx
, &io1
);
1185 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
1188 smb2_util_close(tree2
, h2
);
1189 smb2_util_unlink(tree2
, fname
);
1197 bool test_durable_open_lock_oplock(struct torture_context
*tctx
,
1198 struct smb2_tree
*tree
)
1200 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1201 struct smb2_create io
;
1202 struct smb2_handle h
;
1203 struct smb2_lock lck
;
1204 struct smb2_lock_element el
[2];
1211 snprintf(fname
, 256, "durable_open_oplock_lock_%s.dat", generate_random_str(tctx
, 8));
1214 smb2_util_unlink(tree
, fname
);
1216 /* Create with lease */
1218 smb2_oplock_create_share(&io
, fname
,
1219 smb2_util_share_access(""),
1220 smb2_util_oplock_level("b"));
1221 io
.in
.durable_open
= true;
1223 status
= smb2_create(tree
, mem_ctx
, &io
);
1224 CHECK_STATUS(status
, NT_STATUS_OK
);
1225 h
= io
.out
.file
.handle
;
1226 CHECK_CREATED(&io
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1228 CHECK_VAL(io
.out
.durable_open
, true);
1229 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
1234 lck
.in
.lock_count
= 0x0001;
1235 lck
.in
.lock_sequence
= 0x00000000;
1236 lck
.in
.file
.handle
= h
;
1239 el
[0].reserved
= 0x00000000;
1240 el
[0].flags
= SMB2_LOCK_FLAG_EXCLUSIVE
;
1241 status
= smb2_lock(tree
, &lck
);
1242 CHECK_STATUS(status
, NT_STATUS_OK
);
1244 /* Disconnect/Reconnect. */
1248 if (!torture_smb2_connection(tctx
, &tree
)) {
1249 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1255 io
.in
.fname
= fname
;
1256 io
.in
.durable_handle
= &h
;
1258 status
= smb2_create(tree
, mem_ctx
, &io
);
1259 CHECK_STATUS(status
, NT_STATUS_OK
);
1260 h
= io
.out
.file
.handle
;
1262 lck
.in
.file
.handle
= h
;
1263 el
[0].flags
= SMB2_LOCK_FLAG_UNLOCK
;
1264 status
= smb2_lock(tree
, &lck
);
1265 CHECK_STATUS(status
, NT_STATUS_OK
);
1268 smb2_util_close(tree
, h
);
1269 smb2_util_unlink(tree
, fname
);
1276 Open, take BRL, disconnect, reconnect.
1278 bool test_durable_open_lock_lease(struct torture_context
*tctx
,
1279 struct smb2_tree
*tree
)
1281 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1282 struct smb2_create io
;
1283 struct smb2_lease ls
;
1284 struct smb2_handle h
;
1285 struct smb2_lock lck
;
1286 struct smb2_lock_element el
[2];
1293 caps
= smb2cli_conn_server_capabilities(tree
->session
->transport
->conn
);
1294 if (!(caps
& SMB2_CAP_LEASING
)) {
1295 torture_skip(tctx
, "leases are not supported");
1299 * Choose a random name and random lease in case the state is left a
1303 snprintf(fname
, 256, "durable_open_lease_lock_%s.dat", generate_random_str(tctx
, 8));
1306 smb2_util_unlink(tree
, fname
);
1308 /* Create with lease */
1310 smb2_lease_create(&io
, &ls
, false /* dir */, fname
, lease
,
1311 smb2_util_lease_state("RWH"));
1312 io
.in
.durable_open
= true;
1314 status
= smb2_create(tree
, mem_ctx
, &io
);
1315 CHECK_STATUS(status
, NT_STATUS_OK
);
1316 h
= io
.out
.file
.handle
;
1317 CHECK_CREATED(&io
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1319 CHECK_VAL(io
.out
.durable_open
, true);
1320 CHECK_VAL(io
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_LEASE
);
1321 CHECK_VAL(io
.out
.lease_response
.lease_key
.data
[0], lease
);
1322 CHECK_VAL(io
.out
.lease_response
.lease_key
.data
[1], ~lease
);
1323 CHECK_VAL(io
.out
.lease_response
.lease_state
,
1324 SMB2_LEASE_READ
|SMB2_LEASE_HANDLE
|SMB2_LEASE_WRITE
);
1329 lck
.in
.lock_count
= 0x0001;
1330 lck
.in
.lock_sequence
= 0x00000000;
1331 lck
.in
.file
.handle
= h
;
1334 el
[0].reserved
= 0x00000000;
1335 el
[0].flags
= SMB2_LOCK_FLAG_EXCLUSIVE
;
1336 status
= smb2_lock(tree
, &lck
);
1337 CHECK_STATUS(status
, NT_STATUS_OK
);
1339 /* Disconnect/Reconnect. */
1343 if (!torture_smb2_connection(tctx
, &tree
)) {
1344 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1350 io
.in
.fname
= fname
;
1351 io
.in
.durable_handle
= &h
;
1352 io
.in
.lease_request
= &ls
;
1354 status
= smb2_create(tree
, mem_ctx
, &io
);
1355 CHECK_STATUS(status
, NT_STATUS_OK
);
1356 h
= io
.out
.file
.handle
;
1358 lck
.in
.file
.handle
= h
;
1359 el
[0].flags
= SMB2_LOCK_FLAG_UNLOCK
;
1360 status
= smb2_lock(tree
, &lck
);
1361 CHECK_STATUS(status
, NT_STATUS_OK
);
1364 smb2_util_close(tree
, h
);
1365 smb2_util_unlink(tree
, fname
);
1372 * Open with a RH lease, disconnect, open in another tree, reconnect.
1374 * This test actually demonstrates a minimum level of respect for the durable
1375 * open in the face of another open. As long as this test shows an inability to
1376 * reconnect after an open, the oplock/lease tests above will certainly
1377 * demonstrate an error on reconnect.
1379 bool test_durable_open_open2_lease(struct torture_context
*tctx
,
1380 struct smb2_tree
*tree1
,
1381 struct smb2_tree
*tree2
)
1383 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1384 struct smb2_create io1
, io2
;
1385 struct smb2_lease ls
;
1386 struct smb2_handle h1
, h2
;
1393 caps
= smb2cli_conn_server_capabilities(tree1
->session
->transport
->conn
);
1394 if (!(caps
& SMB2_CAP_LEASING
)) {
1395 torture_skip(tctx
, "leases are not supported");
1399 * Choose a random name and random lease in case the state is left a
1403 snprintf(fname
, 256, "durable_open_open2_lease_%s.dat",
1404 generate_random_str(tctx
, 8));
1407 smb2_util_unlink(tree1
, fname
);
1409 /* Create with lease */
1410 smb2_lease_create_share(&io1
, &ls
, false /* dir */, fname
,
1411 smb2_util_share_access(""),
1413 smb2_util_lease_state("RH"));
1414 io1
.in
.durable_open
= true;
1416 status
= smb2_create(tree1
, mem_ctx
, &io1
);
1417 CHECK_STATUS(status
, NT_STATUS_OK
);
1418 h1
= io1
.out
.file
.handle
;
1419 CHECK_VAL(io1
.out
.durable_open
, true);
1420 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1422 CHECK_VAL(io1
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_LEASE
);
1423 CHECK_VAL(io1
.out
.lease_response
.lease_key
.data
[0], lease
);
1424 CHECK_VAL(io1
.out
.lease_response
.lease_key
.data
[1], ~lease
);
1425 CHECK_VAL(io1
.out
.lease_response
.lease_state
,
1426 smb2_util_lease_state("RH"));
1432 /* Open the file in tree2 */
1433 smb2_oplock_create(&io2
, fname
, SMB2_OPLOCK_LEVEL_NONE
);
1435 status
= smb2_create(tree2
, mem_ctx
, &io2
);
1436 CHECK_STATUS(status
, NT_STATUS_OK
);
1437 h2
= io2
.out
.file
.handle
;
1438 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1441 if (!torture_smb2_connection(tctx
, &tree1
)) {
1442 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1448 io1
.in
.fname
= fname
;
1449 io1
.in
.durable_handle
= &h1
;
1450 io1
.in
.lease_request
= &ls
;
1453 * Windows7 (build 7000) will give away an open immediately if the
1454 * original client is gone. (ZML: This seems like a bug. It should give
1455 * some time for the client to reconnect!)
1457 status
= smb2_create(tree1
, mem_ctx
, &io1
);
1458 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
1459 h1
= io1
.out
.file
.handle
;
1462 smb2_util_close(tree2
, h2
);
1463 smb2_util_unlink(tree2
, fname
);
1464 smb2_util_close(tree1
, h1
);
1465 smb2_util_unlink(tree1
, fname
);
1474 * Open with a batch oplock, disconnect, open in another tree, reconnect.
1476 * This test actually demonstrates a minimum level of respect for the durable
1477 * open in the face of another open. As long as this test shows an inability to
1478 * reconnect after an open, the oplock/lease tests above will certainly
1479 * demonstrate an error on reconnect.
1481 bool test_durable_open_open2_oplock(struct torture_context
*tctx
,
1482 struct smb2_tree
*tree1
,
1483 struct smb2_tree
*tree2
)
1485 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1486 struct smb2_create io1
, io2
;
1487 struct smb2_handle h1
, h2
;
1493 * Choose a random name and random lease in case the state is left a
1496 snprintf(fname
, 256, "durable_open_open2_oplock_%s.dat",
1497 generate_random_str(tctx
, 8));
1500 smb2_util_unlink(tree1
, fname
);
1502 /* Create with batch oplock */
1503 smb2_oplock_create(&io1
, fname
, SMB2_OPLOCK_LEVEL_BATCH
);
1504 io1
.in
.durable_open
= true;
1506 status
= smb2_create(tree1
, mem_ctx
, &io1
);
1507 CHECK_STATUS(status
, NT_STATUS_OK
);
1508 h1
= io1
.out
.file
.handle
;
1509 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1510 CHECK_VAL(io1
.out
.durable_open
, true);
1511 CHECK_VAL(io1
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_BATCH
);
1517 /* Open the file in tree2 */
1518 smb2_oplock_create(&io2
, fname
, SMB2_OPLOCK_LEVEL_NONE
);
1520 status
= smb2_create(tree2
, mem_ctx
, &io2
);
1521 CHECK_STATUS(status
, NT_STATUS_OK
);
1522 h2
= io2
.out
.file
.handle
;
1523 CHECK_CREATED(&io1
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1526 if (!torture_smb2_connection(tctx
, &tree1
)) {
1527 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1533 io1
.in
.fname
= fname
;
1534 io1
.in
.durable_handle
= &h1
;
1536 status
= smb2_create(tree1
, mem_ctx
, &io1
);
1537 CHECK_STATUS(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
);
1538 h1
= io1
.out
.file
.handle
;
1541 smb2_util_close(tree2
, h2
);
1542 smb2_util_unlink(tree2
, fname
);
1543 smb2_util_close(tree1
, h1
);
1544 smb2_util_unlink(tree1
, fname
);
1553 * test behaviour with initial allocation size
1555 bool test_durable_open_alloc_size(struct torture_context
*tctx
,
1556 struct smb2_tree
*tree
)
1559 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1561 struct smb2_handle _h
;
1562 struct smb2_handle
*h
= NULL
;
1563 struct smb2_create io
;
1565 uint64_t previous_session_id
;
1566 uint64_t alloc_size_step
;
1567 uint64_t initial_alloc_size
= 0x100;
1568 const uint8_t *b
= NULL
;
1570 /* Choose a random name in case the state is left a little funky. */
1571 snprintf(fname
, 256, "durable_open_alloc_size_%s.dat",
1572 generate_random_str(tctx
, 8));
1574 smb2_util_unlink(tree
, fname
);
1576 smb2_oplock_create_share(&io
, fname
,
1577 smb2_util_share_access(""),
1578 smb2_util_oplock_level("b"));
1579 io
.in
.durable_open
= true;
1580 io
.in
.alloc_size
= initial_alloc_size
;
1582 status
= smb2_create(tree
, mem_ctx
, &io
);
1583 CHECK_STATUS(status
, NT_STATUS_OK
);
1584 _h
= io
.out
.file
.handle
;
1586 CHECK_NOT_VAL(io
.out
.alloc_size
, 0);
1587 alloc_size_step
= io
.out
.alloc_size
;
1588 CHECK_CREATED_SIZE(&io
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
,
1589 alloc_size_step
, 0);
1590 CHECK_VAL(io
.out
.durable_open
, true);
1591 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
1593 /* prepare buffer */
1594 b
= talloc_zero_size(mem_ctx
, alloc_size_step
);
1595 CHECK_NOT_VAL(b
, NULL
);
1597 previous_session_id
= smb2cli_session_current_id(tree
->session
->smbXcli
);
1599 /* disconnect, reconnect and then do durable reopen */
1603 if (!torture_smb2_connection_ext(tctx
, previous_session_id
, &tree
)) {
1604 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1610 io
.in
.fname
= fname
;
1611 io
.in
.durable_handle
= h
;
1614 status
= smb2_create(tree
, mem_ctx
, &io
);
1615 CHECK_STATUS(status
, NT_STATUS_OK
);
1616 CHECK_CREATED_SIZE(&io
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
,
1617 alloc_size_step
, 0);
1618 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
1619 _h
= io
.out
.file
.handle
;
1622 previous_session_id
= smb2cli_session_current_id(tree
->session
->smbXcli
);
1624 /* write one byte */
1625 status
= smb2_util_write(tree
, *h
, b
, 0, 1);
1626 CHECK_STATUS(status
, NT_STATUS_OK
);
1628 /* disconnect, reconnect and then do durable reopen */
1632 if (!torture_smb2_connection_ext(tctx
, previous_session_id
, &tree
)) {
1633 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1639 io
.in
.fname
= fname
;
1640 io
.in
.durable_handle
= h
;
1643 status
= smb2_create(tree
, mem_ctx
, &io
);
1644 CHECK_STATUS(status
, NT_STATUS_OK
);
1645 CHECK_CREATED_SIZE(&io
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
,
1646 alloc_size_step
, 1);
1647 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
1648 _h
= io
.out
.file
.handle
;
1651 previous_session_id
= smb2cli_session_current_id(tree
->session
->smbXcli
);
1653 /* write more byte than initial allocation size */
1654 status
= smb2_util_write(tree
, *h
, b
, 1, alloc_size_step
);
1656 /* disconnect, reconnect and then do durable reopen */
1660 if (!torture_smb2_connection_ext(tctx
, previous_session_id
, &tree
)) {
1661 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1667 io
.in
.fname
= fname
;
1668 io
.in
.durable_handle
= h
;
1671 status
= smb2_create(tree
, mem_ctx
, &io
);
1672 CHECK_STATUS(status
, NT_STATUS_OK
);
1673 CHECK_CREATED_SIZE(&io
, EXISTED
, FILE_ATTRIBUTE_ARCHIVE
,
1674 alloc_size_step
* 2, alloc_size_step
+ 1);
1675 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
1676 _h
= io
.out
.file
.handle
;
1681 smb2_util_close(tree
, *h
);
1684 smb2_util_unlink(tree
, fname
);
1688 talloc_free(mem_ctx
);
1694 * test behaviour when a disconnect happens while creating a read-only file
1696 bool test_durable_open_read_only(struct torture_context
*tctx
,
1697 struct smb2_tree
*tree
)
1700 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1702 struct smb2_handle _h
;
1703 struct smb2_handle
*h
= NULL
;
1704 struct smb2_create io
;
1706 uint64_t previous_session_id
;
1707 const uint8_t b
= 0;
1708 uint64_t alloc_size
= 0;
1710 /* Choose a random name in case the state is left a little funky. */
1711 snprintf(fname
, 256, "durable_open_initial_alloc_%s.dat",
1712 generate_random_str(tctx
, 8));
1714 smb2_util_unlink(tree
, fname
);
1716 smb2_oplock_create_share(&io
, fname
,
1717 smb2_util_share_access(""),
1718 smb2_util_oplock_level("b"));
1719 io
.in
.durable_open
= true;
1720 io
.in
.file_attributes
= FILE_ATTRIBUTE_READONLY
;
1722 status
= smb2_create(tree
, mem_ctx
, &io
);
1723 CHECK_STATUS(status
, NT_STATUS_OK
);
1724 _h
= io
.out
.file
.handle
;
1726 CHECK_CREATED(&io
, CREATED
, FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_ARCHIVE
);
1727 CHECK_VAL(io
.out
.durable_open
, true);
1728 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
1730 previous_session_id
= smb2cli_session_current_id(tree
->session
->smbXcli
);
1732 /* write one byte */
1733 status
= smb2_util_write(tree
, *h
, &b
, 0, 1);
1734 CHECK_STATUS(status
, NT_STATUS_OK
);
1736 /* disconnect, reconnect and then do durable reopen */
1740 if (!torture_smb2_connection_ext(tctx
, previous_session_id
, &tree
)) {
1741 torture_warning(tctx
, "couldn't reconnect, bailing\n");
1747 io
.in
.fname
= fname
;
1748 io
.in
.durable_handle
= h
;
1751 status
= smb2_create(tree
, mem_ctx
, &io
);
1752 CHECK_STATUS(status
, NT_STATUS_OK
);
1753 alloc_size
= io
.out
.alloc_size
;
1754 CHECK_CREATED_SIZE(&io
, EXISTED
,
1755 FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_ARCHIVE
,
1757 CHECK_VAL(io
.out
.oplock_level
, smb2_util_oplock_level("b"));
1758 _h
= io
.out
.file
.handle
;
1761 /* write one byte */
1762 status
= smb2_util_write(tree
, *h
, &b
, 1, 1);
1763 CHECK_STATUS(status
, NT_STATUS_OK
);
1767 union smb_setfileinfo sfinfo
;
1769 ZERO_STRUCT(sfinfo
);
1770 sfinfo
.basic_info
.level
= RAW_SFILEINFO_BASIC_INFORMATION
;
1771 sfinfo
.basic_info
.in
.file
.handle
= *h
;
1772 sfinfo
.basic_info
.in
.attrib
= FILE_ATTRIBUTE_NORMAL
;
1773 smb2_setinfo_file(tree
, &sfinfo
);
1775 smb2_util_close(tree
, *h
);
1778 smb2_util_unlink(tree
, fname
);
1782 talloc_free(mem_ctx
);
1788 * durable open with oplock, disconnect, exit
1790 static bool test_durable_open_oplock_disconnect(struct torture_context
*tctx
,
1791 struct smb2_tree
*tree
)
1793 TALLOC_CTX
*mem_ctx
= talloc_new(tctx
);
1794 struct smb2_create io
;
1795 struct smb2_handle _h
;
1796 struct smb2_handle
*h
= NULL
;
1801 snprintf(fname
, 256, "durable_open_oplock_disconnect_%s.dat",
1802 generate_random_str(tctx
, 8));
1804 smb2_util_unlink(tree
, fname
);
1806 smb2_oplock_create(&io
, fname
, SMB2_OPLOCK_LEVEL_BATCH
);
1807 io
.in
.durable_open
= true;
1809 status
= smb2_create(tree
, mem_ctx
, &io
);
1810 CHECK_STATUS(status
, NT_STATUS_OK
);
1812 _h
= io
.out
.file
.handle
;
1815 CHECK_CREATED(&io
, CREATED
, FILE_ATTRIBUTE_ARCHIVE
);
1816 CHECK_VAL(io
.out
.durable_open
, true);
1817 CHECK_VAL(io
.out
.oplock_level
, SMB2_OPLOCK_LEVEL_BATCH
);
1826 smb2_util_close(tree
, *h
);
1828 smb2_util_unlink(tree
, fname
);
1835 struct torture_suite
*torture_smb2_durable_open_init(void)
1837 struct torture_suite
*suite
=
1838 torture_suite_create(talloc_autofree_context(), "durable-open");
1840 torture_suite_add_1smb2_test(suite
, "open-oplock", test_durable_open_open_oplock
);
1841 torture_suite_add_1smb2_test(suite
, "open-lease", test_durable_open_open_lease
);
1842 torture_suite_add_1smb2_test(suite
, "reopen1", test_durable_open_reopen1
);
1843 torture_suite_add_1smb2_test(suite
, "reopen2", test_durable_open_reopen2
);
1844 torture_suite_add_1smb2_test(suite
, "reopen2a", test_durable_open_reopen2a
);
1845 torture_suite_add_1smb2_test(suite
, "reopen3", test_durable_open_reopen3
);
1846 torture_suite_add_1smb2_test(suite
, "reopen4", test_durable_open_reopen4
);
1847 torture_suite_add_1smb2_test(suite
, "delete_on_close1",
1848 test_durable_open_delete_on_close1
);
1849 torture_suite_add_1smb2_test(suite
, "delete_on_close2",
1850 test_durable_open_delete_on_close2
);
1851 torture_suite_add_1smb2_test(suite
, "file-position",
1852 test_durable_open_file_position
);
1853 torture_suite_add_2smb2_test(suite
, "oplock", test_durable_open_oplock
);
1854 torture_suite_add_2smb2_test(suite
, "lease", test_durable_open_lease
);
1855 torture_suite_add_1smb2_test(suite
, "lock-oplock", test_durable_open_lock_oplock
);
1856 torture_suite_add_1smb2_test(suite
, "lock-lease", test_durable_open_lock_lease
);
1857 torture_suite_add_2smb2_test(suite
, "open2-lease",
1858 test_durable_open_open2_lease
);
1859 torture_suite_add_2smb2_test(suite
, "open2-oplock",
1860 test_durable_open_open2_oplock
);
1861 torture_suite_add_1smb2_test(suite
, "alloc-size",
1862 test_durable_open_alloc_size
);
1863 torture_suite_add_1smb2_test(suite
, "read-only",
1864 test_durable_open_read_only
);
1866 suite
->description
= talloc_strdup(suite
, "SMB2-DURABLE-OPEN tests");
1871 struct torture_suite
*torture_smb2_durable_open_disconnect_init(void)
1873 struct torture_suite
*suite
=
1874 torture_suite_create(talloc_autofree_context(),
1875 "durable-open-disconnect");
1877 torture_suite_add_1smb2_test(suite
, "open-oplock-disconnect",
1878 test_durable_open_oplock_disconnect
);
1880 suite
->description
= talloc_strdup(suite
,
1881 "SMB2-DURABLE-OPEN-DISCONNECT tests");