?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:librpc/rpc: use talloc_zero for 'struct rpc_request'
[Samba/gebeck_regimport.git] / source4 / torture / smb2 / durable_open.c
blob659fa9d508da9b41ededf1323949c08157330aa0
1 /*
2 Unix SMB/CIFS implementation.
3
4 test suite for SMB2 durable opens
5
6 Copyright (C) Stefan Metzmacher 2008
7 Copyright (C) Michael Adam 2011-2012
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "includes.h"
24 #include "libcli/smb2/smb2.h"
25 #include "libcli/smb2/smb2_calls.h"
26 #include "../libcli/smb/smbXcli_base.h"
27 #include "torture/torture.h"
28 #include "torture/smb2/proto.h"
29 #include "../libcli/smb/smbXcli_base.h"
30
31 #define CHECK_VAL(v, correct) do { \
32 if ((v) != (correct)) { \
33 torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s got 0x%llx - should be 0x%llx\n", \
34 __location__, #v, (unsigned long long)v, (unsigned long long)correct); \
35 ret = false; \
36 }} while (0)
37
38 #define CHECK_NOT_VAL(v, correct) do { \
39 if ((v) == (correct)) { \
40 torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s got 0x%llx - should not be 0x%llx\n", \
41 __location__, #v, (unsigned long long)v, (unsigned long long)correct); \
42 ret = false; \
43 }} while (0)
44
45 #define CHECK_STATUS(status, correct) do { \
46 if (!NT_STATUS_EQUAL(status, correct)) { \
47 torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
48 nt_errstr(status), nt_errstr(correct)); \
49 ret = false; \
50 goto done; \
51 }} while (0)
52
53 #define CHECK_CREATED(__io, __created, __attribute) \
54 do { \
55 CHECK_VAL((__io)->out.create_action, NTCREATEX_ACTION_ ## __created); \
56 CHECK_VAL((__io)->out.alloc_size, 0); \
57 CHECK_VAL((__io)->out.size, 0); \
58 CHECK_VAL((__io)->out.file_attr, (__attribute)); \
59 CHECK_VAL((__io)->out.reserved2, 0); \
60 } while(0)
61
62
63 /**
64 * basic durable_open test.
65 * durable state should only be granted when requested
66 * along with a batch oplock or a handle lease.
67 *
68 * This test tests durable open with all possible oplock types.
69 */
70
71 struct durable_open_vs_oplock {
72 const char *level;
73 const char *share_mode;
74 bool expected;
75 };
76
77 #define NUM_OPLOCK_TYPES 4
78 #define NUM_SHARE_MODES 8
79 #define NUM_OPLOCK_OPEN_TESTS ( NUM_OPLOCK_TYPES * NUM_SHARE_MODES )
80 static struct durable_open_vs_oplock durable_open_vs_oplock_table[NUM_OPLOCK_OPEN_TESTS] =
81 {
82 { "", "", false },
83 { "", "R", false },
84 { "", "W", false },
85 { "", "D", false },
86 { "", "RD", false },
87 { "", "RW", false },
88 { "", "WD", false },
89 { "", "RWD", false },
90
91 { "s", "", false },
92 { "s", "R", false },
93 { "s", "W", false },
94 { "s", "D", false },
95 { "s", "RD", false },
96 { "s", "RW", false },
97 { "s", "WD", false },
98 { "s", "RWD", false },
99
100 { "x", "", false },
101 { "x", "R", false },
102 { "x", "W", false },
103 { "x", "D", false },
104 { "x", "RD", false },
105 { "x", "RW", false },
106 { "x", "WD", false },
107 { "x", "RWD", false },
108
109 { "b", "", true },
110 { "b", "R", true },
111 { "b", "W", true },
112 { "b", "D", true },
113 { "b", "RD", true },
114 { "b", "RW", true },
115 { "b", "WD", true },
116 { "b", "RWD", true },
117 };
118
119 static bool test_one_durable_open_open_oplock(struct torture_context *tctx,
120 struct smb2_tree *tree,
121 const char *fname,
122 struct durable_open_vs_oplock test)
123 {
124 NTSTATUS status;
125 TALLOC_CTX *mem_ctx = talloc_new(tctx);
126 struct smb2_handle _h;
127 struct smb2_handle *h = NULL;
128 bool ret = true;
129 struct smb2_create io;
130
131 smb2_util_unlink(tree, fname);
132
133 smb2_oplock_create_share(&io, fname,
134 smb2_util_share_access(test.share_mode),
135 smb2_util_oplock_level(test.level));
136 io.in.durable_open = true;
137
138 status = smb2_create(tree, mem_ctx, &io);
139 CHECK_STATUS(status, NT_STATUS_OK);
140 _h = io.out.file.handle;
141 h = &_h;
142 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
143 CHECK_VAL(io.out.durable_open, test.expected);
144 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(test.level));
145
146 done:
147 if (h != NULL) {
148 smb2_util_close(tree, *h);
149 }
150 smb2_util_unlink(tree, fname);
151 talloc_free(mem_ctx);
152
153 return ret;
154 }
155
156 bool test_durable_open_open_oplock(struct torture_context *tctx,
157 struct smb2_tree *tree)
158 {
159 TALLOC_CTX *mem_ctx = talloc_new(tctx);
160 char fname[256];
161 bool ret = true;
162 int i;
163
164 /* Choose a random name in case the state is left a little funky. */
165 snprintf(fname, 256, "durable_open_open_oplock_%s.dat", generate_random_str(tctx, 8));
166
167 smb2_util_unlink(tree, fname);
168
169 /* test various oplock levels with durable open */
170
171 for (i = 0; i < NUM_OPLOCK_OPEN_TESTS; i++) {
172 ret = test_one_durable_open_open_oplock(tctx,
173 tree,
174 fname,
175 durable_open_vs_oplock_table[i]);
176 if (ret == false) {
177 goto done;
178 }
179 }
180
181 done:
182 smb2_util_unlink(tree, fname);
183 talloc_free(tree);
184 talloc_free(mem_ctx);
185
186 return ret;
187 }
188
189 /**
190 * basic durable_open test.
191 * durable state should only be granted when requested
192 * along with a batch oplock or a handle lease.
193 *
194 * This test tests durable open with all valid lease types.
195 */
196
197 struct durable_open_vs_lease {
198 const char *type;
199 const char *share_mode;
200 bool expected;
201 };
202
203 #define NUM_LEASE_TYPES 5
204 #define NUM_LEASE_OPEN_TESTS ( NUM_LEASE_TYPES * NUM_SHARE_MODES )
205 static struct durable_open_vs_lease durable_open_vs_lease_table[NUM_LEASE_OPEN_TESTS] =
206 {
207 { "", "", false },
208 { "", "R", false },
209 { "", "W", false },
210 { "", "D", false },
211 { "", "RW", false },
212 { "", "RD", false },
213 { "", "WD", false },
214 { "", "RWD", false },
215
216 { "R", "", false },
217 { "R", "R", false },
218 { "R", "W", false },
219 { "R", "D", false },
220 { "R", "RW", false },
221 { "R", "RD", false },
222 { "R", "DW", false },
223 { "R", "RWD", false },
224
225 { "RW", "", false },
226 { "RW", "R", false },
227 { "RW", "W", false },
228 { "RW", "D", false },
229 { "RW", "RW", false },
230 { "RW", "RD", false },
231 { "RW", "WD", false },
232 { "RW", "RWD", false },
233
234 { "RH", "", true },
235 { "RH", "R", true },
236 { "RH", "W", true },
237 { "RH", "D", true },
238 { "RH", "RW", true },
239 { "RH", "RD", true },
240 { "RH", "WD", true },
241 { "RH", "RWD", true },
242
243 { "RHW", "", true },
244 { "RHW", "R", true },
245 { "RHW", "W", true },
246 { "RHW", "D", true },
247 { "RHW", "RW", true },
248 { "RHW", "RD", true },
249 { "RHW", "WD", true },
250 { "RHW", "RWD", true },
251 };
252
253 static bool test_one_durable_open_open_lease(struct torture_context *tctx,
254 struct smb2_tree *tree,
255 const char *fname,
256 struct durable_open_vs_lease test)
257 {
258 NTSTATUS status;
259 TALLOC_CTX *mem_ctx = talloc_new(tctx);
260 struct smb2_handle _h;
261 struct smb2_handle *h = NULL;
262 bool ret = true;
263 struct smb2_create io;
264 struct smb2_lease ls;
265 uint64_t lease;
266 uint32_t caps;
267
268 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
269 if (!(caps & SMB2_CAP_LEASING)) {
270 torture_skip(tctx, "leases are not supported");
271 }
272
273 smb2_util_unlink(tree, fname);
274
275 lease = random();
276
277 smb2_lease_create_share(&io, &ls, false /* dir */, fname,
278 smb2_util_share_access(test.share_mode),
279 lease,
280 smb2_util_lease_state(test.type));
281 io.in.durable_open = true;
282
283 status = smb2_create(tree, mem_ctx, &io);
284 CHECK_STATUS(status, NT_STATUS_OK);
285 _h = io.out.file.handle;
286 h = &_h;
287 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
288 CHECK_VAL(io.out.durable_open, test.expected);
289 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
290 CHECK_VAL(io.out.lease_response.lease_key.data[0], lease);
291 CHECK_VAL(io.out.lease_response.lease_key.data[1], ~lease);
292 CHECK_VAL(io.out.lease_response.lease_state,
293 smb2_util_lease_state(test.type));
294 done:
295 if (h != NULL) {
296 smb2_util_close(tree, *h);
297 }
298 smb2_util_unlink(tree, fname);
299 talloc_free(mem_ctx);
300
301 return ret;
302 }
303
304 bool test_durable_open_open_lease(struct torture_context *tctx,
305 struct smb2_tree *tree)
306 {
307 TALLOC_CTX *mem_ctx = talloc_new(tctx);
308 char fname[256];
309 bool ret = true;
310 int i;
311 uint32_t caps;
312
313 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
314 if (!(caps & SMB2_CAP_LEASING)) {
315 torture_skip(tctx, "leases are not supported");
316 }
317
318 /* Choose a random name in case the state is left a little funky. */
319 snprintf(fname, 256, "durable_open_open_lease_%s.dat", generate_random_str(tctx, 8));
320
321 smb2_util_unlink(tree, fname);
322
323
324 /* test various oplock levels with durable open */
325
326 for (i = 0; i < NUM_LEASE_OPEN_TESTS; i++) {
327 ret = test_one_durable_open_open_lease(tctx,
328 tree,
329 fname,
330 durable_open_vs_lease_table[i]);
331 if (ret == false) {
332 goto done;
333 }
334 }
335
336 done:
337 smb2_util_unlink(tree, fname);
338 talloc_free(tree);
339 talloc_free(mem_ctx);
340
341 return ret;
342 }
343
344 /**
345 * basic test for doing a durable open
346 * and do a durable reopen on the same connection
347 * while the first open is still active (fails)
348 */
349 bool test_durable_open_reopen1(struct torture_context *tctx,
350 struct smb2_tree *tree)
351 {
352 NTSTATUS status;
353 TALLOC_CTX *mem_ctx = talloc_new(tctx);
354 char fname[256];
355 struct smb2_handle _h;
356 struct smb2_handle *h = NULL;
357 struct smb2_create io1, io2;
358 bool ret = true;
359
360 /* Choose a random name in case the state is left a little funky. */
361 snprintf(fname, 256, "durable_open_reopen1_%s.dat",
362 generate_random_str(tctx, 8));
363
364 smb2_util_unlink(tree, fname);
365
366 smb2_oplock_create_share(&io1, fname,
367 smb2_util_share_access(""),
368 smb2_util_oplock_level("b"));
369 io1.in.durable_open = true;
370
371 status = smb2_create(tree, mem_ctx, &io1);
372 CHECK_STATUS(status, NT_STATUS_OK);
373 _h = io1.out.file.handle;
374 h = &_h;
375 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
376 CHECK_VAL(io1.out.durable_open, true);
377 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
378
379 /* try a durable reconnect while the file is still open */
380 ZERO_STRUCT(io2);
381 io2.in.fname = fname;
382 io2.in.durable_handle = h;
383
384 status = smb2_create(tree, mem_ctx, &io2);
385 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
386
387 done:
388 if (h != NULL) {
389 smb2_util_close(tree, *h);
390 }
391
392 smb2_util_unlink(tree, fname);
393
394 talloc_free(tree);
395
396 talloc_free(mem_ctx);
397
398 return ret;
399 }
400
401 /**
402 * basic test for doing a durable open
403 * tcp disconnect, reconnect, do a durable reopen (succeeds)
404 */
405 bool test_durable_open_reopen2(struct torture_context *tctx,
406 struct smb2_tree *tree)
407 {
408 NTSTATUS status;
409 TALLOC_CTX *mem_ctx = talloc_new(tctx);
410 char fname[256];
411 struct smb2_handle _h;
412 struct smb2_handle *h = NULL;
413 struct smb2_create io1, io2;
414 bool ret = true;
415
416 /* Choose a random name in case the state is left a little funky. */
417 snprintf(fname, 256, "durable_open_reopen2_%s.dat",
418 generate_random_str(tctx, 8));
419
420 smb2_util_unlink(tree, fname);
421
422 smb2_oplock_create_share(&io1, fname,
423 smb2_util_share_access(""),
424 smb2_util_oplock_level("b"));
425 io1.in.durable_open = true;
426
427 status = smb2_create(tree, mem_ctx, &io1);
428 CHECK_STATUS(status, NT_STATUS_OK);
429 _h = io1.out.file.handle;
430 h = &_h;
431 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
432 CHECK_VAL(io1.out.durable_open, true);
433 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
434
435 /* disconnect, reconnect and then do durable reopen */
436 talloc_free(tree);
437 tree = NULL;
438
439 if (!torture_smb2_connection(tctx, &tree)) {
440 torture_warning(tctx, "couldn't reconnect, bailing\n");
441 ret = false;
442 goto done;
443 }
444
445 ZERO_STRUCT(io2);
446 io2.in.fname = fname;
447 io2.in.durable_handle = h;
448 h = NULL;
449
450 status = smb2_create(tree, mem_ctx, &io2);
451 CHECK_STATUS(status, NT_STATUS_OK);
452 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
453 CHECK_VAL(io2.out.durable_open, true);
454 CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));
455 _h = io2.out.file.handle;
456 h = &_h;
457
458 done:
459 if (h != NULL) {
460 smb2_util_close(tree, *h);
461 }
462
463 smb2_util_unlink(tree, fname);
464
465 talloc_free(tree);
466
467 talloc_free(mem_ctx);
468
469 return ret;
470 }
471
472 /**
473 * basic test for doing a durable open
474 * tcp disconnect, reconnect with a session reconnect and
475 * do a durable reopen (succeeds)
476 */
477 bool test_durable_open_reopen2a(struct torture_context *tctx,
478 struct smb2_tree *tree)
479 {
480 NTSTATUS status;
481 TALLOC_CTX *mem_ctx = talloc_new(tctx);
482 char fname[256];
483 struct smb2_handle _h;
484 struct smb2_handle *h = NULL;
485 struct smb2_create io1, io2;
486 uint64_t previous_session_id;
487 bool ret = true;
488
489 /* Choose a random name in case the state is left a little funky. */
490 snprintf(fname, 256, "durable_open_reopen2_%s.dat",
491 generate_random_str(tctx, 8));
492
493 smb2_util_unlink(tree, fname);
494
495 smb2_oplock_create_share(&io1, fname,
496 smb2_util_share_access(""),
497 smb2_util_oplock_level("b"));
498 io1.in.durable_open = true;
499
500 status = smb2_create(tree, mem_ctx, &io1);
501 CHECK_STATUS(status, NT_STATUS_OK);
502 _h = io1.out.file.handle;
503 h = &_h;
504 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
505 CHECK_VAL(io1.out.durable_open, true);
506 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
507
508 /* disconnect, reconnect and then do durable reopen */
509 previous_session_id = smb2cli_session_current_id(tree->session->smbXcli);
510 talloc_free(tree);
511 tree = NULL;
512
513 if (!torture_smb2_connection_ext(tctx, previous_session_id, &tree)) {
514 torture_warning(tctx, "couldn't reconnect, bailing\n");
515 ret = false;
516 goto done;
517 }
518
519 ZERO_STRUCT(io2);
520 io2.in.fname = fname;
521 io2.in.durable_handle = h;
522 h = NULL;
523
524 status = smb2_create(tree, mem_ctx, &io2);
525 CHECK_STATUS(status, NT_STATUS_OK);
526 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
527 CHECK_VAL(io2.out.durable_open, true);
528 CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));
529 _h = io2.out.file.handle;
530 h = &_h;
531
532 done:
533 if (h != NULL) {
534 smb2_util_close(tree, *h);
535 }
536
537 smb2_util_unlink(tree, fname);
538
539 talloc_free(tree);
540
541 talloc_free(mem_ctx);
542
543 return ret;
544 }
545
546
547 /**
548 * basic test for doing a durable open:
549 * tdis, new tcon, try durable reopen (fails)
550 */
551 bool test_durable_open_reopen3(struct torture_context *tctx,
552 struct smb2_tree *tree)
553 {
554 NTSTATUS status;
555 TALLOC_CTX *mem_ctx = talloc_new(tctx);
556 char fname[256];
557 struct smb2_handle _h;
558 struct smb2_handle *h = NULL;
559 struct smb2_create io1, io2;
560 bool ret = true;
561 struct smb2_tree *tree2;
562
563 /* Choose a random name in case the state is left a little funky. */
564 snprintf(fname, 256, "durable_open_reopen3_%s.dat",
565 generate_random_str(tctx, 8));
566
567 smb2_util_unlink(tree, fname);
568
569 smb2_oplock_create_share(&io1, fname,
570 smb2_util_share_access(""),
571 smb2_util_oplock_level("b"));
572 io1.in.durable_open = true;
573
574 status = smb2_create(tree, mem_ctx, &io1);
575 CHECK_STATUS(status, NT_STATUS_OK);
576 _h = io1.out.file.handle;
577 h = &_h;
578 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
579 CHECK_VAL(io1.out.durable_open, true);
580 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
581
582 /* disconnect, reconnect and then do durable reopen */
583 status = smb2_tdis(tree);
584 CHECK_STATUS(status, NT_STATUS_OK);
585
586 if (!torture_smb2_tree_connect(tctx, tree->session, mem_ctx, &tree2)) {
587 torture_warning(tctx, "couldn't reconnect to share, bailing\n");
588 ret = false;
589 goto done;
590 }
591
592
593 ZERO_STRUCT(io2);
594 io2.in.fname = fname;
595 io2.in.durable_handle = h;
596
597 status = smb2_create(tree2, mem_ctx, &io2);
598 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
599
600 done:
601 if (h != NULL) {
602 smb2_util_close(tree, *h);
603 }
604
605 smb2_util_unlink(tree2, fname);
606
607 talloc_free(tree);
608
609 talloc_free(mem_ctx);
610
611 return ret;
612 }
613
614 /**
615 * basic test for doing a durable open:
616 * logoff, create a new session, do a durable reopen (succeeds)
617 */
618 bool test_durable_open_reopen4(struct torture_context *tctx,
619 struct smb2_tree *tree)
620 {
621 NTSTATUS status;
622 TALLOC_CTX *mem_ctx = talloc_new(tctx);
623 char fname[256];
624 struct smb2_handle _h;
625 struct smb2_handle *h = NULL;
626 struct smb2_create io1, io2;
627 bool ret = true;
628 struct smb2_transport *transport;
629 struct smb2_session *session2;
630 struct smb2_tree *tree2;
631
632 /* Choose a random name in case the state is left a little funky. */
633 snprintf(fname, 256, "durable_open_reopen4_%s.dat",
634 generate_random_str(tctx, 8));
635
636 smb2_util_unlink(tree, fname);
637
638 smb2_oplock_create_share(&io1, fname,
639 smb2_util_share_access(""),
640 smb2_util_oplock_level("b"));
641 io1.in.durable_open = true;
642 io1.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
643
644 status = smb2_create(tree, mem_ctx, &io1);
645 CHECK_STATUS(status, NT_STATUS_OK);
646 _h = io1.out.file.handle;
647 h = &_h;
648 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
649 CHECK_VAL(io1.out.durable_open, true);
650 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
651
652 /*
653 * do a session logoff, establish a new session and tree
654 * connect on the same transport, and try a durable reopen
655 */
656 transport = tree->session->transport;
657 status = smb2_logoff(tree->session);
658 CHECK_STATUS(status, NT_STATUS_OK);
659
660 if (!torture_smb2_session_setup(tctx, transport,
661 0, /* previous_session_id */
662 mem_ctx, &session2))
663 {
664 torture_warning(tctx, "session setup failed.\n");
665 ret = false;
666 goto done;
667 }
668
669 /*
670 * the session setup has talloc-stolen the transport,
671 * so we can safely free the old tree+session for clarity
672 */
673 TALLOC_FREE(tree);
674
675 if (!torture_smb2_tree_connect(tctx, session2, mem_ctx, &tree2)) {
676 torture_warning(tctx, "tree connect failed.\n");
677 ret = false;
678 goto done;
679 }
680
681 ZERO_STRUCT(io2);
682 io2.in.fname = fname;
683 io2.in.durable_handle = h;
684 h = NULL;
685
686 status = smb2_create(tree2, mem_ctx, &io2);
687 CHECK_STATUS(status, NT_STATUS_OK);
688
689 _h = io2.out.file.handle;
690 h = &_h;
691 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
692 CHECK_VAL(io2.out.durable_open, true);
693 CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));
694
695 done:
696 if (h != NULL) {
697 smb2_util_close(tree2, *h);
698 }
699
700 smb2_util_unlink(tree2, fname);
701
702 talloc_free(tree);
703
704 talloc_free(mem_ctx);
705
706 return ret;
707 }
708
709 bool test_durable_open_delete_on_close1(struct torture_context *tctx,
710 struct smb2_tree *tree)
711 {
712 NTSTATUS status;
713 TALLOC_CTX *mem_ctx = talloc_new(tctx);
714 char fname[256];
715 struct smb2_handle _h;
716 struct smb2_handle *h = NULL;
717 struct smb2_create io1, io2, io3;
718 bool ret = true;
719 struct smb2_transport *transport;
720 struct smb2_session *session2;
721 struct smb2_tree *tree2;
722 union smb_fileinfo info1, info2;
723
724 /* Choose a random name in case the state is left a little funky. */
725 snprintf(fname, 256, "durable_open_delete_on_close1_%s.dat",
726 generate_random_str(tctx, 8));
727
728 smb2_util_unlink(tree, fname);
729
730 smb2_oplock_create_share(&io1, fname,
731 smb2_util_share_access(""),
732 smb2_util_oplock_level("b"));
733 io1.in.durable_open = true;
734 io1.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
735
736 status = smb2_create(tree, mem_ctx, &io1);
737 CHECK_STATUS(status, NT_STATUS_OK);
738 _h = io1.out.file.handle;
739 h = &_h;
740 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
741 CHECK_VAL(io1.out.durable_open, true);
742 CHECK_VAL(io1.out.oplock_level, smb2_util_oplock_level("b"));
743
744 ZERO_STRUCT(info1);
745 info1.internal_information.level = RAW_FILEINFO_INTERNAL_INFORMATION;
746 info1.internal_information.in.file.handle = _h;
747 status = smb2_getinfo_file(tree, tree, &info1);
748 CHECK_STATUS(status, NT_STATUS_OK);
749
750 /*
751 * do a session logoff, establish a new session and tree
752 * connect on the same transport, and try a durable reopen
753 */
754 transport = tree->session->transport;
755 status = smb2_logoff(tree->session);
756 CHECK_STATUS(status, NT_STATUS_OK);
757
758 if (!torture_smb2_session_setup(tctx, transport,
759 0, /* previous_session_id */
760 mem_ctx, &session2))
761 {
762 torture_warning(tctx, "session setup failed.\n");
763 ret = false;
764 goto done;
765 }
766
767 /*
768 * the session setup has talloc-stolen the transport,
769 * so we can safely free the old tree+session for clarity
770 */
771 TALLOC_FREE(tree);
772
773 if (!torture_smb2_tree_connect(tctx, session2, mem_ctx, &tree2)) {
774 torture_warning(tctx, "tree connect failed.\n");
775 ret = false;
776 goto done;
777 }
778
779 ZERO_STRUCT(io3);
780 io3.in.fname = fname;
781 io3.in.durable_handle = h;
782 h = NULL;
783
784 smb2_oplock_create_share(&io2, fname,
785 smb2_util_share_access(""),
786 smb2_util_oplock_level("b"));
787 io2.in.create_options |= NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
788
789 status = smb2_create(tree2, mem_ctx, &io2);
790 CHECK_STATUS(status, NT_STATUS_OK);
791 _h = io2.out.file.handle;
792 h = &_h;
793 CHECK_CREATED(&io2, CREATED, FILE_ATTRIBUTE_ARCHIVE);
794 CHECK_VAL(io2.out.durable_open, false);
795 CHECK_VAL(io2.out.oplock_level, smb2_util_oplock_level("b"));
796
797 ZERO_STRUCT(info2);
798 info2.internal_information.level = RAW_FILEINFO_INTERNAL_INFORMATION;
799 info2.internal_information.in.file.handle = _h;
800 status = smb2_getinfo_file(tree2, tree2, &info2);
801 CHECK_STATUS(status, NT_STATUS_OK);
802
803 CHECK_NOT_VAL(info1.internal_information.out.file_id,
804 info2.internal_information.out.file_id);
805
806 status = smb2_create(tree2, mem_ctx, &io3);
807 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
808
809 done:
810 if (h != NULL) {
811 smb2_util_close(tree2, *h);
812 }
813
814 smb2_util_unlink(tree2, fname);
815
816 talloc_free(tree);
817 talloc_free(tree2);
818
819 talloc_free(mem_ctx);
820
821 return ret;
822 }
823
824 /*
825 basic testing of SMB2 durable opens
826 regarding the position information on the handle
827 */
828 bool test_durable_open_file_position(struct torture_context *tctx,
829 struct smb2_tree *tree1,
830 struct smb2_tree *tree2)
831 {
832 TALLOC_CTX *mem_ctx = talloc_new(tctx);
833 struct smb2_handle h1, h2;
834 struct smb2_create io1, io2;
835 NTSTATUS status;
836 const char *fname = "durable_open_position.dat";
837 union smb_fileinfo qfinfo;
838 union smb_setfileinfo sfinfo;
839 bool ret = true;
840 uint64_t pos;
841
842 smb2_util_unlink(tree1, fname);
843
844 smb2_oplock_create(&io1, fname, SMB2_OPLOCK_LEVEL_BATCH);
845 io1.in.durable_open = true;
846
847 status = smb2_create(tree1, mem_ctx, &io1);
848 CHECK_STATUS(status, NT_STATUS_OK);
849 h1 = io1.out.file.handle;
850 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
851 CHECK_VAL(io1.out.durable_open, true);
852 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
853
854 /* TODO: check extra blob content */
855
856 ZERO_STRUCT(qfinfo);
857 qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
858 qfinfo.generic.in.file.handle = h1;
859 status = smb2_getinfo_file(tree1, mem_ctx, &qfinfo);
860 CHECK_STATUS(status, NT_STATUS_OK);
861 CHECK_VAL(qfinfo.position_information.out.position, 0);
862 pos = qfinfo.position_information.out.position;
863 torture_comment(tctx, "position: %llu\n",
864 (unsigned long long)pos);
865
866 ZERO_STRUCT(sfinfo);
867 sfinfo.generic.level = RAW_SFILEINFO_POSITION_INFORMATION;
868 sfinfo.generic.in.file.handle = h1;
869 sfinfo.position_information.in.position = 0x1000;
870 status = smb2_setinfo_file(tree1, &sfinfo);
871 CHECK_STATUS(status, NT_STATUS_OK);
872
873 ZERO_STRUCT(qfinfo);
874 qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
875 qfinfo.generic.in.file.handle = h1;
876 status = smb2_getinfo_file(tree1, mem_ctx, &qfinfo);
877 CHECK_STATUS(status, NT_STATUS_OK);
878 CHECK_VAL(qfinfo.position_information.out.position, 0x1000);
879 pos = qfinfo.position_information.out.position;
880 torture_comment(tctx, "position: %llu\n",
881 (unsigned long long)pos);
882
883 talloc_free(tree1);
884 tree1 = NULL;
885
886 ZERO_STRUCT(qfinfo);
887 qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
888 qfinfo.generic.in.file.handle = h1;
889 status = smb2_getinfo_file(tree2, mem_ctx, &qfinfo);
890 CHECK_STATUS(status, NT_STATUS_FILE_CLOSED);
891
892 ZERO_STRUCT(io2);
893 io2.in.fname = fname;
894 io2.in.durable_handle = &h1;
895
896 status = smb2_create(tree2, mem_ctx, &io2);
897 CHECK_STATUS(status, NT_STATUS_OK);
898 CHECK_VAL(io2.out.durable_open, true);
899 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
900 CHECK_VAL(io2.out.reserved, 0x00);
901 CHECK_VAL(io2.out.create_action, NTCREATEX_ACTION_EXISTED);
902 CHECK_VAL(io2.out.alloc_size, 0);
903 CHECK_VAL(io2.out.size, 0);
904 CHECK_VAL(io2.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
905 CHECK_VAL(io2.out.reserved2, 0);
906
907 h2 = io2.out.file.handle;
908
909 ZERO_STRUCT(qfinfo);
910 qfinfo.generic.level = RAW_FILEINFO_POSITION_INFORMATION;
911 qfinfo.generic.in.file.handle = h2;
912 status = smb2_getinfo_file(tree2, mem_ctx, &qfinfo);
913 CHECK_STATUS(status, NT_STATUS_OK);
914 CHECK_VAL(qfinfo.position_information.out.position, 0x1000);
915 pos = qfinfo.position_information.out.position;
916 torture_comment(tctx, "position: %llu\n",
917 (unsigned long long)pos);
918
919 smb2_util_close(tree2, h2);
920
921 talloc_free(mem_ctx);
922
923 smb2_util_unlink(tree2, fname);
924 done:
925 talloc_free(tree1);
926 talloc_free(tree2);
927
928 return ret;
929 }
930
931 /*
932 Open, disconnect, oplock break, reconnect.
933 */
934 bool test_durable_open_oplock(struct torture_context *tctx,
935 struct smb2_tree *tree1,
936 struct smb2_tree *tree2)
937 {
938 TALLOC_CTX *mem_ctx = talloc_new(tctx);
939 struct smb2_create io1, io2;
940 struct smb2_handle h1, h2;
941 NTSTATUS status;
942 char fname[256];
943 bool ret = true;
944
945 /* Choose a random name in case the state is left a little funky. */
946 snprintf(fname, 256, "durable_open_oplock_%s.dat", generate_random_str(tctx, 8));
947
948 /* Clean slate */
949 smb2_util_unlink(tree1, fname);
950
951 /* Create with batch oplock */
952 smb2_oplock_create(&io1, fname, SMB2_OPLOCK_LEVEL_BATCH);
953 io1.in.durable_open = true;
954
955 io2 = io1;
956 io2.in.create_disposition = NTCREATEX_DISP_OPEN;
957
958 status = smb2_create(tree1, mem_ctx, &io1);
959 CHECK_STATUS(status, NT_STATUS_OK);
960 h1 = io1.out.file.handle;
961 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
962 CHECK_VAL(io1.out.durable_open, true);
963 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
964
965 /* Disconnect after getting the batch */
966 talloc_free(tree1);
967 tree1 = NULL;
968
969 /*
970 * Windows7 (build 7000) will break a batch oplock immediately if the
971 * original client is gone. (ZML: This seems like a bug. It should give
972 * some time for the client to reconnect!)
973 */
974 status = smb2_create(tree2, mem_ctx, &io2);
975 CHECK_STATUS(status, NT_STATUS_OK);
976 h2 = io2.out.file.handle;
977 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
978 CHECK_VAL(io2.out.durable_open, true);
979 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
980
981 /* What if tree1 tries to come back and reclaim? */
982 if (!torture_smb2_connection(tctx, &tree1)) {
983 torture_warning(tctx, "couldn't reconnect, bailing\n");
984 ret = false;
985 goto done;
986 }
987
988 ZERO_STRUCT(io1);
989 io1.in.fname = fname;
990 io1.in.durable_handle = &h1;
991
992 status = smb2_create(tree1, mem_ctx, &io1);
993 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
994
995 done:
996 smb2_util_close(tree2, h2);
997 smb2_util_unlink(tree2, fname);
998
999 talloc_free(tree1);
1000 talloc_free(tree2);
1001
1002 return ret;
1003 }
1004
1005 /*
1006 Open, disconnect, lease break, reconnect.
1007 */
1008 bool test_durable_open_lease(struct torture_context *tctx,
1009 struct smb2_tree *tree1,
1010 struct smb2_tree *tree2)
1011 {
1012 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1013 struct smb2_create io1, io2;
1014 struct smb2_lease ls1, ls2;
1015 struct smb2_handle h1, h2;
1016 NTSTATUS status;
1017 char fname[256];
1018 bool ret = true;
1019 uint64_t lease1, lease2;
1020 uint32_t caps;
1021
1022 caps = smb2cli_conn_server_capabilities(tree1->session->transport->conn);
1023 if (!(caps & SMB2_CAP_LEASING)) {
1024 torture_skip(tctx, "leases are not supported");
1025 }
1026
1027 /*
1028 * Choose a random name and random lease in case the state is left a
1029 * little funky.
1030 */
1031 lease1 = random();
1032 lease2 = random();
1033 snprintf(fname, 256, "durable_open_lease_%s.dat", generate_random_str(tctx, 8));
1034
1035 /* Clean slate */
1036 smb2_util_unlink(tree1, fname);
1037
1038 /* Create with lease */
1039 smb2_lease_create(&io1, &ls1, false /* dir */, fname,
1040 lease1, smb2_util_lease_state("RHW"));
1041 io1.in.durable_open = true;
1042
1043 smb2_lease_create(&io2, &ls2, false /* dir */, fname,
1044 lease2, smb2_util_lease_state("RHW"));
1045 io2.in.durable_open = true;
1046 io2.in.create_disposition = NTCREATEX_DISP_OPEN;
1047
1048 status = smb2_create(tree1, mem_ctx, &io1);
1049 CHECK_STATUS(status, NT_STATUS_OK);
1050 h1 = io1.out.file.handle;
1051 CHECK_VAL(io1.out.durable_open, true);
1052 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1053
1054 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1055 CHECK_VAL(io1.out.lease_response.lease_key.data[0], lease1);
1056 CHECK_VAL(io1.out.lease_response.lease_key.data[1], ~lease1);
1057 CHECK_VAL(io1.out.lease_response.lease_state,
1058 SMB2_LEASE_READ|SMB2_LEASE_HANDLE|SMB2_LEASE_WRITE);
1059
1060 /* Disconnect after getting the lease */
1061 talloc_free(tree1);
1062 tree1 = NULL;
1063
1064 /*
1065 * Windows7 (build 7000) will grant an RH lease immediate (not an RHW?)
1066 * even if the original client is gone. (ZML: This seems like a bug. It
1067 * should give some time for the client to reconnect! And why RH?)
1068 *
1069 * obnox: Current windows 7 and w2k8r2 grant RHW instead of RH.
1070 * Test is adapted accordingly.
1071 */
1072 status = smb2_create(tree2, mem_ctx, &io2);
1073 CHECK_STATUS(status, NT_STATUS_OK);
1074 h2 = io2.out.file.handle;
1075 CHECK_VAL(io2.out.durable_open, true);
1076 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1077
1078 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1079 CHECK_VAL(io2.out.lease_response.lease_key.data[0], lease2);
1080 CHECK_VAL(io2.out.lease_response.lease_key.data[1], ~lease2);
1081 CHECK_VAL(io2.out.lease_response.lease_state,
1082 SMB2_LEASE_READ|SMB2_LEASE_HANDLE|SMB2_LEASE_WRITE);
1083
1084 /* What if tree1 tries to come back and reclaim? */
1085 if (!torture_smb2_connection(tctx, &tree1)) {
1086 torture_warning(tctx, "couldn't reconnect, bailing\n");
1087 ret = false;
1088 goto done;
1089 }
1090
1091 ZERO_STRUCT(io1);
1092 io1.in.fname = fname;
1093 io1.in.durable_handle = &h1;
1094 io1.in.lease_request = &ls1;
1095
1096 status = smb2_create(tree1, mem_ctx, &io1);
1097 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1098
1099 done:
1100 smb2_util_close(tree2, h2);
1101 smb2_util_unlink(tree2, fname);
1102
1103 talloc_free(tree1);
1104 talloc_free(tree2);
1105
1106 return ret;
1107 }
1108
1109 bool test_durable_open_lock_oplock(struct torture_context *tctx,
1110 struct smb2_tree *tree)
1111 {
1112 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1113 struct smb2_create io;
1114 struct smb2_handle h;
1115 struct smb2_lock lck;
1116 struct smb2_lock_element el[2];
1117 NTSTATUS status;
1118 char fname[256];
1119 bool ret = true;
1120
1121 /*
1122 */
1123 snprintf(fname, 256, "durable_open_oplock_lock_%s.dat", generate_random_str(tctx, 8));
1124
1125 /* Clean slate */
1126 smb2_util_unlink(tree, fname);
1127
1128 /* Create with lease */
1129
1130 smb2_oplock_create_share(&io, fname,
1131 smb2_util_share_access(""),
1132 smb2_util_oplock_level("b"));
1133 io.in.durable_open = true;
1134
1135 status = smb2_create(tree, mem_ctx, &io);
1136 CHECK_STATUS(status, NT_STATUS_OK);
1137 h = io.out.file.handle;
1138 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1139
1140 CHECK_VAL(io.out.durable_open, true);
1141 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("b"));
1142
1143 ZERO_STRUCT(lck);
1144 ZERO_STRUCT(el);
1145 lck.in.locks = el;
1146 lck.in.lock_count = 0x0001;
1147 lck.in.lock_sequence = 0x00000000;
1148 lck.in.file.handle = h;
1149 el[0].offset = 0;
1150 el[0].length = 1;
1151 el[0].reserved = 0x00000000;
1152 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
1153 status = smb2_lock(tree, &lck);
1154 CHECK_STATUS(status, NT_STATUS_OK);
1155
1156 /* Disconnect/Reconnect. */
1157 talloc_free(tree);
1158 tree = NULL;
1159
1160 if (!torture_smb2_connection(tctx, &tree)) {
1161 torture_warning(tctx, "couldn't reconnect, bailing\n");
1162 ret = false;
1163 goto done;
1164 }
1165
1166 ZERO_STRUCT(io);
1167 io.in.fname = fname;
1168 io.in.durable_handle = &h;
1169
1170 status = smb2_create(tree, mem_ctx, &io);
1171 CHECK_STATUS(status, NT_STATUS_OK);
1172 h = io.out.file.handle;
1173
1174 lck.in.file.handle = h;
1175 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
1176 status = smb2_lock(tree, &lck);
1177 CHECK_STATUS(status, NT_STATUS_OK);
1178
1179 done:
1180 smb2_util_close(tree, h);
1181 smb2_util_unlink(tree, fname);
1182 talloc_free(tree);
1183
1184 return ret;
1185 }
1186
1187 /*
1188 Open, take BRL, disconnect, reconnect.
1189 */
1190 bool test_durable_open_lock_lease(struct torture_context *tctx,
1191 struct smb2_tree *tree)
1192 {
1193 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1194 struct smb2_create io;
1195 struct smb2_lease ls;
1196 struct smb2_handle h;
1197 struct smb2_lock lck;
1198 struct smb2_lock_element el[2];
1199 NTSTATUS status;
1200 char fname[256];
1201 bool ret = true;
1202 uint64_t lease;
1203 uint32_t caps;
1204
1205 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1206 if (!(caps & SMB2_CAP_LEASING)) {
1207 torture_skip(tctx, "leases are not supported");
1208 }
1209
1210 /*
1211 * Choose a random name and random lease in case the state is left a
1212 * little funky.
1213 */
1214 lease = random();
1215 snprintf(fname, 256, "durable_open_lease_lock_%s.dat", generate_random_str(tctx, 8));
1216
1217 /* Clean slate */
1218 smb2_util_unlink(tree, fname);
1219
1220 /* Create with lease */
1221
1222 smb2_lease_create(&io, &ls, false /* dir */, fname, lease,
1223 smb2_util_lease_state("RWH"));
1224 io.in.durable_open = true;
1225
1226 status = smb2_create(tree, mem_ctx, &io);
1227 CHECK_STATUS(status, NT_STATUS_OK);
1228 h = io.out.file.handle;
1229 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1230
1231 CHECK_VAL(io.out.durable_open, true);
1232 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1233 CHECK_VAL(io.out.lease_response.lease_key.data[0], lease);
1234 CHECK_VAL(io.out.lease_response.lease_key.data[1], ~lease);
1235 CHECK_VAL(io.out.lease_response.lease_state,
1236 SMB2_LEASE_READ|SMB2_LEASE_HANDLE|SMB2_LEASE_WRITE);
1237
1238 ZERO_STRUCT(lck);
1239 ZERO_STRUCT(el);
1240 lck.in.locks = el;
1241 lck.in.lock_count = 0x0001;
1242 lck.in.lock_sequence = 0x00000000;
1243 lck.in.file.handle = h;
1244 el[0].offset = 0;
1245 el[0].length = 1;
1246 el[0].reserved = 0x00000000;
1247 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
1248 status = smb2_lock(tree, &lck);
1249 CHECK_STATUS(status, NT_STATUS_OK);
1250
1251 /* Disconnect/Reconnect. */
1252 talloc_free(tree);
1253 tree = NULL;
1254
1255 if (!torture_smb2_connection(tctx, &tree)) {
1256 torture_warning(tctx, "couldn't reconnect, bailing\n");
1257 ret = false;
1258 goto done;
1259 }
1260
1261 ZERO_STRUCT(io);
1262 io.in.fname = fname;
1263 io.in.durable_handle = &h;
1264 io.in.lease_request = &ls;
1265
1266 status = smb2_create(tree, mem_ctx, &io);
1267 CHECK_STATUS(status, NT_STATUS_OK);
1268 h = io.out.file.handle;
1269
1270 lck.in.file.handle = h;
1271 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
1272 status = smb2_lock(tree, &lck);
1273 CHECK_STATUS(status, NT_STATUS_OK);
1274
1275 done:
1276 smb2_util_close(tree, h);
1277 smb2_util_unlink(tree, fname);
1278 talloc_free(tree);
1279
1280 return ret;
1281 }
1282
1283 /**
1284 * Open with a RH lease, disconnect, open in another tree, reconnect.
1285 *
1286 * This test actually demonstrates a minimum level of respect for the durable
1287 * open in the face of another open. As long as this test shows an inability to
1288 * reconnect after an open, the oplock/lease tests above will certainly
1289 * demonstrate an error on reconnect.
1290 */
1291 bool test_durable_open_open2_lease(struct torture_context *tctx,
1292 struct smb2_tree *tree1,
1293 struct smb2_tree *tree2)
1294 {
1295 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1296 struct smb2_create io1, io2;
1297 struct smb2_lease ls;
1298 struct smb2_handle h1, h2;
1299 NTSTATUS status;
1300 char fname[256];
1301 bool ret = true;
1302 uint64_t lease;
1303 uint32_t caps;
1304
1305 caps = smb2cli_conn_server_capabilities(tree1->session->transport->conn);
1306 if (!(caps & SMB2_CAP_LEASING)) {
1307 torture_skip(tctx, "leases are not supported");
1308 }
1309
1310 /*
1311 * Choose a random name and random lease in case the state is left a
1312 * little funky.
1313 */
1314 lease = random();
1315 snprintf(fname, 256, "durable_open_open2_lease_%s.dat",
1316 generate_random_str(tctx, 8));
1317
1318 /* Clean slate */
1319 smb2_util_unlink(tree1, fname);
1320
1321 /* Create with lease */
1322 smb2_lease_create_share(&io1, &ls, false /* dir */, fname,
1323 smb2_util_share_access(""),
1324 lease,
1325 smb2_util_lease_state("RH"));
1326 io1.in.durable_open = true;
1327
1328 status = smb2_create(tree1, mem_ctx, &io1);
1329 CHECK_STATUS(status, NT_STATUS_OK);
1330 h1 = io1.out.file.handle;
1331 CHECK_VAL(io1.out.durable_open, true);
1332 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1333
1334 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE);
1335 CHECK_VAL(io1.out.lease_response.lease_key.data[0], lease);
1336 CHECK_VAL(io1.out.lease_response.lease_key.data[1], ~lease);
1337 CHECK_VAL(io1.out.lease_response.lease_state,
1338 smb2_util_lease_state("RH"));
1339
1340 /* Disconnect */
1341 talloc_free(tree1);
1342 tree1 = NULL;
1343
1344 /* Open the file in tree2 */
1345 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
1346
1347 status = smb2_create(tree2, mem_ctx, &io2);
1348 CHECK_STATUS(status, NT_STATUS_OK);
1349 h2 = io2.out.file.handle;
1350 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1351
1352 /* Reconnect */
1353 if (!torture_smb2_connection(tctx, &tree1)) {
1354 torture_warning(tctx, "couldn't reconnect, bailing\n");
1355 ret = false;
1356 goto done;
1357 }
1358
1359 ZERO_STRUCT(io1);
1360 io1.in.fname = fname;
1361 io1.in.durable_handle = &h1;
1362 io1.in.lease_request = &ls;
1363
1364 /*
1365 * Windows7 (build 7000) will give away an open immediately if the
1366 * original client is gone. (ZML: This seems like a bug. It should give
1367 * some time for the client to reconnect!)
1368 */
1369 status = smb2_create(tree1, mem_ctx, &io1);
1370 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1371 h1 = io1.out.file.handle;
1372
1373 done:
1374 smb2_util_close(tree2, h2);
1375 smb2_util_unlink(tree2, fname);
1376 smb2_util_close(tree1, h1);
1377 smb2_util_unlink(tree1, fname);
1378
1379 talloc_free(tree1);
1380 talloc_free(tree2);
1381
1382 return ret;
1383 }
1384
1385 /**
1386 * Open with a batch oplock, disconnect, open in another tree, reconnect.
1387 *
1388 * This test actually demonstrates a minimum level of respect for the durable
1389 * open in the face of another open. As long as this test shows an inability to
1390 * reconnect after an open, the oplock/lease tests above will certainly
1391 * demonstrate an error on reconnect.
1392 */
1393 bool test_durable_open_open2_oplock(struct torture_context *tctx,
1394 struct smb2_tree *tree1,
1395 struct smb2_tree *tree2)
1396 {
1397 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1398 struct smb2_create io1, io2;
1399 struct smb2_handle h1, h2;
1400 NTSTATUS status;
1401 char fname[256];
1402 bool ret = true;
1403
1404 /*
1405 * Choose a random name and random lease in case the state is left a
1406 * little funky.
1407 */
1408 snprintf(fname, 256, "durable_open_open2_oplock_%s.dat",
1409 generate_random_str(tctx, 8));
1410
1411 /* Clean slate */
1412 smb2_util_unlink(tree1, fname);
1413
1414 /* Create with batch oplock */
1415 smb2_oplock_create(&io1, fname, SMB2_OPLOCK_LEVEL_BATCH);
1416 io1.in.durable_open = true;
1417
1418 status = smb2_create(tree1, mem_ctx, &io1);
1419 CHECK_STATUS(status, NT_STATUS_OK);
1420 h1 = io1.out.file.handle;
1421 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1422 CHECK_VAL(io1.out.durable_open, true);
1423 CHECK_VAL(io1.out.oplock_level, SMB2_OPLOCK_LEVEL_BATCH);
1424
1425 /* Disconnect */
1426 talloc_free(tree1);
1427 tree1 = NULL;
1428
1429 /* Open the file in tree2 */
1430 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
1431
1432 status = smb2_create(tree2, mem_ctx, &io2);
1433 CHECK_STATUS(status, NT_STATUS_OK);
1434 h2 = io2.out.file.handle;
1435 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1436
1437 /* Reconnect */
1438 if (!torture_smb2_connection(tctx, &tree1)) {
1439 torture_warning(tctx, "couldn't reconnect, bailing\n");
1440 ret = false;
1441 goto done;
1442 }
1443
1444 ZERO_STRUCT(io1);
1445 io1.in.fname = fname;
1446 io1.in.durable_handle = &h1;
1447
1448 status = smb2_create(tree1, mem_ctx, &io1);
1449 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
1450 h1 = io1.out.file.handle;
1451
1452 done:
1453 smb2_util_close(tree2, h2);
1454 smb2_util_unlink(tree2, fname);
1455 smb2_util_close(tree1, h1);
1456 smb2_util_unlink(tree1, fname);
1457
1458 talloc_free(tree1);
1459 talloc_free(tree2);
1460
1461 return ret;
1462 }
1463
1464 struct torture_suite *torture_smb2_durable_open_init(void)
1465 {
1466 struct torture_suite *suite =
1467 torture_suite_create(talloc_autofree_context(), "durable-open");
1468
1469 torture_suite_add_1smb2_test(suite, "open-oplock", test_durable_open_open_oplock);
1470 torture_suite_add_1smb2_test(suite, "open-lease", test_durable_open_open_lease);
1471 torture_suite_add_1smb2_test(suite, "reopen1", test_durable_open_reopen1);
1472 torture_suite_add_1smb2_test(suite, "reopen2", test_durable_open_reopen2);
1473 torture_suite_add_1smb2_test(suite, "reopen2a", test_durable_open_reopen2a);
1474 torture_suite_add_1smb2_test(suite, "reopen3", test_durable_open_reopen3);
1475 torture_suite_add_1smb2_test(suite, "reopen4", test_durable_open_reopen4);
1476 torture_suite_add_1smb2_test(suite, "delete_on_close1",
1477 test_durable_open_delete_on_close1);
1478 torture_suite_add_2smb2_test(suite, "file-position",
1479 test_durable_open_file_position);
1480 torture_suite_add_2smb2_test(suite, "oplock", test_durable_open_oplock);
1481 torture_suite_add_2smb2_test(suite, "lease", test_durable_open_lease);
1482 torture_suite_add_1smb2_test(suite, "lock-oplock", test_durable_open_lock_oplock);
1483 torture_suite_add_1smb2_test(suite, "lock-lease", test_durable_open_lock_lease);
1484 torture_suite_add_2smb2_test(suite, "open2-lease",
1485 test_durable_open_open2_lease);
1486 torture_suite_add_2smb2_test(suite, "open2-oplock",
1487 test_durable_open_open2_oplock);
1488
1489 suite->description = talloc_strdup(suite, "SMB2-DURABLE-OPEN tests");
1490
1491 return suite;
1492 }
reg import