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