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