Debian Codegraph @

source4/torture/smb2/lease.c

raw
1 /*
2 Unix SMB/CIFS implementation.
3
4 test suite for SMB2 leases
5
6 Copyright (C) Zachary Loafman 2009
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include <tevent.h>
24 #include "libcli/smb2/smb2.h"
25 #include "libcli/smb2/smb2_calls.h"
26 #include "torture/torture.h"
27 #include "torture/smb2/proto.h"
28 #include "torture/util.h"
29 #include "libcli/smb/smbXcli_base.h"
30 #include "libcli/security/security.h"
31 #include "lib/param/param.h"
32 #include "lease_break_handler.h"
33
34 #define CHECK_VAL(v, correct) do { \
35 if ((v) != (correct)) { \
36 torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s got 0x%x - should be 0x%x\n", \
37 __location__, #v, (int)(v), (int)(correct)); \
38 ret = false; \
39 }} while (0)
40
41 #define CHECK_STATUS(status, correct) do { \
42 if (!NT_STATUS_EQUAL(status, correct)) { \
43 torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
44 nt_errstr(status), nt_errstr(correct)); \
45 ret = false; \
46 goto done; \
47 }} while (0)
48
49 #define CHECK_CREATED(__io, __created, __attribute) \
50 do { \
51 CHECK_VAL((__io)->out.create_action, NTCREATEX_ACTION_ ## __created); \
52 CHECK_VAL((__io)->out.size, 0); \
53 CHECK_VAL((__io)->out.file_attr, (__attribute)); \
54 CHECK_VAL((__io)->out.reserved2, 0); \
55 } while(0)
56
57 #define CHECK_LEASE(__io, __state, __oplevel, __key, __flags) \
58 do { \
59 CHECK_VAL((__io)->out.lease_response.lease_version, 1); \
60 if (__oplevel) { \
61 CHECK_VAL((__io)->out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE); \
62 CHECK_VAL((__io)->out.lease_response.lease_key.data[0], (__key)); \
63 CHECK_VAL((__io)->out.lease_response.lease_key.data[1], ~(__key)); \
64 CHECK_VAL((__io)->out.lease_response.lease_state, smb2_util_lease_state(__state)); \
65 } else { \
66 CHECK_VAL((__io)->out.oplock_level, SMB2_OPLOCK_LEVEL_NONE); \
67 CHECK_VAL((__io)->out.lease_response.lease_key.data[0], 0); \
68 CHECK_VAL((__io)->out.lease_response.lease_key.data[1], 0); \
69 CHECK_VAL((__io)->out.lease_response.lease_state, 0); \
70 } \
71 \
72 CHECK_VAL((__io)->out.lease_response.lease_flags, (__flags)); \
73 CHECK_VAL((__io)->out.lease_response.lease_duration, 0); \
74 CHECK_VAL((__io)->out.lease_response.lease_epoch, 0); \
75 } while(0)
76
77 #define CHECK_LEASE_V2(__io, __state, __oplevel, __key, __flags, __parent, __epoch) \
78 do { \
79 CHECK_VAL((__io)->out.lease_response_v2.lease_version, 2); \
80 if (__oplevel) { \
81 CHECK_VAL((__io)->out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE); \
82 CHECK_VAL((__io)->out.lease_response_v2.lease_key.data[0], (__key)); \
83 CHECK_VAL((__io)->out.lease_response_v2.lease_key.data[1], ~(__key)); \
84 CHECK_VAL((__io)->out.lease_response_v2.lease_state, smb2_util_lease_state(__state)); \
85 } else { \
86 CHECK_VAL((__io)->out.oplock_level, SMB2_OPLOCK_LEVEL_NONE); \
87 CHECK_VAL((__io)->out.lease_response_v2.lease_key.data[0], 0); \
88 CHECK_VAL((__io)->out.lease_response_v2.lease_key.data[1], 0); \
89 CHECK_VAL((__io)->out.lease_response_v2.lease_state, 0); \
90 } \
91 \
92 CHECK_VAL((__io)->out.lease_response_v2.lease_flags, __flags); \
93 if (__flags & SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET) { \
94 CHECK_VAL((__io)->out.lease_response_v2.parent_lease_key.data[0], (__parent)); \
95 CHECK_VAL((__io)->out.lease_response_v2.parent_lease_key.data[1], ~(__parent)); \
96 } else { \
97 CHECK_VAL((__io)->out.lease_response_v2.parent_lease_key.data[0], 0); \
98 CHECK_VAL((__io)->out.lease_response_v2.parent_lease_key.data[1], 0); \
99 } \
100 CHECK_VAL((__io)->out.lease_response_v2.lease_duration, 0); \
101 CHECK_VAL((__io)->out.lease_response_v2.lease_epoch, (__epoch)); \
102 } while(0)
103
104 static const uint64_t LEASE1 = 0xBADC0FFEE0DDF00Dull;
105 static const uint64_t LEASE2 = 0xDEADBEEFFEEDBEADull;
106 static const uint64_t LEASE3 = 0xDAD0FFEDD00DF00Dull;
107 static const uint64_t LEASE4 = 0xBAD0FFEDD00DF00Dull;
108
109 #define NREQUEST_RESULTS 8
110 static const char *request_results[NREQUEST_RESULTS][2] = {
111 { "", "" },
112 { "R", "R" },
113 { "H", "" },
114 { "W", "" },
115 { "RH", "RH" },
116 { "RW", "RW" },
117 { "HW", "" },
118 { "RHW", "RHW" },
119 };
120
121 static bool test_lease_request(struct torture_context *tctx,
122 struct smb2_tree *tree)
123 {
124 TALLOC_CTX *mem_ctx = talloc_new(tctx);
125 struct smb2_create io;
126 struct smb2_lease ls;
127 struct smb2_handle h1 = {};
128 struct smb2_handle h2 = {};
129 NTSTATUS status;
130 const char *fname = "lease_request.dat";
131 const char *fname2 = "lease_request.2.dat";
132 const char *sname = "lease_request.dat:stream";
133 const char *dname = "lease_request.dir";
134 bool ret = true;
135 int i;
136 uint32_t caps;
137
138 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
139 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
140
141 smb2_util_unlink(tree, fname);
142 smb2_util_unlink(tree, fname2);
143 smb2_util_rmdir(tree, dname);
144
145 /* Win7 is happy to grant RHW leases on files. */
146 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
147 status = smb2_create(tree, mem_ctx, &io);
148 CHECK_STATUS(status, NT_STATUS_OK);
149 h1 = io.out.file.handle;
150 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
151 CHECK_LEASE(&io, "RHW", true, LEASE1, 0);
152
153 /* But will reject leases on directories. */
154 if (!(caps & SMB2_CAP_DIRECTORY_LEASING)) {
155 smb2_lease_create(&io, &ls, true, dname, LEASE2, smb2_util_lease_state("RHW"));
156 status = smb2_create(tree, mem_ctx, &io);
157 CHECK_STATUS(status, NT_STATUS_OK);
158 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_DIRECTORY);
159 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
160 smb2_util_close(tree, io.out.file.handle);
161 }
162
163 /* Also rejects multiple files leased under the same key. */
164 smb2_lease_create(&io, &ls, true, fname2, LEASE1, smb2_util_lease_state("RHW"));
165 status = smb2_create(tree, mem_ctx, &io);
166 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
167
168 /* And grants leases on streams (with separate leasekey). */
169 smb2_lease_create(&io, &ls, false, sname, LEASE2, smb2_util_lease_state("RHW"));
170 status = smb2_create(tree, mem_ctx, &io);
171 h2 = io.out.file.handle;
172 CHECK_STATUS(status, NT_STATUS_OK);
173 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
174 CHECK_LEASE(&io, "RHW", true, LEASE2, 0);
175 smb2_util_close(tree, h2);
176
177 smb2_util_close(tree, h1);
178
179 /* Now see what combos are actually granted. */
180 for (i = 0; i < NREQUEST_RESULTS; i++) {
181 torture_comment(tctx, "Requesting lease type %s(%x),"
182 " expecting %s(%x)\n",
183 request_results[i][0], smb2_util_lease_state(request_results[i][0]),
184 request_results[i][1], smb2_util_lease_state(request_results[i][1]));
185 smb2_lease_create(&io, &ls, false, fname, LEASE1,
186 smb2_util_lease_state(request_results[i][0]));
187 status = smb2_create(tree, mem_ctx, &io);
188 h2 = io.out.file.handle;
189 CHECK_STATUS(status, NT_STATUS_OK);
190 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
191 CHECK_LEASE(&io, request_results[i][1], true, LEASE1, 0);
192 smb2_util_close(tree, io.out.file.handle);
193 }
194
195 done:
196 smb2_util_close(tree, h1);
197 smb2_util_close(tree, h2);
198
199 smb2_util_unlink(tree, fname);
200 smb2_util_unlink(tree, fname2);
201 smb2_util_rmdir(tree, dname);
202
203 talloc_free(mem_ctx);
204
205 return ret;
206 }
207
208 static bool test_lease_upgrade(struct torture_context *tctx,
209 struct smb2_tree *tree)
210 {
211 TALLOC_CTX *mem_ctx = talloc_new(tctx);
212 struct smb2_create io;
213 struct smb2_lease ls;
214 struct smb2_handle h = {};
215 struct smb2_handle hnew = {};
216 NTSTATUS status;
217 const char *fname = "lease_upgrade.dat";
218 bool ret = true;
219 uint32_t caps;
220
221 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
222 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
223
224 smb2_util_unlink(tree, fname);
225
226 /* Grab a RH lease. */
227 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
228 status = smb2_create(tree, mem_ctx, &io);
229 CHECK_STATUS(status, NT_STATUS_OK);
230 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
231 CHECK_LEASE(&io, "RH", true, LEASE1, 0);
232 h = io.out.file.handle;
233
234 /* Upgrades (sidegrades?) to RW leave us with an RH. */
235 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RW"));
236 status = smb2_create(tree, mem_ctx, &io);
237 CHECK_STATUS(status, NT_STATUS_OK);
238 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
239 CHECK_LEASE(&io, "RH", true, LEASE1, 0);
240 hnew = io.out.file.handle;
241
242 smb2_util_close(tree, hnew);
243
244 /* Upgrade to RHW lease. */
245 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
246 status = smb2_create(tree, mem_ctx, &io);
247 CHECK_STATUS(status, NT_STATUS_OK);
248 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
249 CHECK_LEASE(&io, "RHW", true, LEASE1, 0);
250 hnew = io.out.file.handle;
251
252 smb2_util_close(tree, h);
253 h = hnew;
254
255 /* Attempt to downgrade - original lease state is maintained. */
256 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
257 status = smb2_create(tree, mem_ctx, &io);
258 CHECK_STATUS(status, NT_STATUS_OK);
259 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
260 CHECK_LEASE(&io, "RHW", true, LEASE1, 0);
261 hnew = io.out.file.handle;
262
263 smb2_util_close(tree, hnew);
264
265 done:
266 smb2_util_close(tree, h);
267 smb2_util_close(tree, hnew);
268
269 smb2_util_unlink(tree, fname);
270
271 talloc_free(mem_ctx);
272
273 return ret;
274 }
275
276 /**
277 * upgrade2 test.
278 * full matrix of lease upgrade combinations
279 * (non-contended case)
280 *
281 * The summary of the behaviour is this:
282 * -------------------------------------
283 * An uncontended lease upgrade results in a change
284 * if and only if the requested lease state is
285 * - valid, and
286 * - strictly a superset of the lease state already held.
287 *
288 * In that case the resulting lease state is the one
289 * requested in the upgrade.
290 */
291 struct lease_upgrade2_test {
292 const char *initial;
293 const char *upgrade_to;
294 const char *expected;
295 };
296
297 #define NUM_LEASE_TYPES 5
298 #define NUM_UPGRADE_TESTS ( NUM_LEASE_TYPES * NUM_LEASE_TYPES )
299 struct lease_upgrade2_test lease_upgrade2_tests[NUM_UPGRADE_TESTS] = {
300 { "", "", "" },
301 { "", "R", "R" },
302 { "", "RH", "RH" },
303 { "", "RW", "RW" },
304 { "", "RWH", "RWH" },
305
306 { "R", "", "R" },
307 { "R", "R", "R" },
308 { "R", "RH", "RH" },
309 { "R", "RW", "RW" },
310 { "R", "RWH", "RWH" },
311
312 { "RH", "", "RH" },
313 { "RH", "R", "RH" },
314 { "RH", "RH", "RH" },
315 { "RH", "RW", "RH" },
316 { "RH", "RWH", "RWH" },
317
318 { "RW", "", "RW" },
319 { "RW", "R", "RW" },
320 { "RW", "RH", "RW" },
321 { "RW", "RW", "RW" },
322 { "RW", "RWH", "RWH" },
323
324 { "RWH", "", "RWH" },
325 { "RWH", "R", "RWH" },
326 { "RWH", "RH", "RWH" },
327 { "RWH", "RW", "RWH" },
328 { "RWH", "RWH", "RWH" },
329 };
330
331 static bool test_lease_upgrade2(struct torture_context *tctx,
332 struct smb2_tree *tree)
333 {
334 TALLOC_CTX *mem_ctx = talloc_new(tctx);
335 struct smb2_handle h = {};
336 struct smb2_handle hnew = {};
337 NTSTATUS status;
338 struct smb2_create io;
339 struct smb2_lease ls;
340 const char *fname = "lease_upgrade2.dat";
341 bool ret = true;
342 int i;
343 uint32_t caps;
344
345 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
346 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
347
348 for (i = 0; i < NUM_UPGRADE_TESTS; i++) {
349 struct lease_upgrade2_test t = lease_upgrade2_tests[i];
350
351 smb2_util_unlink(tree, fname);
352
353 /* Grab a lease. */
354 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.initial));
355 status = smb2_create(tree, mem_ctx, &io);
356 CHECK_STATUS(status, NT_STATUS_OK);
357 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
358 CHECK_LEASE(&io, t.initial, true, LEASE1, 0);
359 h = io.out.file.handle;
360
361 /* Upgrade. */
362 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.upgrade_to));
363 status = smb2_create(tree, mem_ctx, &io);
364 CHECK_STATUS(status, NT_STATUS_OK);
365 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
366 CHECK_LEASE(&io, t.expected, true, LEASE1, 0);
367 hnew = io.out.file.handle;
368
369 smb2_util_close(tree, hnew);
370 smb2_util_close(tree, h);
371 }
372
373 done:
374 smb2_util_close(tree, h);
375 smb2_util_close(tree, hnew);
376
377 smb2_util_unlink(tree, fname);
378
379 talloc_free(mem_ctx);
380
381 return ret;
382 }
383
384
385 /**
386 * upgrade3:
387 * full matrix of lease upgrade combinations
388 * (contended case)
389 *
390 * We start with 2 leases, and check how one can
391 * be upgraded
392 *
393 * The summary of the behaviour is this:
394 * -------------------------------------
395 *
396 * If we have two leases (lease1 and lease2) on the same file,
397 * then attempt to upgrade lease1 results in a change if and only
398 * if the requested lease state:
399 * - is valid,
400 * - is strictly a superset of lease1, and
401 * - can held together with lease2.
402 *
403 * In that case, the resulting lease state of the upgraded lease1
404 * is the state requested in the upgrade. lease2 is not broken
405 * and remains unchanged.
406 *
407 * Note that this contrasts the case of directly opening with
408 * an initial requested lease state, in which case you get that
409 * portion of the requested state that can be shared with the
410 * already existing leases (or the states that they get broken to).
411 */
412 struct lease_upgrade3_test {
413 const char *held1;
414 const char *held2;
415 const char *upgrade_to;
416 const char *upgraded_to;
417 };
418
419 #define NUM_UPGRADE3_TESTS ( 20 )
420 struct lease_upgrade3_test lease_upgrade3_tests[NUM_UPGRADE3_TESTS] = {
421 {"R", "R", "", "R" },
422 {"R", "R", "R", "R" },
423 {"R", "R", "RW", "R" },
424 {"R", "R", "RH", "RH" },
425 {"R", "R", "RHW", "R" },
426
427 {"R", "RH", "", "R" },
428 {"R", "RH", "R", "R" },
429 {"R", "RH", "RW", "R" },
430 {"R", "RH", "RH", "RH" },
431 {"R", "RH", "RHW", "R" },
432
433 {"RH", "R", "", "RH" },
434 {"RH", "R", "R", "RH" },
435 {"RH", "R", "RW", "RH" },
436 {"RH", "R", "RH", "RH" },
437 {"RH", "R", "RHW", "RH" },
438
439 {"RH", "RH", "", "RH" },
440 {"RH", "RH", "R", "RH" },
441 {"RH", "RH", "RW", "RH" },
442 {"RH", "RH", "RH", "RH" },
443 {"RH", "RH", "RHW", "RH" },
444 };
445
446 static bool test_lease_upgrade3(struct torture_context *tctx,
447 struct smb2_tree *tree)
448 {
449 TALLOC_CTX *mem_ctx = talloc_new(tctx);
450 struct smb2_handle h = {};
451 struct smb2_handle h2 = {};
452 struct smb2_handle hnew = {};
453 NTSTATUS status;
454 struct smb2_create io;
455 struct smb2_lease ls;
456 const char *fname = "lease_upgrade3.dat";
457 bool ret = true;
458 int i;
459 uint32_t caps;
460
461 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
462 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
463
464 tree->session->transport->lease.handler = torture_lease_handler;
465 tree->session->transport->lease.private_data = tree;
466
467 smb2_util_unlink(tree, fname);
468
469 for (i = 0; i < NUM_UPGRADE3_TESTS; i++) {
470 struct lease_upgrade3_test t = lease_upgrade3_tests[i];
471
472 smb2_util_unlink(tree, fname);
473
474 torture_reset_lease_break_info(tctx, &lease_break_info);
475
476 /* grab first lease */
477 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.held1));
478 status = smb2_create(tree, mem_ctx, &io);
479 CHECK_STATUS(status, NT_STATUS_OK);
480 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
481 CHECK_LEASE(&io, t.held1, true, LEASE1, 0);
482 h = io.out.file.handle;
483
484 /* grab second lease */
485 smb2_lease_create(&io, &ls, false, fname, LEASE2, smb2_util_lease_state(t.held2));
486 status = smb2_create(tree, mem_ctx, &io);
487 CHECK_STATUS(status, NT_STATUS_OK);
488 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
489 CHECK_LEASE(&io, t.held2, true, LEASE2, 0);
490 h2 = io.out.file.handle;
491
492 /* no break has happened */
493 CHECK_VAL(lease_break_info.count, 0);
494 CHECK_VAL(lease_break_info.failures, 0);
495
496 /* try to upgrade lease1 */
497 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.upgrade_to));
498 status = smb2_create(tree, mem_ctx, &io);
499 CHECK_STATUS(status, NT_STATUS_OK);
500 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
501 CHECK_LEASE(&io, t.upgraded_to, true, LEASE1, 0);
502 hnew = io.out.file.handle;
503
504 /* no break has happened */
505 CHECK_VAL(lease_break_info.count, 0);
506 CHECK_VAL(lease_break_info.failures, 0);
507
508 smb2_util_close(tree, hnew);
509 smb2_util_close(tree, h);
510 smb2_util_close(tree, h2);
511 }
512
513 done:
514 smb2_util_close(tree, h);
515 smb2_util_close(tree, hnew);
516 smb2_util_close(tree, h2);
517
518 smb2_util_unlink(tree, fname);
519
520 talloc_free(mem_ctx);
521
522 return ret;
523 }
524
525
526
527 /*
528 break_results should be read as "held lease, new lease, hold broken to, new
529 grant", i.e. { "RH", "RW", "RH", "R" } means that if key1 holds RH and key2
530 tries for RW, key1 will be broken to RH (in this case, not broken at all)
531 and key2 will be granted R.
532
533 Note: break_results only includes things that Win7 will actually grant (see
534 request_results above).
535 */
536 #define NBREAK_RESULTS 16
537 static const char *break_results[NBREAK_RESULTS][4] = {
538 {"R", "R", "R", "R"},
539 {"R", "RH", "R", "RH"},
540 {"R", "RW", "R", "R"},
541 {"R", "RHW", "R", "RH"},
542
543 {"RH", "R", "RH", "R"},
544 {"RH", "RH", "RH", "RH"},
545 {"RH", "RW", "RH", "R"},
546 {"RH", "RHW", "RH", "RH"},
547
548 {"RW", "R", "R", "R"},
549 {"RW", "RH", "R", "RH"},
550 {"RW", "RW", "R", "R"},
551 {"RW", "RHW", "R", "RH"},
552
553 {"RHW", "R", "RH", "R"},
554 {"RHW", "RH", "RH", "RH"},
555 {"RHW", "RW", "RH", "R"},
556 {"RHW", "RHW", "RH", "RH"},
557 };
558
559 static bool test_lease_break(struct torture_context *tctx,
560 struct smb2_tree *tree)
561 {
562 TALLOC_CTX *mem_ctx = talloc_new(tctx);
563 struct smb2_create io;
564 struct smb2_lease ls;
565 struct smb2_handle h = {};
566 struct smb2_handle h2 = {};
567 struct smb2_handle h3 = {};
568 NTSTATUS status;
569 const char *fname = "lease_break.dat";
570 bool ret = true;
571 int i;
572 uint32_t caps;
573
574 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
575 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
576
577 tree->session->transport->lease.handler = torture_lease_handler;
578 tree->session->transport->lease.private_data = tree;
579
580 smb2_util_unlink(tree, fname);
581
582 for (i = 0; i < NBREAK_RESULTS; i++) {
583 const char *held = break_results[i][0];
584 const char *contend = break_results[i][1];
585 const char *brokento = break_results[i][2];
586 const char *granted = break_results[i][3];
587 torture_comment(tctx, "Hold %s(%x), requesting %s(%x), "
588 "expecting break to %s(%x) and grant of %s(%x)\n",
589 held, smb2_util_lease_state(held), contend, smb2_util_lease_state(contend),
590 brokento, smb2_util_lease_state(brokento), granted, smb2_util_lease_state(granted));
591
592 torture_reset_lease_break_info(tctx, &lease_break_info);
593
594 /* Grab lease. */
595 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(held));
596 status = smb2_create(tree, mem_ctx, &io);
597 CHECK_STATUS(status, NT_STATUS_OK);
598 h = io.out.file.handle;
599 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
600 CHECK_LEASE(&io, held, true, LEASE1, 0);
601
602 /* Possibly contend lease. */
603 smb2_lease_create(&io, &ls, false, fname, LEASE2, smb2_util_lease_state(contend));
604 status = smb2_create(tree, mem_ctx, &io);
605 CHECK_STATUS(status, NT_STATUS_OK);
606 h2 = io.out.file.handle;
607 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
608 CHECK_LEASE(&io, granted, true, LEASE2, 0);
609
610 if (smb2_util_lease_state(held) != smb2_util_lease_state(brokento)) {
611 CHECK_BREAK_INFO(held, brokento, LEASE1);
612 } else {
613 CHECK_NO_BREAK(tctx);
614 }
615
616 torture_reset_lease_break_info(tctx, &lease_break_info);
617
618 /*
619 Now verify that an attempt to upgrade LEASE1 results in no
620 break and no change in LEASE1.
621 */
622 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
623 status = smb2_create(tree, mem_ctx, &io);
624 CHECK_STATUS(status, NT_STATUS_OK);
625 h3 = io.out.file.handle;
626 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
627 CHECK_LEASE(&io, brokento, true, LEASE1, 0);
628 CHECK_VAL(lease_break_info.count, 0);
629 CHECK_VAL(lease_break_info.failures, 0);
630
631 smb2_util_close(tree, h);
632 smb2_util_close(tree, h2);
633 smb2_util_close(tree, h3);
634
635 status = smb2_util_unlink(tree, fname);
636 CHECK_STATUS(status, NT_STATUS_OK);
637 }
638
639 done:
640 smb2_util_close(tree, h);
641 smb2_util_close(tree, h2);
642
643 smb2_util_unlink(tree, fname);
644
645 talloc_free(mem_ctx);
646
647 return ret;
648 }
649
650 static bool test_lease_nobreakself(struct torture_context *tctx,
651 struct smb2_tree *tree)
652 {
653 TALLOC_CTX *mem_ctx = talloc_new(tctx);
654 struct smb2_create io;
655 struct smb2_lease ls;
656 struct smb2_handle h1 = {};
657 struct smb2_handle h2 = {};
658 NTSTATUS status;
659 const char *fname = "lease_nobreakself.dat";
660 bool ret = true;
661 uint32_t caps;
662 char c = 0;
663
664 caps = smb2cli_conn_server_capabilities(
665 tree->session->transport->conn);
666 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
667
668 smb2_util_unlink(tree, fname);
669
670 /* Win7 is happy to grant RHW leases on files. */
671 smb2_lease_create(&io, &ls, false, fname, LEASE1,
672 smb2_util_lease_state("R"));
673 status = smb2_create(tree, mem_ctx, &io);
674 CHECK_STATUS(status, NT_STATUS_OK);
675 h1 = io.out.file.handle;
676 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
677 CHECK_LEASE(&io, "R", true, LEASE1, 0);
678
679 smb2_lease_create(&io, &ls, false, fname, LEASE2,
680 smb2_util_lease_state("R"));
681 status = smb2_create(tree, mem_ctx, &io);
682 CHECK_STATUS(status, NT_STATUS_OK);
683 h2 = io.out.file.handle;
684 CHECK_LEASE(&io, "R", true, LEASE2, 0);
685
686 torture_reset_lease_break_info(tctx, &lease_break_info);
687
688 tree->session->transport->lease.handler = torture_lease_handler;
689 tree->session->transport->lease.private_data = tree;
690
691 /* Make sure we don't break ourselves on write */
692
693 status = smb2_util_write(tree, h1, &c, 0, 1);
694 CHECK_STATUS(status, NT_STATUS_OK);
695 CHECK_BREAK_INFO("R", "", LEASE2);
696
697 /* Try the other way round. First, upgrade LEASE2 to R again */
698
699 smb2_lease_create(&io, &ls, false, fname, LEASE2,
700 smb2_util_lease_state("R"));
701 status = smb2_create(tree, mem_ctx, &io);
702 CHECK_STATUS(status, NT_STATUS_OK);
703 CHECK_LEASE(&io, "R", true, LEASE2, 0);
704 smb2_util_close(tree, io.out.file.handle);
705
706 /* Now break LEASE1 via h2 */
707
708 torture_reset_lease_break_info(tctx, &lease_break_info);
709 status = smb2_util_write(tree, h2, &c, 0, 1);
710 CHECK_STATUS(status, NT_STATUS_OK);
711 CHECK_BREAK_INFO("R", "", LEASE1);
712
713 /* .. and break LEASE2 via h1 */
714
715 torture_reset_lease_break_info(tctx, &lease_break_info);
716 status = smb2_util_write(tree, h1, &c, 0, 1);
717 CHECK_STATUS(status, NT_STATUS_OK);
718 CHECK_BREAK_INFO("R", "", LEASE2);
719
720 done:
721 smb2_util_close(tree, h2);
722 smb2_util_close(tree, h1);
723 smb2_util_unlink(tree, fname);
724 talloc_free(mem_ctx);
725 return ret;
726 }
727
728 static bool test_lease_statopen(struct torture_context *tctx,
729 struct smb2_tree *tree)
730 {
731 TALLOC_CTX *mem_ctx = talloc_new(tctx);
732 struct smb2_create io;
733 struct smb2_lease ls;
734 struct smb2_handle h1 = {};
735 struct smb2_handle h2 = {};
736 NTSTATUS status;
737 const char *fname = "lease_statopen.dat";
738 bool ret = true;
739 uint32_t caps;
740
741 caps = smb2cli_conn_server_capabilities(
742 tree->session->transport->conn);
743 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
744
745 smb2_util_unlink(tree, fname);
746
747 /* Create file. */
748 smb2_lease_create(&io, &ls, false, fname, LEASE1,
749 smb2_util_lease_state("RWH"));
750 status = smb2_create(tree, mem_ctx, &io);
751 CHECK_STATUS(status, NT_STATUS_OK);
752 h1 = io.out.file.handle;
753 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
754 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
755 smb2_util_close(tree, h1);
756
757 /* Stat open file with RWH lease. */
758 smb2_lease_create_share(&io, &ls, false, fname, 0, LEASE1,
759 smb2_util_lease_state("RWH"));
760 io.in.desired_access = FILE_READ_ATTRIBUTES;
761 status = smb2_create(tree, mem_ctx, &io);
762 CHECK_STATUS(status, NT_STATUS_OK);
763 h2 = io.out.file.handle;
764 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
765
766 torture_reset_lease_break_info(tctx, &lease_break_info);
767
768 tree->session->transport->lease.handler = torture_lease_handler;
769 tree->session->transport->lease.private_data = tree;
770
771 /* Ensure non-stat open doesn't break and gets same lease
772 state as existing stat open. */
773 smb2_lease_create(&io, &ls, false, fname, LEASE1,
774 smb2_util_lease_state(""));
775 status = smb2_create(tree, mem_ctx, &io);
776 CHECK_STATUS(status, NT_STATUS_OK);
777 h1 = io.out.file.handle;
778 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
779 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
780
781 CHECK_NO_BREAK(tctx);
782 smb2_util_close(tree, h1);
783
784 /* Open with conflicting lease. stat open should break down to RH */
785 smb2_lease_create(&io, &ls, false, fname, LEASE2,
786 smb2_util_lease_state("RWH"));
787 status = smb2_create(tree, mem_ctx, &io);
788 CHECK_STATUS(status, NT_STATUS_OK);
789 h1 = io.out.file.handle;
790 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
791 CHECK_LEASE(&io, "RH", true, LEASE2, 0);
792
793 CHECK_BREAK_INFO("RWH", "RH", LEASE1);
794
795 done:
796 smb2_util_close(tree, h2);
797 smb2_util_close(tree, h1);
798 smb2_util_unlink(tree, fname);
799 talloc_free(mem_ctx);
800 return ret;
801 }
802
803 static bool test_lease_statopen2(struct torture_context *tctx,
804 struct smb2_tree *tree)
805 {
806 TALLOC_CTX *mem_ctx = talloc_new(tctx);
807 struct smb2_create io;
808 struct smb2_lease ls;
809 struct smb2_handle h1 = {};
810 struct smb2_handle h2 = {};
811 struct smb2_handle h3 = {};
812 NTSTATUS status;
813 const char *fname = "lease_statopen2.dat";
814 bool ret = true;
815 uint32_t caps;
816
817 caps = smb2cli_conn_server_capabilities(
818 tree->session->transport->conn);
819 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
820
821 smb2_util_unlink(tree, fname);
822 torture_reset_lease_break_info(tctx, &lease_break_info);
823 tree->session->transport->lease.handler = torture_lease_handler;
824 tree->session->transport->lease.private_data = tree;
825
826 status = torture_smb2_testfile(tree, fname, &h1);
827 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
828 "smb2_create failed\n");
829 smb2_util_close(tree, h1);
830 ZERO_STRUCT(h1);
831
832 /* Open file with RWH lease. */
833 smb2_lease_create_share(&io, &ls, false, fname,
834 smb2_util_share_access("RWD"),
835 LEASE1,
836 smb2_util_lease_state("RWH"));
837 io.in.desired_access = SEC_FILE_WRITE_DATA;
838 status = smb2_create(tree, mem_ctx, &io);
839 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
840 "smb2_create failed\n");
841 h1 = io.out.file.handle;
842 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
843
844 /* Stat open */
845 ZERO_STRUCT(io);
846 io.in.desired_access = FILE_READ_ATTRIBUTES;
847 io.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
848 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
849 io.in.create_disposition = NTCREATEX_DISP_OPEN;
850 io.in.fname = fname;
851 status = smb2_create(tree, mem_ctx, &io);
852 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
853 "smb2_create failed\n");
854 h2 = io.out.file.handle;
855
856 /* Open file with RWH lease. */
857 smb2_lease_create_share(&io, &ls, false, fname,
858 smb2_util_share_access("RWD"),
859 LEASE1,
860 smb2_util_lease_state("RWH"));
861 io.in.desired_access = SEC_FILE_WRITE_DATA;
862 status = smb2_create(tree, mem_ctx, &io);
863 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
864 "smb2_create failed\n");
865 h3 = io.out.file.handle;
866 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
867
868 done:
869 if (!smb2_util_handle_empty(h3)) {
870 smb2_util_close(tree, h3);
871 }
872 if (!smb2_util_handle_empty(h2)) {
873 smb2_util_close(tree, h2);
874 }
875 if (!smb2_util_handle_empty(h1)) {
876 smb2_util_close(tree, h1);
877 }
878 smb2_util_unlink(tree, fname);
879 talloc_free(mem_ctx);
880 return ret;
881 }
882
883 static bool test_lease_statopen3(struct torture_context *tctx,
884 struct smb2_tree *tree)
885 {
886 TALLOC_CTX *mem_ctx = talloc_new(tctx);
887 struct smb2_create io;
888 struct smb2_lease ls;
889 struct smb2_handle h1 = {};
890 struct smb2_handle h2 = {};
891 NTSTATUS status;
892 const char *fname = "lease_statopen3.dat";
893 bool ret = true;
894 uint32_t caps;
895
896 caps = smb2cli_conn_server_capabilities(
897 tree->session->transport->conn);
898 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
899
900 smb2_util_unlink(tree, fname);
901 torture_reset_lease_break_info(tctx, &lease_break_info);
902 tree->session->transport->lease.handler = torture_lease_handler;
903 tree->session->transport->lease.private_data = tree;
904
905 status = torture_smb2_testfile(tree, fname, &h1);
906 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
907 "smb2_create failed\n");
908 smb2_util_close(tree, h1);
909 ZERO_STRUCT(h1);
910
911 /* Stat open */
912 ZERO_STRUCT(io);
913 io.in.desired_access = FILE_READ_ATTRIBUTES;
914 io.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
915 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
916 io.in.create_disposition = NTCREATEX_DISP_OPEN;
917 io.in.fname = fname;
918 status = smb2_create(tree, mem_ctx, &io);
919 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
920 "smb2_create failed\n");
921 h1 = io.out.file.handle;
922
923 /* Open file with RWH lease. */
924 smb2_lease_create_share(&io, &ls, false, fname,
925 smb2_util_share_access("RWD"),
926 LEASE1,
927 smb2_util_lease_state("RWH"));
928 io.in.desired_access = SEC_FILE_WRITE_DATA;
929 status = smb2_create(tree, mem_ctx, &io);
930 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
931 "smb2_create failed\n");
932 h2 = io.out.file.handle;
933 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
934
935 done:
936 if (!smb2_util_handle_empty(h1)) {
937 smb2_util_close(tree, h1);
938 }
939 if (!smb2_util_handle_empty(h2)) {
940 smb2_util_close(tree, h2);
941 }
942 smb2_util_unlink(tree, fname);
943 talloc_free(mem_ctx);
944 return ret;
945 }
946
947 static bool test_lease_statopen4_do(struct torture_context *tctx,
948 struct smb2_tree *tree,
949 uint32_t access_mask,
950 bool expect_stat_open)
951 {
952 TALLOC_CTX *mem_ctx = talloc_new(tctx);
953 struct smb2_create io;
954 struct smb2_lease ls;
955 struct smb2_handle h1 = {};
956 struct smb2_handle h2 = {};
957 struct smb2_handle h3 = {};
958 NTSTATUS status;
959 const char *fname = "lease_statopen2.dat";
960 bool ret = true;
961
962 /* Open file with RWH lease. */
963 smb2_lease_create_share(&io, &ls, false, fname,
964 smb2_util_share_access("RWD"),
965 LEASE1,
966 smb2_util_lease_state("RWH"));
967 io.in.desired_access = SEC_FILE_ALL;
968 status = smb2_create(tree, mem_ctx, &io);
969 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
970 "smb2_create failed\n");
971 h1 = io.out.file.handle;
972 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
973
974 /* Stat open */
975 ZERO_STRUCT(io);
976 io.in.desired_access = access_mask;
977 io.in.share_access = NTCREATEX_SHARE_ACCESS_MASK;
978 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
979 io.in.create_disposition = NTCREATEX_DISP_OPEN;
980 io.in.fname = fname;
981 status = smb2_create(tree, mem_ctx, &io);
982 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
983 "smb2_create failed\n");
984 h2 = io.out.file.handle;
985
986 if (expect_stat_open) {
987 CHECK_NO_BREAK(tctx);
988 if (!ret) {
989 goto done;
990 }
991 } else {
992 CHECK_VAL(lease_break_info.count, 1);
993 if (!ret) {
994 goto done;
995 }
996 /*
997 * Don't bother checking the lease state of an additional open
998 * below...
999 */
1000 goto done;
1001 }
1002
1003 /* Open file with RWH lease. */
1004 smb2_lease_create_share(&io, &ls, false, fname,
1005 smb2_util_share_access("RWD"),
1006 LEASE1,
1007 smb2_util_lease_state("RWH"));
1008 io.in.desired_access = SEC_FILE_WRITE_DATA;
1009 status = smb2_create(tree, mem_ctx, &io);
1010 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1011 "smb2_create failed\n");
1012 h3 = io.out.file.handle;
1013 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
1014
1015 done:
1016 if (!smb2_util_handle_empty(h3)) {
1017 smb2_util_close(tree, h3);
1018 }
1019 if (!smb2_util_handle_empty(h2)) {
1020 smb2_util_close(tree, h2);
1021 }
1022 if (!smb2_util_handle_empty(h1)) {
1023 smb2_util_close(tree, h1);
1024 }
1025 talloc_free(mem_ctx);
1026 return ret;
1027 }
1028
1029 static bool test_lease_statopen4(struct torture_context *tctx,
1030 struct smb2_tree *tree)
1031 {
1032 const char *fname = "lease_statopen4.dat";
1033 struct smb2_handle h1 = {};
1034 uint32_t caps;
1035 size_t i;
1036 NTSTATUS status;
1037 bool ret = true;
1038 struct {
1039 uint32_t access_mask;
1040 bool expect_stat_open;
1041 } tests[] = {
1042 {
1043 .access_mask = FILE_READ_DATA,
1044 .expect_stat_open = false,
1045 },
1046 {
1047 .access_mask = FILE_WRITE_DATA,
1048 .expect_stat_open = false,
1049 },
1050 {
1051 .access_mask = FILE_READ_EA,
1052 .expect_stat_open = false,
1053 },
1054 {
1055 .access_mask = FILE_WRITE_EA,
1056 .expect_stat_open = false,
1057 },
1058 {
1059 .access_mask = FILE_EXECUTE,
1060 .expect_stat_open = false,
1061 },
1062 {
1063 .access_mask = FILE_READ_ATTRIBUTES,
1064 .expect_stat_open = true,
1065 },
1066 {
1067 .access_mask = FILE_WRITE_ATTRIBUTES,
1068 .expect_stat_open = true,
1069 },
1070 {
1071 .access_mask = DELETE_ACCESS,
1072 .expect_stat_open = false,
1073 },
1074 {
1075 .access_mask = READ_CONTROL_ACCESS,
1076 .expect_stat_open = true,
1077 },
1078 {
1079 .access_mask = WRITE_DAC_ACCESS,
1080 .expect_stat_open = false,
1081 },
1082 {
1083 .access_mask = WRITE_OWNER_ACCESS,
1084 .expect_stat_open = false,
1085 },
1086 {
1087 .access_mask = SYNCHRONIZE_ACCESS,
1088 .expect_stat_open = true,
1089 },
1090 };
1091
1092 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1093 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
1094
1095 smb2_util_unlink(tree, fname);
1096 tree->session->transport->lease.handler = torture_lease_handler;
1097 tree->session->transport->lease.private_data = tree;
1098
1099 status = torture_smb2_testfile(tree, fname, &h1);
1100 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1101 "smb2_create failed\n");
1102 smb2_util_close(tree, h1);
1103 ZERO_STRUCT(h1);
1104
1105 for (i = 0; i < ARRAY_SIZE(tests); i++) {
1106 torture_reset_lease_break_info(tctx, &lease_break_info);
1107
1108 ret = test_lease_statopen4_do(tctx,
1109 tree,
1110 tests[i].access_mask,
1111 tests[i].expect_stat_open);
1112 if (ret == true) {
1113 continue;
1114 }
1115 torture_result(tctx, TORTURE_FAIL,
1116 "test %zu: access_mask: %s, "
1117 "expect_stat_open: %s\n",
1118 i,
1119 get_sec_mask_str(tree, tests[i].access_mask),
1120 tests[i].expect_stat_open ? "yes" : "no");
1121 goto done;
1122 }
1123
1124 done:
1125 smb2_util_unlink(tree, fname);
1126 return ret;
1127 }
1128
1129 static void torture_oplock_break_callback(struct smb2_request *req)
1130 {
1131 NTSTATUS status;
1132 struct smb2_break br;
1133
1134 ZERO_STRUCT(br);
1135 status = smb2_break_recv(req, &br);
1136 if (!NT_STATUS_IS_OK(status))
1137 lease_break_info.oplock_failures++;
1138
1139 return;
1140 }
1141
1142 /* a oplock break request handler */
1143 static bool torture_oplock_handler(struct smb2_transport *transport,
1144 const struct smb2_handle *handle,
1145 uint8_t level, void *private_data)
1146 {
1147 struct smb2_tree *tree = private_data;
1148 struct smb2_request *req;
1149 struct smb2_break br;
1150
1151 lease_break_info.oplock_handle = *handle;
1152 lease_break_info.oplock_level = level;
1153 lease_break_info.oplock_count++;
1154
1155 ZERO_STRUCT(br);
1156 br.in.file.handle = *handle;
1157 br.in.oplock_level = level;
1158
1159 if (lease_break_info.held_oplock_level > SMB2_OPLOCK_LEVEL_II) {
1160 req = smb2_break_send(tree, &br);
1161 req->async.fn = torture_oplock_break_callback;
1162 req->async.private_data = NULL;
1163 }
1164 lease_break_info.held_oplock_level = level;
1165
1166 return true;
1167 }
1168
1169 #define NOPLOCK_RESULTS 12
1170 static const char *oplock_results[NOPLOCK_RESULTS][4] = {
1171 {"R", "s", "R", "s"},
1172 {"R", "x", "R", "s"},
1173 {"R", "b", "R", "s"},
1174
1175 {"RH", "s", "RH", ""},
1176 {"RH", "x", "RH", ""},
1177 {"RH", "b", "RH", ""},
1178
1179 {"RW", "s", "R", "s"},
1180 {"RW", "x", "R", "s"},
1181 {"RW", "b", "R", "s"},
1182
1183 {"RHW", "s", "RH", ""},
1184 {"RHW", "x", "RH", ""},
1185 {"RHW", "b", "RH", ""},
1186 };
1187
1188 static const char *oplock_results_2[NOPLOCK_RESULTS][4] = {
1189 {"s", "R", "s", "R"},
1190 {"s", "RH", "s", "R"},
1191 {"s", "RW", "s", "R"},
1192 {"s", "RHW", "s", "R"},
1193
1194 {"x", "R", "s", "R"},
1195 {"x", "RH", "s", "R"},
1196 {"x", "RW", "s", "R"},
1197 {"x", "RHW", "s", "R"},
1198
1199 {"b", "R", "s", "R"},
1200 {"b", "RH", "s", "R"},
1201 {"b", "RW", "s", "R"},
1202 {"b", "RHW", "s", "R"},
1203 };
1204
1205 static bool test_lease_oplock(struct torture_context *tctx,
1206 struct smb2_tree *tree)
1207 {
1208 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1209 struct smb2_create io;
1210 struct smb2_lease ls;
1211 struct smb2_handle h = {};
1212 struct smb2_handle h2 = {};
1213 NTSTATUS status;
1214 const char *fname = "lease_oplock.dat";
1215 bool ret = true;
1216 int i;
1217 uint32_t caps;
1218
1219 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1220 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
1221
1222 tree->session->transport->lease.handler = torture_lease_handler;
1223 tree->session->transport->lease.private_data = tree;
1224 tree->session->transport->oplock.handler = torture_oplock_handler;
1225 tree->session->transport->oplock.private_data = tree;
1226
1227 smb2_util_unlink(tree, fname);
1228
1229 for (i = 0; i < NOPLOCK_RESULTS; i++) {
1230 const char *held = oplock_results[i][0];
1231 const char *contend = oplock_results[i][1];
1232 const char *brokento = oplock_results[i][2];
1233 const char *granted = oplock_results[i][3];
1234 torture_comment(tctx, "Hold %s(%x), requesting %s(%x), "
1235 "expecting break to %s(%x) and grant of %s(%x)\n",
1236 held, smb2_util_lease_state(held), contend, smb2_util_oplock_level(contend),
1237 brokento, smb2_util_lease_state(brokento), granted, smb2_util_oplock_level(granted));
1238
1239 torture_reset_lease_break_info(tctx, &lease_break_info);
1240
1241 /* Grab lease. */
1242 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(held));
1243 status = smb2_create(tree, mem_ctx, &io);
1244 CHECK_STATUS(status, NT_STATUS_OK);
1245 h = io.out.file.handle;
1246 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1247 CHECK_LEASE(&io, held, true, LEASE1, 0);
1248
1249 /* Does an oplock contend the lease? */
1250 smb2_oplock_create(&io, fname, smb2_util_oplock_level(contend));
1251 status = smb2_create(tree, mem_ctx, &io);
1252 CHECK_STATUS(status, NT_STATUS_OK);
1253 h2 = io.out.file.handle;
1254 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1255 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(granted));
1256 lease_break_info.held_oplock_level = io.out.oplock_level;
1257
1258 if (smb2_util_lease_state(held) != smb2_util_lease_state(brokento)) {
1259 CHECK_BREAK_INFO(held, brokento, LEASE1);
1260 } else {
1261 CHECK_NO_BREAK(tctx);
1262 }
1263
1264 smb2_util_close(tree, h);
1265 smb2_util_close(tree, h2);
1266
1267 status = smb2_util_unlink(tree, fname);
1268 CHECK_STATUS(status, NT_STATUS_OK);
1269 }
1270
1271 for (i = 0; i < NOPLOCK_RESULTS; i++) {
1272 const char *held = oplock_results_2[i][0];
1273 const char *contend = oplock_results_2[i][1];
1274 const char *brokento = oplock_results_2[i][2];
1275 const char *granted = oplock_results_2[i][3];
1276 torture_comment(tctx, "Hold %s(%x), requesting %s(%x), "
1277 "expecting break to %s(%x) and grant of %s(%x)\n",
1278 held, smb2_util_oplock_level(held), contend, smb2_util_lease_state(contend),
1279 brokento, smb2_util_oplock_level(brokento), granted, smb2_util_lease_state(granted));
1280
1281 torture_reset_lease_break_info(tctx, &lease_break_info);
1282
1283 /* Grab an oplock. */
1284 smb2_oplock_create(&io, fname, smb2_util_oplock_level(held));
1285 status = smb2_create(tree, mem_ctx, &io);
1286 CHECK_STATUS(status, NT_STATUS_OK);
1287 h = io.out.file.handle;
1288 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1289 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(held));
1290 lease_break_info.held_oplock_level = io.out.oplock_level;
1291
1292 /* Grab lease. */
1293 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(contend));
1294 status = smb2_create(tree, mem_ctx, &io);
1295 CHECK_STATUS(status, NT_STATUS_OK);
1296 h2 = io.out.file.handle;
1297 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1298 CHECK_LEASE(&io, granted, true, LEASE1, 0);
1299
1300 if (smb2_util_oplock_level(held) != smb2_util_oplock_level(brokento)) {
1301 CHECK_OPLOCK_BREAK(brokento);
1302 } else {
1303 CHECK_NO_BREAK(tctx);
1304 }
1305
1306 smb2_util_close(tree, h);
1307 smb2_util_close(tree, h2);
1308
1309 status = smb2_util_unlink(tree, fname);
1310 CHECK_STATUS(status, NT_STATUS_OK);
1311 }
1312
1313 done:
1314 smb2_util_close(tree, h);
1315 smb2_util_close(tree, h2);
1316
1317 smb2_util_unlink(tree, fname);
1318
1319 talloc_free(mem_ctx);
1320
1321 return ret;
1322 }
1323
1324 static bool test_lease_multibreak(struct torture_context *tctx,
1325 struct smb2_tree *tree)
1326 {
1327 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1328 struct smb2_create io;
1329 struct smb2_lease ls;
1330 struct smb2_handle h = {};
1331 struct smb2_handle h2 = {};
1332 struct smb2_handle h3 = {};
1333 struct smb2_write w;
1334 NTSTATUS status;
1335 const char *fname = "lease_multibreak.dat";
1336 bool ret = true;
1337 uint32_t caps;
1338
1339 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1340 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
1341
1342 tree->session->transport->lease.handler = torture_lease_handler;
1343 tree->session->transport->lease.private_data = tree;
1344 tree->session->transport->oplock.handler = torture_oplock_handler;
1345 tree->session->transport->oplock.private_data = tree;
1346
1347 smb2_util_unlink(tree, fname);
1348
1349 torture_reset_lease_break_info(tctx, &lease_break_info);
1350
1351 /* Grab lease, upgrade to RHW .. */
1352 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
1353 status = smb2_create(tree, mem_ctx, &io);
1354 CHECK_STATUS(status, NT_STATUS_OK);
1355 h = io.out.file.handle;
1356 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1357 CHECK_LEASE(&io, "RH", true, LEASE1, 0);
1358
1359 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
1360 status = smb2_create(tree, mem_ctx, &io);
1361 CHECK_STATUS(status, NT_STATUS_OK);
1362 h2 = io.out.file.handle;
1363 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1364 CHECK_LEASE(&io, "RHW", true, LEASE1, 0);
1365
1366 /* Contend with LEASE2. */
1367 smb2_lease_create(&io, &ls, false, fname, LEASE2, smb2_util_lease_state("RHW"));
1368 status = smb2_create(tree, mem_ctx, &io);
1369 CHECK_STATUS(status, NT_STATUS_OK);
1370 h3 = io.out.file.handle;
1371 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1372 CHECK_LEASE(&io, "RH", true, LEASE2, 0);
1373
1374 /* Verify that we were only sent one break. */
1375 CHECK_BREAK_INFO("RHW", "RH", LEASE1);
1376
1377 /* Drop LEASE1 / LEASE2 */
1378 status = smb2_util_close(tree, h);
1379 CHECK_STATUS(status, NT_STATUS_OK);
1380 status = smb2_util_close(tree, h2);
1381 CHECK_STATUS(status, NT_STATUS_OK);
1382 status = smb2_util_close(tree, h3);
1383 CHECK_STATUS(status, NT_STATUS_OK);
1384
1385 torture_reset_lease_break_info(tctx, &lease_break_info);
1386
1387 /* Grab an R lease. */
1388 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("R"));
1389 status = smb2_create(tree, mem_ctx, &io);
1390 CHECK_STATUS(status, NT_STATUS_OK);
1391 h = io.out.file.handle;
1392 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1393 CHECK_LEASE(&io, "R", true, LEASE1, 0);
1394
1395 /* Grab a level-II oplock. */
1396 smb2_oplock_create(&io, fname, smb2_util_oplock_level("s"));
1397 status = smb2_create(tree, mem_ctx, &io);
1398 CHECK_STATUS(status, NT_STATUS_OK);
1399 h2 = io.out.file.handle;
1400 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1401 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("s"));
1402 lease_break_info.held_oplock_level = io.out.oplock_level;
1403
1404 /* Verify no breaks. */
1405 CHECK_NO_BREAK(tctx);
1406
1407 /* Open for truncate, force a break. */
1408 smb2_generic_create(&io, NULL, false, fname,
1409 NTCREATEX_DISP_OVERWRITE_IF, smb2_util_oplock_level(""), 0, 0);
1410 status = smb2_create(tree, mem_ctx, &io);
1411 CHECK_STATUS(status, NT_STATUS_OK);
1412 h3 = io.out.file.handle;
1413 CHECK_CREATED(&io, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
1414 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(""));
1415 lease_break_info.held_oplock_level = io.out.oplock_level;
1416
1417 /* Sleep, use a write to clear the recv queue. */
1418 smb_msleep(250);
1419 ZERO_STRUCT(w);
1420 w.in.file.handle = h3;
1421 w.in.offset = 0;
1422 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
1423 memset(w.in.data.data, 'o', w.in.data.length);
1424 status = smb2_write(tree, &w);
1425 CHECK_STATUS(status, NT_STATUS_OK);
1426
1427 /* Verify one oplock break, one lease break. */
1428 CHECK_OPLOCK_BREAK("");
1429 CHECK_BREAK_INFO("R", "", LEASE1);
1430
1431 done:
1432 smb2_util_close(tree, h);
1433 smb2_util_close(tree, h2);
1434 smb2_util_close(tree, h3);
1435
1436 smb2_util_unlink(tree, fname);
1437
1438 talloc_free(mem_ctx);
1439
1440 return ret;
1441 }
1442
1443 static bool test_lease_v2_request_parent(struct torture_context *tctx,
1444 struct smb2_tree *tree)
1445 {
1446 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1447 struct smb2_create io;
1448 struct smb2_lease ls;
1449 struct smb2_handle h1 = {};
1450 uint64_t parent = LEASE2;
1451 NTSTATUS status;
1452 const char *fname = "lease_v2_request_parent.dat";
1453 bool ret = true;
1454 uint32_t caps;
1455 enum protocol_types protocol;
1456
1457 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1458 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
1459 torture_assert_goto(tctx, caps & SMB2_CAP_DIRECTORY_LEASING, ret, done,
1460 "SMB3 Directory Leases are not supported\n");
1461
1462 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
1463 if (protocol < PROTOCOL_SMB3_00) {
1464 torture_skip(tctx, "v2 leases are not supported");
1465 }
1466
1467 smb2_util_unlink(tree, fname);
1468
1469 torture_reset_lease_break_info(tctx, &lease_break_info);
1470
1471 ZERO_STRUCT(io);
1472 smb2_lease_v2_create_share(&io, &ls, false, fname,
1473 smb2_util_share_access("RWD"),
1474 LEASE1, &parent,
1475 smb2_util_lease_state("RHW"),
1476 0x11);
1477
1478 status = smb2_create(tree, mem_ctx, &io);
1479 CHECK_STATUS(status, NT_STATUS_OK);
1480 h1 = io.out.file.handle;
1481 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1482 CHECK_LEASE_V2(&io, "RHW", true, LEASE1,
1483 SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET, LEASE2,
1484 ls.lease_epoch + 1);
1485
1486 done:
1487 smb2_util_close(tree, h1);
1488 smb2_util_unlink(tree, fname);
1489
1490 talloc_free(mem_ctx);
1491
1492 return ret;
1493 }
1494
1495 static bool test_dirlease_oplocks(struct torture_context *tctx,
1496 struct smb2_tree *tree)
1497 {
1498 const char *dname = "test_dirlease_leases_dir";
1499 struct smb2_create c;
1500 struct smb2_handle h = {};
1501 uint16_t levels[] = {
1502 SMB2_OPLOCK_LEVEL_NONE,
1503 SMB2_OPLOCK_LEVEL_II,
1504 SMB2_OPLOCK_LEVEL_EXCLUSIVE,
1505 SMB2_OPLOCK_LEVEL_BATCH
1506 };
1507 uint32_t caps;
1508 int i;
1509 NTSTATUS status;
1510 bool ret = true;
1511
1512 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1513 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
1514 torture_assert_goto(tctx, caps & SMB2_CAP_DIRECTORY_LEASING, ret, done,
1515 "SMB3 Directory Leases are not supported\n");
1516
1517 smb2_deltree(tree, dname);
1518
1519 for (i = 0; i < ARRAY_SIZE(levels); i++) {
1520 c = (struct smb2_create) {
1521 .in.oplock_level = levels[i],
1522 .in.desired_access = SEC_RIGHTS_DIR_READ,
1523 .in.create_options = NTCREATEX_OPTIONS_DIRECTORY,
1524 .in.file_attributes = FILE_ATTRIBUTE_DIRECTORY,
1525 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
1526 .in.create_disposition = NTCREATEX_DISP_OPEN_IF,
1527 .in.fname = dname,
1528 };
1529
1530 status = smb2_create(tree, tree, &c);
1531 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1532 "smb2_create failed\n");
1533 h = c.out.file.handle;
1534 status = smb2_util_close(tree, h);
1535 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
1536 "smb2_util_close failed\n");
1537
1538 torture_assert_int_equal_goto(
1539 tctx,
1540 c.out.oplock_level,
1541 SMB2_OPLOCK_LEVEL_NONE,
1542 ret, done, "bad level");
1543 }
1544
1545 done:
1546 smb2_util_close(tree, h);
1547 smb2_deltree(tree, dname);
1548
1549 return ret;
1550 }
1551
1552 /*
1553 * Checks server accepts "RWH", "RH" and "R" lease request and grants at most
1554 * (lease_request & "RH"), so no "W", but "R" without "H" if requested.
1555 */
1556 static bool test_dirlease_leases(struct torture_context *tctx,
1557 struct smb2_tree *tree)
1558 {
1559 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1560 struct smb2_create io;
1561 struct smb2_lease ls;
1562 struct smb2_handle h1 = {};
1563 NTSTATUS status;
1564 const char *dname = "test_dirlease_leases_dir";
1565 bool ret = true;
1566 uint32_t caps;
1567
1568 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1569 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
1570 torture_assert_goto(tctx, caps & SMB2_CAP_DIRECTORY_LEASING, ret, done,
1571 "SMB3 Directory Leases are not supported\n");
1572
1573 smb2_deltree(tree, dname);
1574
1575 torture_reset_lease_break_info(tctx, &lease_break_info);
1576
1577 /* Request "RWH" -> grant "RH" */
1578
1579 ZERO_STRUCT(io);
1580 smb2_lease_v2_create_share(&io, &ls, true, dname,
1581 smb2_util_share_access("RWD"),
1582 LEASE1, NULL,
1583 smb2_util_lease_state("RWH"),
1584 0x11);
1585
1586 status = smb2_create(tree, mem_ctx, &io);
1587 CHECK_STATUS(status, NT_STATUS_OK);
1588 h1 = io.out.file.handle;
1589 CHECK_LEASE_V2(&io, "RH", true, LEASE1,
1590 0, 0, ++ls.lease_epoch);
1591 smb2_util_close(tree, h1);
1592
1593 /* Request "RW" -> grant "R" */
1594
1595 ZERO_STRUCT(io);
1596 smb2_lease_v2_create_share(&io, &ls, true, dname,
1597 smb2_util_share_access("RWD"),
1598 LEASE1, NULL,
1599 smb2_util_lease_state("RW"),
1600 0x11);
1601
1602 status = smb2_create(tree, mem_ctx, &io);
1603 CHECK_STATUS(status, NT_STATUS_OK);
1604 h1 = io.out.file.handle;
1605 CHECK_LEASE_V2(&io, "R", true, LEASE1,
1606 0, 0, ++ls.lease_epoch);
1607 smb2_util_close(tree, h1);
1608
1609 /* Request "RH" -> grant "RH" */
1610
1611 ZERO_STRUCT(io);
1612 smb2_lease_v2_create_share(&io, &ls, true, dname,
1613 smb2_util_share_access("RWD"),
1614 LEASE1, NULL,
1615 smb2_util_lease_state("RH"),
1616 0x11);
1617
1618 status = smb2_create(tree, mem_ctx, &io);
1619 CHECK_STATUS(status, NT_STATUS_OK);
1620 h1 = io.out.file.handle;
1621 CHECK_LEASE_V2(&io, "RH", true, LEASE1,
1622 0, 0, ++ls.lease_epoch);
1623 smb2_util_close(tree, h1);
1624
1625 /* Request "R" -> grant "R" */
1626
1627 ZERO_STRUCT(io);
1628 smb2_lease_v2_create_share(&io, &ls, true, dname,
1629 smb2_util_share_access("RWD"),
1630 LEASE1, NULL,
1631 smb2_util_lease_state("R"),
1632 0x11);
1633
1634 status = smb2_create(tree, mem_ctx, &io);
1635 CHECK_STATUS(status, NT_STATUS_OK);
1636 h1 = io.out.file.handle;
1637 CHECK_LEASE_V2(&io, "R", true, LEASE1,
1638 0, 0, ++ls.lease_epoch);
1639 smb2_util_close(tree, h1);
1640
1641 done:
1642 smb2_util_close(tree, h1);
1643 smb2_deltree(tree, dname);
1644
1645 talloc_free(mem_ctx);
1646
1647 return ret;
1648 }
1649
1650 static bool test_lease_break_twice(struct torture_context *tctx,
1651 struct smb2_tree *tree)
1652 {
1653 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1654 struct smb2_create io;
1655 struct smb2_lease ls1;
1656 struct smb2_lease ls2;
1657 struct smb2_handle h1 = {};
1658 NTSTATUS status;
1659 const char *fname = "lease_break_twice.dat";
1660 bool ret = true;
1661 uint32_t caps;
1662 enum protocol_types protocol;
1663
1664 caps = smb2cli_conn_server_capabilities(
1665 tree->session->transport->conn);
1666 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
1667
1668 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
1669 if (protocol < PROTOCOL_SMB3_00) {
1670 torture_skip(tctx, "v2 leases are not supported");
1671 }
1672
1673 smb2_util_unlink(tree, fname);
1674
1675 torture_reset_lease_break_info(tctx, &lease_break_info);
1676 ZERO_STRUCT(io);
1677
1678 smb2_lease_v2_create_share(
1679 &io, &ls1, false, fname, smb2_util_share_access("RWD"),
1680 LEASE1, NULL, smb2_util_lease_state("RWH"), 0x11);
1681
1682 status = smb2_create(tree, mem_ctx, &io);
1683 CHECK_STATUS(status, NT_STATUS_OK);
1684 h1 = io.out.file.handle;
1685 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1686 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0, ls1.lease_epoch + 1);
1687
1688 tree->session->transport->lease.handler = torture_lease_handler;
1689 tree->session->transport->lease.private_data = tree;
1690
1691 torture_reset_lease_break_info(tctx, &lease_break_info);
1692
1693 smb2_lease_v2_create_share(
1694 &io, &ls2, false, fname, smb2_util_share_access("R"),
1695 LEASE2, NULL, smb2_util_lease_state("RWH"), 0x22);
1696
1697 status = smb2_create(tree, mem_ctx, &io);
1698 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
1699 CHECK_BREAK_INFO_V2(tree->session->transport,
1700 "RWH", "RW", LEASE1, ls1.lease_epoch + 2);
1701
1702 smb2_lease_v2_create_share(
1703 &io, &ls2, false, fname, smb2_util_share_access("RWD"),
1704 LEASE2, NULL, smb2_util_lease_state("RWH"), 0x22);
1705
1706 torture_reset_lease_break_info(tctx, &lease_break_info);
1707
1708 status = smb2_create(tree, mem_ctx, &io);
1709 CHECK_STATUS(status, NT_STATUS_OK);
1710 CHECK_LEASE_V2(&io, "RH", true, LEASE2, 0, 0, ls2.lease_epoch + 1);
1711 CHECK_BREAK_INFO_V2(tree->session->transport,
1712 "RW", "R", LEASE1, ls1.lease_epoch + 3);
1713
1714 done:
1715 smb2_util_close(tree, h1);
1716 smb2_util_unlink(tree, fname);
1717 talloc_free(mem_ctx);
1718 return ret;
1719 }
1720
1721 static bool test_rearm_dirlease(TALLOC_CTX *mem_ctx,
1722 struct torture_context *tctx,
1723 struct smb2_tree *tree,
1724 const char *dname,
1725 uint64_t lease_key,
1726 uint16_t *lease_epoch)
1727 {
1728 struct smb2_create io;
1729 struct smb2_lease ls;
1730 NTSTATUS status;
1731 bool ret = true;
1732
1733 smb2_lease_v2_create_share(&io,
1734 &ls,
1735 true,
1736 dname,
1737 smb2_util_share_access("RWD"),
1738 lease_key,
1739 NULL,
1740 smb2_util_lease_state("RH"),
1741 *lease_epoch);
1742
1743 io.in.create_disposition = NTCREATEX_DISP_OPEN;
1744
1745 status = smb2_create(tree, mem_ctx, &io);
1746 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "rearm failed\n");
1747
1748 smb2_util_close(tree, io.out.file.handle);
1749
1750 (*lease_epoch)++;
1751 CHECK_LEASE_V2(&io, "RH", true, lease_key, 0, 0, *lease_epoch);
1752
1753 done:
1754 return ret;
1755 }
1756
1757 static bool test_lease_v2_request(struct torture_context *tctx,
1758 struct smb2_tree *tree,
1759 struct smb2_tree *tree2)
1760 {
1761 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1762 struct smb2_create io;
1763 struct smb2_lease ls1, ls3, ls4, dirlease;
1764 struct smb2_handle h1 = {};
1765 struct smb2_handle h2 = {};
1766 struct smb2_handle h3 = {};
1767 struct smb2_handle h4 = {};
1768 struct smb2_handle h5 = {};
1769 struct smb2_write w;
1770 struct smb2_lease tr2_ls1;
1771 struct smb2_request *req = NULL;
1772 NTSTATUS status;
1773 const char *fname = "lease_v2_request.dat";
1774 const char *dname = "lease_v2_request.dir";
1775 const char *dnamefname = "lease_v2_request.dir\\lease.dat";
1776 const char *dnamefname2 = "lease_v2_request.dir\\lease2.dat";
1777 bool ret = true;
1778 uint32_t caps;
1779 enum protocol_types protocol;
1780
1781 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
1782 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
1783 torture_assert_goto(tctx, caps & SMB2_CAP_DIRECTORY_LEASING, ret, done,
1784 "SMB3 Directory Leases are not supported\n");
1785
1786 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
1787 if (protocol < PROTOCOL_SMB3_00) {
1788 torture_skip(tctx, "v2 leases are not supported");
1789 }
1790
1791 smb2_util_unlink(tree, fname);
1792 smb2_deltree(tree, dname);
1793
1794 tree->session->transport->lease.handler = torture_lease_handler;
1795 tree->session->transport->lease.private_data = tree;
1796 tree->session->transport->oplock.handler = torture_oplock_handler;
1797 tree->session->transport->oplock.private_data = tree;
1798
1799 torture_reset_lease_break_info(tctx, &lease_break_info);
1800
1801 ZERO_STRUCT(io);
1802 smb2_lease_v2_create_share(&io, &ls1, false, fname,
1803 smb2_util_share_access("RWD"),
1804 LEASE1, NULL,
1805 smb2_util_lease_state("RHW"),
1806 0x11);
1807
1808 status = smb2_create(tree, mem_ctx, &io);
1809 CHECK_STATUS(status, NT_STATUS_OK);
1810 h1 = io.out.file.handle;
1811 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1812 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0, ls1.lease_epoch + 1);
1813
1814 ZERO_STRUCT(io);
1815 smb2_lease_v2_create_share(&io, &dirlease, true, dname,
1816 smb2_util_share_access("RWD"),
1817 LEASE2, NULL,
1818 smb2_util_lease_state("RHW"),
1819 0x22);
1820 status = smb2_create(tree, mem_ctx, &io);
1821 CHECK_STATUS(status, NT_STATUS_OK);
1822 h2 = io.out.file.handle;
1823 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_DIRECTORY);
1824 CHECK_LEASE_V2(&io, "RH", true, LEASE2, 0, 0, ++dirlease.lease_epoch);
1825
1826 /*
1827 * TEST: second client opens the same directory as first client,
1828 * triggering a sharing violation
1829 */
1830 ZERO_STRUCT(io);
1831 smb2_lease_v2_create_share(&io, &tr2_ls1, true, dname,
1832 smb2_util_share_access(""),
1833 LEASE3, NULL,
1834 smb2_util_lease_state("RHW"),
1835 0x22);
1836 status = smb2_create(tree2, mem_ctx, &io);
1837 torture_assert_ntstatus_equal_goto(
1838 tctx, status, NT_STATUS_SHARING_VIOLATION, ret, done,
1839 "CREATE didn't fail with NT_STATUS_SHARING_VIOLATION\n");
1840
1841 CHECK_BREAK_INFO_V2(tree->session->transport,
1842 "RH", "R", LEASE2, ++dirlease.lease_epoch);
1843
1844 torture_reset_lease_break_info(tctx, &lease_break_info);
1845 ret = test_rearm_dirlease(mem_ctx, tctx, tree, dname, LEASE2, &dirlease.lease_epoch);
1846 torture_assert_goto(tctx, ret == true, ret, done, "Rearm dirlease failed\n");
1847
1848 /*
1849 * TEST: second client opens the same directory as first client,
1850 * triggering a sharing violation, first client closes his handle, open
1851 * should pass.
1852 */
1853 lease_break_info.lease_skip_ack = true;
1854
1855 ZERO_STRUCT(io);
1856 smb2_lease_v2_create_share(&io, &tr2_ls1, true, dname,
1857 smb2_util_share_access(""),
1858 LEASE3, NULL,
1859 smb2_util_lease_state("RHW"),
1860 0x22);
1861 req = smb2_create_send(tree2, &io);
1862 torture_assert(tctx, req != NULL, "smb2_create_send");
1863
1864 CHECK_BREAK_INFO_V2(tree->session->transport,
1865 "RH", "R", LEASE2, ++dirlease.lease_epoch);
1866
1867 status = smb2_util_close(tree, h2);
1868 CHECK_STATUS(status, NT_STATUS_OK);
1869
1870 status = smb2_create_recv(req, tctx, &io);
1871 CHECK_STATUS(status, NT_STATUS_OK);
1872 h2 = io.out.file.handle;
1873
1874 status = smb2_util_close(tree2, h2);
1875 CHECK_STATUS(status, NT_STATUS_OK);
1876
1877 /* Reopen directory for subsequent tests */
1878 ZERO_STRUCT(io);
1879 smb2_lease_v2_create_share(&io, &dirlease, true, dname,
1880 smb2_util_share_access("RWD"),
1881 LEASE2, NULL,
1882 smb2_util_lease_state("RHW"),
1883 0x22);
1884 status = smb2_create(tree, mem_ctx, &io);
1885 CHECK_STATUS(status, NT_STATUS_OK);
1886 h2 = io.out.file.handle;
1887 CHECK_LEASE_V2(&io, "RH", true, LEASE2, 0, 0, ++dirlease.lease_epoch);
1888
1889 torture_reset_lease_break_info(tctx, &lease_break_info);
1890
1891 /*
1892 * TEST: create file in a directory with dirlease with valid parent key
1893 * -> no break
1894 */
1895
1896 ZERO_STRUCT(io);
1897 smb2_lease_v2_create_share(&io, &ls3, false, dnamefname,
1898 smb2_util_share_access("RWD"),
1899 LEASE3, &LEASE2,
1900 smb2_util_lease_state("RHW"),
1901 0x33);
1902 status = smb2_create(tree, mem_ctx, &io);
1903 CHECK_STATUS(status, NT_STATUS_OK);
1904 h3 = io.out.file.handle;
1905 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1906 CHECK_LEASE_V2(&io, "RHW", true, LEASE3,
1907 SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET, LEASE2,
1908 ls3.lease_epoch + 1);
1909
1910 CHECK_NO_BREAK(tctx);
1911
1912 /*
1913 * TEST: create file in a directory with dirlease with invalid parent
1914 * key -> break
1915 */
1916
1917 ZERO_STRUCT(io);
1918 smb2_lease_v2_create_share(&io, &ls4, false, dnamefname2,
1919 smb2_util_share_access("RWD"),
1920 LEASE4, NULL,
1921 smb2_util_lease_state("RHW"),
1922 0x44);
1923 status = smb2_create(tree, mem_ctx, &io);
1924 CHECK_STATUS(status, NT_STATUS_OK);
1925 h4 = io.out.file.handle;
1926 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1927 CHECK_LEASE_V2(&io, "RHW", true, LEASE4, 0, 0, ls4.lease_epoch + 1);
1928
1929 CHECK_BREAK_INFO_V2(tree->session->transport,
1930 "RH", "", LEASE2, ++dirlease.lease_epoch);
1931
1932 /*
1933 * TEST: Write on handle without valid parent key -> break
1934 */
1935
1936 torture_reset_lease_break_info(tctx, &lease_break_info);
1937 ret = test_rearm_dirlease(mem_ctx, tctx, tree, dname, LEASE2, &dirlease.lease_epoch);
1938 torture_assert_goto(tctx, ret == true, ret, done, "Rearm dirlease failed\n");
1939
1940 ZERO_STRUCT(w);
1941 w.in.file.handle = h4;
1942 w.in.offset = 0;
1943 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
1944 memset(w.in.data.data, 'o', w.in.data.length);
1945 status = smb2_write(tree, &w);
1946 CHECK_STATUS(status, NT_STATUS_OK);
1947
1948 /*
1949 * Wait 4 seconds in order to check if the write time
1950 * was updated (after 2 seconds).
1951 */
1952 smb_msleep(4000);
1953 CHECK_NO_BREAK(tctx);
1954
1955 /*
1956 * only the close on the modified file break the
1957 * directory lease.
1958 */
1959 smb2_util_close(tree, h4);
1960 ZERO_STRUCT(h4);
1961
1962 CHECK_BREAK_INFO_V2(tree->session->transport,
1963 "RH", "", LEASE2, ++dirlease.lease_epoch);
1964
1965 /*
1966 * TEST: Write on handle with valid parent key -> no break
1967 */
1968
1969 torture_reset_lease_break_info(tctx, &lease_break_info);
1970 ret = test_rearm_dirlease(mem_ctx, tctx, tree, dname, LEASE2, &dirlease.lease_epoch);
1971 torture_assert_goto(tctx, ret == true, ret, done, "Rearm dirlease failed\n");
1972
1973 ZERO_STRUCT(w);
1974 w.in.file.handle = h3;
1975 w.in.offset = 0;
1976 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
1977 memset(w.in.data.data, 'o', w.in.data.length);
1978 status = smb2_write(tree, &w);
1979 CHECK_STATUS(status, NT_STATUS_OK);
1980
1981 smb_msleep(4000);
1982 CHECK_NO_BREAK(tctx);
1983 smb2_util_close(tree, h3);
1984 ZERO_STRUCT(h3);
1985 CHECK_NO_BREAK(tctx);
1986
1987 done:
1988 smb2_util_close(tree, h1);
1989 smb2_util_close(tree, h2);
1990 smb2_util_close(tree, h3);
1991 smb2_util_close(tree, h4);
1992 smb2_util_close(tree, h5);
1993
1994 smb2_util_unlink(tree, fname);
1995 smb2_deltree(tree, dname);
1996
1997 talloc_free(mem_ctx);
1998
1999 return ret;
2000 }
2001
2002 static bool test_lease_v2_flags_breaking(struct torture_context *tctx,
2003 struct smb2_tree *tree)
2004 {
2005 struct smb2_create c = {};
2006 struct smb2_lease ls = {};
2007 struct smb2_handle h = {};
2008 const char *fname = "lease_v2_epoch1.dat";
2009 enum protocol_types protocol;
2010 uint32_t caps;
2011 NTSTATUS status;
2012 bool ret = true;
2013
2014 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2015 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2016
2017 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
2018 if (protocol < PROTOCOL_SMB3_00) {
2019 torture_skip(tctx, "v2 leases are not supported");
2020 }
2021
2022 smb2_util_unlink(tree, fname);
2023
2024 smb2_lease_v2_create_share(&c, &ls, false, fname,
2025 smb2_util_share_access("RWD"),
2026 LEASE1, NULL,
2027 smb2_util_lease_state("RHW"),
2028 0x4711);
2029 ls.lease_flags |= SMB2_LEASE_FLAG_BREAK_IN_PROGRESS;
2030
2031 status = smb2_create(tree, tree, &c);
2032 CHECK_STATUS(status, NT_STATUS_OK);
2033 h = c.out.file.handle;
2034
2035 CHECK_CREATED(&c, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2036 CHECK_LEASE_V2(&c, "RHW", true, LEASE1, 0, 0, ls.lease_epoch + 1);
2037
2038 done:
2039 smb2_util_close(tree, h);
2040 smb2_util_unlink(tree, fname);
2041 return ret;
2042 }
2043
2044 /*
2045 * Verify server ignores the parent leasekey if
2046 * SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET is not set in the request.
2047 */
2048 static bool test_lease_v2_flags_parentkey(struct torture_context *tctx,
2049 struct smb2_tree *tree)
2050 {
2051 struct smb2_create c = {};
2052 struct smb2_lease ls = {};
2053 struct smb2_handle h = {};
2054 const char *fname = "lease_v2_epoch1.dat";
2055 enum protocol_types protocol;
2056 uint32_t caps;
2057 NTSTATUS status;
2058 bool ret = true;
2059
2060 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2061 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2062
2063 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
2064 if (protocol < PROTOCOL_SMB3_00) {
2065 torture_skip(tctx, "v2 leases are not supported");
2066 }
2067
2068 smb2_util_unlink(tree, fname);
2069
2070 smb2_lease_v2_create_share(&c, &ls, false, fname,
2071 smb2_util_share_access("RWD"),
2072 LEASE1, &LEASE1,
2073 smb2_util_lease_state("RHW"),
2074 0x4711);
2075 ls.lease_flags = 0;
2076
2077 status = smb2_create(tree, tree, &c);
2078 CHECK_STATUS(status, NT_STATUS_OK);
2079 h = c.out.file.handle;
2080
2081 CHECK_CREATED(&c, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2082 CHECK_LEASE_V2(&c, "RHW", true, LEASE1, 0, 0, ls.lease_epoch + 1);
2083
2084 done:
2085 smb2_util_close(tree, h);
2086 smb2_util_unlink(tree, fname);
2087 return ret;
2088 }
2089
2090 static bool test_lease_v2_epoch1(struct torture_context *tctx,
2091 struct smb2_tree *tree)
2092 {
2093 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2094 struct smb2_create io;
2095 struct smb2_lease ls;
2096 struct smb2_handle h = {};
2097 const char *fname = "lease_v2_epoch1.dat";
2098 bool ret = true;
2099 NTSTATUS status;
2100 uint32_t caps;
2101 enum protocol_types protocol;
2102
2103 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2104 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2105
2106 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
2107 if (protocol < PROTOCOL_SMB3_00) {
2108 torture_skip(tctx, "v2 leases are not supported");
2109 }
2110
2111 smb2_util_unlink(tree, fname);
2112
2113 tree->session->transport->lease.handler = torture_lease_handler;
2114 tree->session->transport->lease.private_data = tree;
2115 tree->session->transport->oplock.handler = torture_oplock_handler;
2116 tree->session->transport->oplock.private_data = tree;
2117
2118 torture_reset_lease_break_info(tctx, &lease_break_info);
2119
2120 ZERO_STRUCT(io);
2121 smb2_lease_v2_create_share(&io, &ls, false, fname,
2122 smb2_util_share_access("RWD"),
2123 LEASE1, NULL,
2124 smb2_util_lease_state("RHW"),
2125 0x4711);
2126 status = smb2_create(tree, mem_ctx, &io);
2127 CHECK_STATUS(status, NT_STATUS_OK);
2128 h = io.out.file.handle;
2129 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2130 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0, ls.lease_epoch + 1);
2131 smb2_util_close(tree, h);
2132 smb2_util_unlink(tree, fname);
2133
2134 smb2_lease_v2_create_share(&io, &ls, false, fname,
2135 smb2_util_share_access("RWD"),
2136 LEASE1, NULL,
2137 smb2_util_lease_state("RHW"),
2138 0x11);
2139
2140 status = smb2_create(tree, mem_ctx, &io);
2141 CHECK_STATUS(status, NT_STATUS_OK);
2142 h = io.out.file.handle;
2143 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2144 CHECK_LEASE_V2(&io, "RWH", true, LEASE1, 0, 0, ls.lease_epoch + 1);
2145 smb2_util_close(tree, h);
2146
2147 done:
2148 smb2_util_unlink(tree, fname);
2149 talloc_free(mem_ctx);
2150 return ret;
2151 }
2152
2153 static bool test_lease_v2_epoch2(struct torture_context *tctx,
2154 struct smb2_tree *tree)
2155 {
2156 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2157 struct smb2_create io;
2158 struct smb2_lease ls1v2, ls1v2t, ls1v1;
2159 struct smb2_handle hv2 = {}, hv1 = {};
2160 const char *fname = "lease_v2_epoch2.dat";
2161 bool ret = true;
2162 NTSTATUS status;
2163 uint32_t caps;
2164 enum protocol_types protocol;
2165
2166 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2167 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2168
2169 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
2170 if (protocol < PROTOCOL_SMB3_00) {
2171 torture_skip(tctx, "v2 leases are not supported");
2172 }
2173
2174 smb2_util_unlink(tree, fname);
2175
2176 tree->session->transport->lease.handler = torture_lease_handler;
2177 tree->session->transport->lease.private_data = tree;
2178 tree->session->transport->oplock.handler = torture_oplock_handler;
2179 tree->session->transport->oplock.private_data = tree;
2180
2181 torture_reset_lease_break_info(tctx, &lease_break_info);
2182
2183 ZERO_STRUCT(io);
2184 smb2_lease_v2_create_share(&io, &ls1v2, false, fname,
2185 smb2_util_share_access("RWD"),
2186 LEASE1, NULL,
2187 smb2_util_lease_state("R"),
2188 0x4711);
2189 status = smb2_create(tree, mem_ctx, &io);
2190 CHECK_STATUS(status, NT_STATUS_OK);
2191 hv2 = io.out.file.handle;
2192 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2193 CHECK_LEASE_V2(&io, "R", true, LEASE1, 0, 0, ls1v2.lease_epoch + 1);
2194
2195 ZERO_STRUCT(io);
2196 smb2_lease_create_share(&io, &ls1v1, false, fname,
2197 smb2_util_share_access("RWD"),
2198 LEASE1,
2199 smb2_util_lease_state("RH"));
2200 status = smb2_create(tree, mem_ctx, &io);
2201 CHECK_STATUS(status, NT_STATUS_OK);
2202 hv1 = io.out.file.handle;
2203 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2204 CHECK_LEASE_V2(&io, "RH", true, LEASE1, 0, 0, ls1v2.lease_epoch + 2);
2205
2206 smb2_util_close(tree, hv2);
2207
2208 ZERO_STRUCT(io);
2209 smb2_lease_v2_create_share(&io, &ls1v2t, false, fname,
2210 smb2_util_share_access("RWD"),
2211 LEASE1, NULL,
2212 smb2_util_lease_state("RHW"),
2213 0x11);
2214 status = smb2_create(tree, mem_ctx, &io);
2215 CHECK_STATUS(status, NT_STATUS_OK);
2216 hv2 = io.out.file.handle;
2217 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2218 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0, ls1v2.lease_epoch + 3);
2219
2220 smb2_util_close(tree, hv2);
2221
2222 smb2_oplock_create(&io, fname, SMB2_OPLOCK_LEVEL_NONE);
2223 status = smb2_create(tree, mem_ctx, &io);
2224 CHECK_STATUS(status, NT_STATUS_OK);
2225 hv2 = io.out.file.handle;
2226 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2227 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
2228
2229 CHECK_BREAK_INFO_V2(tree->session->transport,
2230 "RWH", "RH", LEASE1, ls1v2.lease_epoch + 4);
2231
2232 smb2_util_close(tree, hv2);
2233 smb2_util_close(tree, hv1);
2234
2235 ZERO_STRUCT(io);
2236 smb2_lease_create_share(&io, &ls1v1, false, fname,
2237 smb2_util_share_access("RWD"),
2238 LEASE1,
2239 smb2_util_lease_state("RHW"));
2240 status = smb2_create(tree, mem_ctx, &io);
2241 CHECK_STATUS(status, NT_STATUS_OK);
2242 hv1 = io.out.file.handle;
2243 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2244 CHECK_LEASE(&io, "RHW", true, LEASE1, 0);
2245
2246 smb2_util_close(tree, hv1);
2247
2248 done:
2249 smb2_util_close(tree, hv2);
2250 smb2_util_close(tree, hv1);
2251 smb2_util_unlink(tree, fname);
2252 talloc_free(mem_ctx);
2253 return ret;
2254 }
2255
2256 static bool test_lease_v2_epoch3(struct torture_context *tctx,
2257 struct smb2_tree *tree)
2258 {
2259 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2260 struct smb2_create io;
2261 struct smb2_lease ls1v1 = {}, ls1v1t = {},ls1v2 = {};
2262 struct smb2_handle hv1 = {}, hv2 = {};
2263 const char *fname = "lease_v2_epoch3.dat";
2264 bool ret = true;
2265 NTSTATUS status;
2266 uint32_t caps;
2267 enum protocol_types protocol;
2268
2269 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2270 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2271
2272 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
2273 if (protocol < PROTOCOL_SMB3_00) {
2274 torture_skip(tctx, "v2 leases are not supported");
2275 }
2276
2277 smb2_util_unlink(tree, fname);
2278
2279 tree->session->transport->lease.handler = torture_lease_handler;
2280 tree->session->transport->lease.private_data = tree;
2281 tree->session->transport->oplock.handler = torture_oplock_handler;
2282 tree->session->transport->oplock.private_data = tree;
2283
2284 torture_reset_lease_break_info(tctx, &lease_break_info);
2285
2286 ZERO_STRUCT(io);
2287 smb2_lease_create_share(&io, &ls1v1, false, fname,
2288 smb2_util_share_access("RWD"),
2289 LEASE1,
2290 smb2_util_lease_state("R"));
2291 status = smb2_create(tree, mem_ctx, &io);
2292 CHECK_STATUS(status, NT_STATUS_OK);
2293 hv1 = io.out.file.handle;
2294 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2295 CHECK_LEASE(&io, "R", true, LEASE1, 0);
2296
2297 ZERO_STRUCT(io);
2298 smb2_lease_v2_create_share(&io, &ls1v2, false, fname,
2299 smb2_util_share_access("RWD"),
2300 LEASE1, NULL,
2301 smb2_util_lease_state("RW"),
2302 0x4711);
2303 status = smb2_create(tree, mem_ctx, &io);
2304 CHECK_STATUS(status, NT_STATUS_OK);
2305 hv2 = io.out.file.handle;
2306 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2307 CHECK_LEASE(&io, "RW", true, LEASE1, 0);
2308
2309 smb2_util_close(tree, hv1);
2310
2311 ZERO_STRUCT(io);
2312 smb2_lease_create_share(&io, &ls1v1t, false, fname,
2313 smb2_util_share_access("RWD"),
2314 LEASE1,
2315 smb2_util_lease_state("RWH"));
2316 status = smb2_create(tree, mem_ctx, &io);
2317 CHECK_STATUS(status, NT_STATUS_OK);
2318 hv1 = io.out.file.handle;
2319 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2320 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
2321
2322 smb2_util_close(tree, hv1);
2323
2324 smb2_oplock_create(&io, fname, SMB2_OPLOCK_LEVEL_NONE);
2325 status = smb2_create(tree, mem_ctx, &io);
2326 CHECK_STATUS(status, NT_STATUS_OK);
2327 hv1 = io.out.file.handle;
2328 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2329 CHECK_VAL(io.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
2330
2331 CHECK_BREAK_INFO("RWH", "RH", LEASE1);
2332
2333 smb2_util_close(tree, hv1);
2334 smb2_util_close(tree, hv2);
2335
2336 ZERO_STRUCT(io);
2337 smb2_lease_v2_create_share(&io, &ls1v2, false, fname,
2338 smb2_util_share_access("RWD"),
2339 LEASE1, NULL,
2340 smb2_util_lease_state("RWH"),
2341 0x4711);
2342 status = smb2_create(tree, mem_ctx, &io);
2343 CHECK_STATUS(status, NT_STATUS_OK);
2344 hv2 = io.out.file.handle;
2345 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2346 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0, ls1v2.lease_epoch + 1);
2347 smb2_util_close(tree, hv2);
2348
2349 done:
2350 smb2_util_close(tree, hv2);
2351 smb2_util_close(tree, hv1);
2352 smb2_util_unlink(tree, fname);
2353 talloc_free(mem_ctx);
2354 return ret;
2355 }
2356
2357 static bool test_lease_breaking1(struct torture_context *tctx,
2358 struct smb2_tree *tree)
2359 {
2360 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2361 struct smb2_create io1 = {};
2362 struct smb2_create io2 = {};
2363 struct smb2_lease ls1 = {};
2364 struct smb2_handle h1a = {};
2365 struct smb2_handle h1b = {};
2366 struct smb2_handle h2 = {};
2367 struct smb2_request *req2 = NULL;
2368 struct smb2_lease_break_ack ack = {};
2369 const char *fname = "lease_breaking1.dat";
2370 bool ret = true;
2371 NTSTATUS status;
2372 uint32_t caps;
2373
2374 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2375 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2376
2377 smb2_util_unlink(tree, fname);
2378
2379 tree->session->transport->lease.handler = torture_lease_handler;
2380 tree->session->transport->lease.private_data = tree;
2381 tree->session->transport->oplock.handler = torture_oplock_handler;
2382 tree->session->transport->oplock.private_data = tree;
2383
2384 /*
2385 * we defer acking the lease break.
2386 */
2387 torture_reset_lease_break_info(tctx, &lease_break_info);
2388 lease_break_info.lease_skip_ack = true;
2389
2390 smb2_lease_create_share(&io1, &ls1, false, fname,
2391 smb2_util_share_access("RWD"),
2392 LEASE1,
2393 smb2_util_lease_state("RWH"));
2394 status = smb2_create(tree, mem_ctx, &io1);
2395 CHECK_STATUS(status, NT_STATUS_OK);
2396 h1a = io1.out.file.handle;
2397 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2398 CHECK_LEASE(&io1, "RWH", true, LEASE1, 0);
2399
2400 /*
2401 * a conflicting open is blocked until we ack the
2402 * lease break
2403 */
2404 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
2405 req2 = smb2_create_send(tree, &io2);
2406 torture_assert(tctx, req2 != NULL, "smb2_create_send");
2407
2408 /*
2409 * we got the lease break, but defer the ack.
2410 */
2411 CHECK_BREAK_INFO("RWH", "RH", LEASE1);
2412
2413 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
2414
2415 ack.in.lease.lease_key =
2416 lease_break_info.lease_break.current_lease.lease_key;
2417 ack.in.lease.lease_state =
2418 lease_break_info.lease_break.new_lease_state;
2419 torture_reset_lease_break_info(tctx, &lease_break_info);
2420
2421 /*
2422 * a open using the same lease key is still works,
2423 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
2424 */
2425 status = smb2_create(tree, mem_ctx, &io1);
2426 CHECK_STATUS(status, NT_STATUS_OK);
2427 h1b = io1.out.file.handle;
2428 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2429 CHECK_LEASE(&io1, "RWH", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS);
2430 smb2_util_close(tree, h1b);
2431
2432 CHECK_NO_BREAK(tctx);
2433
2434 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
2435
2436 /*
2437 * We ack the lease break.
2438 */
2439 status = smb2_lease_break_ack(tree, &ack);
2440 CHECK_STATUS(status, NT_STATUS_OK);
2441 CHECK_LEASE_BREAK_ACK(&ack, "RH", LEASE1);
2442
2443 torture_assert(tctx, req2->cancel.can_cancel,
2444 "req2 can_cancel");
2445
2446 status = smb2_create_recv(req2, tctx, &io2);
2447 CHECK_STATUS(status, NT_STATUS_OK);
2448 h2 = io2.out.file.handle;
2449 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2450 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
2451
2452 CHECK_NO_BREAK(tctx);
2453 done:
2454 smb2_util_close(tree, h1a);
2455 smb2_util_close(tree, h1b);
2456 smb2_util_close(tree, h2);
2457 smb2_util_unlink(tree, fname);
2458 talloc_free(mem_ctx);
2459 return ret;
2460 }
2461
2462 static bool test_lease_breaking2(struct torture_context *tctx,
2463 struct smb2_tree *tree)
2464 {
2465 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2466 struct smb2_create io1 = {};
2467 struct smb2_create io2 = {};
2468 struct smb2_lease ls1 = {};
2469 struct smb2_handle h1a = {};
2470 struct smb2_handle h1b = {};
2471 struct smb2_handle h2 = {};
2472 struct smb2_request *req2 = NULL;
2473 struct smb2_lease_break_ack ack = {};
2474 const char *fname = "lease_breaking2.dat";
2475 bool ret = true;
2476 NTSTATUS status;
2477 uint32_t caps;
2478
2479 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2480 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2481
2482 smb2_util_unlink(tree, fname);
2483
2484 tree->session->transport->lease.handler = torture_lease_handler;
2485 tree->session->transport->lease.private_data = tree;
2486 tree->session->transport->oplock.handler = torture_oplock_handler;
2487 tree->session->transport->oplock.private_data = tree;
2488
2489 /*
2490 * we defer acking the lease break.
2491 */
2492 torture_reset_lease_break_info(tctx, &lease_break_info);
2493 lease_break_info.lease_skip_ack = true;
2494
2495 smb2_lease_create_share(&io1, &ls1, false, fname,
2496 smb2_util_share_access("RWD"),
2497 LEASE1,
2498 smb2_util_lease_state("RWH"));
2499 status = smb2_create(tree, mem_ctx, &io1);
2500 CHECK_STATUS(status, NT_STATUS_OK);
2501 h1a = io1.out.file.handle;
2502 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2503 CHECK_LEASE(&io1, "RWH", true, LEASE1, 0);
2504
2505 /*
2506 * a conflicting open is blocked until we ack the
2507 * lease break
2508 */
2509 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
2510 io2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
2511 req2 = smb2_create_send(tree, &io2);
2512 torture_assert(tctx, req2 != NULL, "smb2_create_send");
2513
2514 /*
2515 * we got the lease break, but defer the ack.
2516 */
2517 CHECK_BREAK_INFO("RWH", "", LEASE1);
2518
2519 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
2520
2521 ack.in.lease.lease_key =
2522 lease_break_info.lease_break.current_lease.lease_key;
2523 torture_reset_lease_break_info(tctx, &lease_break_info);
2524
2525 /*
2526 * a open using the same lease key is still works,
2527 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
2528 */
2529 status = smb2_create(tree, mem_ctx, &io1);
2530 CHECK_STATUS(status, NT_STATUS_OK);
2531 h1b = io1.out.file.handle;
2532 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2533 CHECK_LEASE(&io1, "RWH", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS);
2534 smb2_util_close(tree, h1b);
2535
2536 CHECK_NO_BREAK(tctx);
2537
2538 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
2539
2540 /*
2541 * We ack the lease break.
2542 */
2543 ack.in.lease.lease_state =
2544 SMB2_LEASE_READ | SMB2_LEASE_WRITE | SMB2_LEASE_HANDLE;
2545 status = smb2_lease_break_ack(tree, &ack);
2546 CHECK_STATUS(status, NT_STATUS_REQUEST_NOT_ACCEPTED);
2547
2548 ack.in.lease.lease_state =
2549 SMB2_LEASE_READ | SMB2_LEASE_WRITE;
2550 status = smb2_lease_break_ack(tree, &ack);
2551 CHECK_STATUS(status, NT_STATUS_REQUEST_NOT_ACCEPTED);
2552
2553 ack.in.lease.lease_state =
2554 SMB2_LEASE_WRITE | SMB2_LEASE_HANDLE;
2555 status = smb2_lease_break_ack(tree, &ack);
2556 CHECK_STATUS(status, NT_STATUS_REQUEST_NOT_ACCEPTED);
2557
2558 ack.in.lease.lease_state =
2559 SMB2_LEASE_READ | SMB2_LEASE_HANDLE;
2560 status = smb2_lease_break_ack(tree, &ack);
2561 CHECK_STATUS(status, NT_STATUS_REQUEST_NOT_ACCEPTED);
2562
2563 ack.in.lease.lease_state = SMB2_LEASE_WRITE;
2564 status = smb2_lease_break_ack(tree, &ack);
2565 CHECK_STATUS(status, NT_STATUS_REQUEST_NOT_ACCEPTED);
2566
2567 ack.in.lease.lease_state = SMB2_LEASE_HANDLE;
2568 status = smb2_lease_break_ack(tree, &ack);
2569 CHECK_STATUS(status, NT_STATUS_REQUEST_NOT_ACCEPTED);
2570
2571 ack.in.lease.lease_state = SMB2_LEASE_READ;
2572 status = smb2_lease_break_ack(tree, &ack);
2573 CHECK_STATUS(status, NT_STATUS_REQUEST_NOT_ACCEPTED);
2574
2575 /* Try again with the correct state this time. */
2576 ack.in.lease.lease_state = SMB2_LEASE_NONE;;
2577 status = smb2_lease_break_ack(tree, &ack);
2578 CHECK_STATUS(status, NT_STATUS_OK);
2579 CHECK_LEASE_BREAK_ACK(&ack, "", LEASE1);
2580
2581 status = smb2_lease_break_ack(tree, &ack);
2582 CHECK_STATUS(status, NT_STATUS_UNSUCCESSFUL);
2583
2584 torture_assert(tctx, req2->cancel.can_cancel,
2585 "req2 can_cancel");
2586
2587 status = smb2_create_recv(req2, tctx, &io2);
2588 CHECK_STATUS(status, NT_STATUS_OK);
2589 h2 = io2.out.file.handle;
2590 CHECK_CREATED(&io2, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
2591 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
2592
2593 CHECK_NO_BREAK(tctx);
2594
2595 /* Get state of the original handle. */
2596 smb2_lease_create(&io1, &ls1, false, fname, LEASE1, smb2_util_lease_state(""));
2597 status = smb2_create(tree, mem_ctx, &io1);
2598 CHECK_STATUS(status, NT_STATUS_OK);
2599 CHECK_LEASE(&io1, "", true, LEASE1, 0);
2600 smb2_util_close(tree, io1.out.file.handle);
2601
2602 done:
2603 smb2_util_close(tree, h1a);
2604 smb2_util_close(tree, h1b);
2605 smb2_util_close(tree, h2);
2606 smb2_util_unlink(tree, fname);
2607 talloc_free(mem_ctx);
2608 return ret;
2609 }
2610
2611 static bool test_lease_breaking3(struct torture_context *tctx,
2612 struct smb2_tree *tree)
2613 {
2614 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2615 struct smb2_create io1 = {};
2616 struct smb2_create io2 = {};
2617 struct smb2_create io3 = {};
2618 struct smb2_lease ls1 = {};
2619 struct smb2_handle h1a = {};
2620 struct smb2_handle h1b = {};
2621 struct smb2_handle h2 = {};
2622 struct smb2_handle h3 = {};
2623 struct smb2_request *req2 = NULL;
2624 struct smb2_request *req3 = NULL;
2625 struct lease_break_info lease_break_info_tmp = {};
2626 struct smb2_lease_break_ack ack = {};
2627 const char *fname = "lease_breaking3.dat";
2628 bool ret = true;
2629 NTSTATUS status;
2630 uint32_t caps;
2631
2632 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2633 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2634
2635 smb2_util_unlink(tree, fname);
2636
2637 tree->session->transport->lease.handler = torture_lease_handler;
2638 tree->session->transport->lease.private_data = tree;
2639 tree->session->transport->oplock.handler = torture_oplock_handler;
2640 tree->session->transport->oplock.private_data = tree;
2641
2642 /*
2643 * we defer acking the lease break.
2644 */
2645 torture_reset_lease_break_info(tctx, &lease_break_info);
2646 lease_break_info.lease_skip_ack = true;
2647
2648 smb2_lease_create_share(&io1, &ls1, false, fname,
2649 smb2_util_share_access("RWD"),
2650 LEASE1,
2651 smb2_util_lease_state("RWH"));
2652 status = smb2_create(tree, mem_ctx, &io1);
2653 CHECK_STATUS(status, NT_STATUS_OK);
2654 h1a = io1.out.file.handle;
2655 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2656 CHECK_LEASE(&io1, "RWH", true, LEASE1, 0);
2657
2658 /*
2659 * a conflicting open is blocked until we ack the
2660 * lease break
2661 */
2662 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
2663 req2 = smb2_create_send(tree, &io2);
2664 torture_assert(tctx, req2 != NULL, "smb2_create_send");
2665
2666 /*
2667 * we got the lease break, but defer the ack.
2668 */
2669 CHECK_BREAK_INFO("RWH", "RH", LEASE1);
2670
2671 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
2672
2673 /*
2674 * a open using the same lease key is still works,
2675 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
2676 */
2677 status = smb2_create(tree, mem_ctx, &io1);
2678 CHECK_STATUS(status, NT_STATUS_OK);
2679 h1b = io1.out.file.handle;
2680 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2681 CHECK_LEASE(&io1, "RWH", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS);
2682 smb2_util_close(tree, h1b);
2683
2684 /*
2685 * a conflicting open with NTCREATEX_DISP_OVERWRITE
2686 * doesn't trigger an immediate lease break to none.
2687 */
2688 lease_break_info_tmp = lease_break_info;
2689 torture_reset_lease_break_info(tctx, &lease_break_info);
2690 smb2_oplock_create(&io3, fname, SMB2_OPLOCK_LEVEL_NONE);
2691 io3.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
2692 req3 = smb2_create_send(tree, &io3);
2693 torture_assert(tctx, req3 != NULL, "smb2_create_send");
2694 CHECK_NO_BREAK(tctx);
2695 lease_break_info = lease_break_info_tmp;
2696
2697 torture_assert(tctx, req3->state == SMB2_REQUEST_RECV, "req3 pending");
2698
2699 ack.in.lease.lease_key =
2700 lease_break_info.lease_break.current_lease.lease_key;
2701 ack.in.lease.lease_state =
2702 lease_break_info.lease_break.new_lease_state;
2703 torture_reset_lease_break_info(tctx, &lease_break_info);
2704
2705 /*
2706 * a open using the same lease key is still works,
2707 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
2708 */
2709 status = smb2_create(tree, mem_ctx, &io1);
2710 CHECK_STATUS(status, NT_STATUS_OK);
2711 h1b = io1.out.file.handle;
2712 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2713 CHECK_LEASE(&io1, "RWH", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS);
2714 smb2_util_close(tree, h1b);
2715
2716 CHECK_NO_BREAK(tctx);
2717
2718 /*
2719 * We ack the lease break, but defer acking the next break (to "R")
2720 */
2721 lease_break_info.lease_skip_ack = true;
2722 status = smb2_lease_break_ack(tree, &ack);
2723 CHECK_STATUS(status, NT_STATUS_OK);
2724 CHECK_LEASE_BREAK_ACK(&ack, "RH", LEASE1);
2725
2726 /*
2727 * We got an additional break downgrading to just "R"
2728 * while we defer the ack.
2729 */
2730 CHECK_BREAK_INFO("RH", "R", LEASE1);
2731
2732 ack.in.lease.lease_key =
2733 lease_break_info.lease_break.current_lease.lease_key;
2734 ack.in.lease.lease_state =
2735 lease_break_info.lease_break.new_lease_state;
2736 torture_reset_lease_break_info(tctx, &lease_break_info);
2737
2738 /*
2739 * a open using the same lease key is still works,
2740 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
2741 */
2742 status = smb2_create(tree, mem_ctx, &io1);
2743 CHECK_STATUS(status, NT_STATUS_OK);
2744 h1b = io1.out.file.handle;
2745 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2746 CHECK_LEASE(&io1, "RH", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS);
2747 smb2_util_close(tree, h1b);
2748
2749 CHECK_NO_BREAK(tctx);
2750
2751 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
2752 torture_assert(tctx, req3->state == SMB2_REQUEST_RECV, "req3 pending");
2753
2754 /*
2755 * We ack the downgrade to "R" and get an immediate break to none
2756 */
2757 status = smb2_lease_break_ack(tree, &ack);
2758 CHECK_STATUS(status, NT_STATUS_OK);
2759 CHECK_LEASE_BREAK_ACK(&ack, "R", LEASE1);
2760
2761 /*
2762 * We get the downgrade to none.
2763 */
2764 CHECK_BREAK_INFO("R", "", LEASE1);
2765
2766 torture_assert(tctx, req2->cancel.can_cancel,
2767 "req2 can_cancel");
2768 torture_assert(tctx, req3->cancel.can_cancel,
2769 "req3 can_cancel");
2770
2771 torture_reset_lease_break_info(tctx, &lease_break_info);
2772
2773 status = smb2_create_recv(req2, tctx, &io2);
2774 CHECK_STATUS(status, NT_STATUS_OK);
2775 h2 = io2.out.file.handle;
2776 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2777 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
2778
2779 status = smb2_create_recv(req3, tctx, &io3);
2780 CHECK_STATUS(status, NT_STATUS_OK);
2781 h3 = io3.out.file.handle;
2782 CHECK_CREATED(&io3, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
2783 CHECK_VAL(io3.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
2784
2785 CHECK_NO_BREAK(tctx);
2786 done:
2787 smb2_util_close(tree, h1a);
2788 smb2_util_close(tree, h1b);
2789 smb2_util_close(tree, h2);
2790 smb2_util_close(tree, h3);
2791
2792 smb2_util_unlink(tree, fname);
2793 talloc_free(mem_ctx);
2794 return ret;
2795 }
2796
2797 static bool test_lease_v2_breaking3(struct torture_context *tctx,
2798 struct smb2_tree *tree)
2799 {
2800 TALLOC_CTX *mem_ctx = talloc_new(tctx);
2801 struct smb2_create io1 = {};
2802 struct smb2_create io2 = {};
2803 struct smb2_create io3 = {};
2804 struct smb2_lease ls1 = {};
2805 struct smb2_handle h1a = {};
2806 struct smb2_handle h1b = {};
2807 struct smb2_handle h2 = {};
2808 struct smb2_handle h3 = {};
2809 struct smb2_request *req2 = NULL;
2810 struct smb2_request *req3 = NULL;
2811 struct lease_break_info lease_break_info_tmp = {};
2812 struct smb2_lease_break_ack ack = {};
2813 const char *fname = "v2_lease_breaking3.dat";
2814 bool ret = true;
2815 NTSTATUS status;
2816 uint32_t caps;
2817 enum protocol_types protocol;
2818
2819 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
2820 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
2821
2822 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
2823 if (protocol < PROTOCOL_SMB3_00) {
2824 torture_skip(tctx, "v2 leases are not supported");
2825 }
2826
2827 smb2_util_unlink(tree, fname);
2828
2829 tree->session->transport->lease.handler = torture_lease_handler;
2830 tree->session->transport->lease.private_data = tree;
2831 tree->session->transport->oplock.handler = torture_oplock_handler;
2832 tree->session->transport->oplock.private_data = tree;
2833
2834 /*
2835 * we defer acking the lease break.
2836 */
2837 torture_reset_lease_break_info(tctx, &lease_break_info);
2838 lease_break_info.lease_skip_ack = true;
2839
2840 smb2_lease_v2_create_share(&io1, &ls1, false, fname,
2841 smb2_util_share_access("RWD"),
2842 LEASE1, NULL,
2843 smb2_util_lease_state("RHW"),
2844 0x11);
2845 status = smb2_create(tree, mem_ctx, &io1);
2846 CHECK_STATUS(status, NT_STATUS_OK);
2847 h1a = io1.out.file.handle;
2848 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
2849 /* Epoch increases on open. */
2850 ls1.lease_epoch += 1;
2851 CHECK_LEASE_V2(&io1, "RHW", true, LEASE1, 0, 0, ls1.lease_epoch);
2852
2853 /*
2854 * a conflicting open is blocked until we ack the
2855 * lease break
2856 */
2857 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
2858 req2 = smb2_create_send(tree, &io2);
2859 torture_assert(tctx, req2 != NULL, "smb2_create_send");
2860
2861 /*
2862 * we got the lease break, but defer the ack.
2863 */
2864 CHECK_BREAK_INFO_V2(tree->session->transport,
2865 "RWH", "RH", LEASE1, ls1.lease_epoch + 1);
2866
2867 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
2868
2869 /* On receiving a lease break, we must sync the new epoch. */
2870 ls1.lease_epoch = lease_break_info.lease_break.new_epoch;
2871
2872 /*
2873 * a open using the same lease key is still works,
2874 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
2875 */
2876 status = smb2_create(tree, mem_ctx, &io1);
2877 CHECK_STATUS(status, NT_STATUS_OK);
2878 h1b = io1.out.file.handle;
2879 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2880 CHECK_LEASE_V2(&io1, "RHW", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS, 0, ls1.lease_epoch);
2881 smb2_util_close(tree, h1b);
2882
2883 /*
2884 * a conflicting open with NTCREATEX_DISP_OVERWRITE
2885 * doesn't trigger an immediate lease break to none.
2886 */
2887 lease_break_info_tmp = lease_break_info;
2888 torture_reset_lease_break_info(tctx, &lease_break_info);
2889 smb2_oplock_create(&io3, fname, SMB2_OPLOCK_LEVEL_NONE);
2890 io3.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
2891 req3 = smb2_create_send(tree, &io3);
2892 torture_assert(tctx, req3 != NULL, "smb2_create_send");
2893 CHECK_NO_BREAK(tctx);
2894 lease_break_info = lease_break_info_tmp;
2895
2896 torture_assert(tctx, req3->state == SMB2_REQUEST_RECV, "req3 pending");
2897
2898 ack.in.lease.lease_key =
2899 lease_break_info.lease_break.current_lease.lease_key;
2900 ack.in.lease.lease_state =
2901 lease_break_info.lease_break.new_lease_state;
2902 torture_reset_lease_break_info(tctx, &lease_break_info);
2903
2904 /*
2905 * a open using the same lease key is still works,
2906 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
2907 */
2908 status = smb2_create(tree, mem_ctx, &io1);
2909 CHECK_STATUS(status, NT_STATUS_OK);
2910 h1b = io1.out.file.handle;
2911 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2912 CHECK_LEASE_V2(&io1, "RHW", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS, 0, ls1.lease_epoch);
2913 smb2_util_close(tree, h1b);
2914
2915 CHECK_NO_BREAK(tctx);
2916
2917 /*
2918 * We ack the lease break, but defer acking the next break (to "R")
2919 */
2920 lease_break_info.lease_skip_ack = true;
2921 status = smb2_lease_break_ack(tree, &ack);
2922 CHECK_STATUS(status, NT_STATUS_OK);
2923 CHECK_LEASE_BREAK_ACK(&ack, "RH", LEASE1);
2924
2925 /*
2926 * We got an additional break downgrading to just "R"
2927 * while we defer the ack.
2928 */
2929 CHECK_BREAK_INFO_V2(tree->session->transport,
2930 "RH", "R", LEASE1, ls1.lease_epoch);
2931 /* On receiving a lease break, we must sync the new epoch. */
2932 ls1.lease_epoch = lease_break_info.lease_break.new_epoch;
2933
2934 ack.in.lease.lease_key =
2935 lease_break_info.lease_break.current_lease.lease_key;
2936 ack.in.lease.lease_state =
2937 lease_break_info.lease_break.new_lease_state;
2938 torture_reset_lease_break_info(tctx, &lease_break_info);
2939
2940 /*
2941 * a open using the same lease key is still works,
2942 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
2943 */
2944 status = smb2_create(tree, mem_ctx, &io1);
2945 CHECK_STATUS(status, NT_STATUS_OK);
2946 h1b = io1.out.file.handle;
2947 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2948 CHECK_LEASE_V2(&io1, "RH", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS, 0, ls1.lease_epoch);
2949 smb2_util_close(tree, h1b);
2950
2951 CHECK_NO_BREAK(tctx);
2952
2953 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
2954 torture_assert(tctx, req3->state == SMB2_REQUEST_RECV, "req3 pending");
2955
2956 /*
2957 * We ack the downgrade to "R" and get an immediate break to none
2958 */
2959 status = smb2_lease_break_ack(tree, &ack);
2960 CHECK_STATUS(status, NT_STATUS_OK);
2961 CHECK_LEASE_BREAK_ACK(&ack, "R", LEASE1);
2962
2963 /*
2964 * We get the downgrade to none.
2965 */
2966 CHECK_BREAK_INFO_V2(tree->session->transport,
2967 "R", "", LEASE1, ls1.lease_epoch);
2968
2969 torture_assert(tctx, req2->cancel.can_cancel,
2970 "req2 can_cancel");
2971 torture_assert(tctx, req3->cancel.can_cancel,
2972 "req3 can_cancel");
2973
2974 torture_reset_lease_break_info(tctx, &lease_break_info);
2975
2976 status = smb2_create_recv(req2, tctx, &io2);
2977 CHECK_STATUS(status, NT_STATUS_OK);
2978 h2 = io2.out.file.handle;
2979 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
2980 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
2981
2982 status = smb2_create_recv(req3, tctx, &io3);
2983 CHECK_STATUS(status, NT_STATUS_OK);
2984 h3 = io3.out.file.handle;
2985 CHECK_CREATED(&io3, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
2986 CHECK_VAL(io3.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
2987
2988 CHECK_NO_BREAK(tctx);
2989 done:
2990 smb2_util_close(tree, h1a);
2991 smb2_util_close(tree, h1b);
2992 smb2_util_close(tree, h2);
2993 smb2_util_close(tree, h3);
2994
2995 smb2_util_unlink(tree, fname);
2996 talloc_free(mem_ctx);
2997 return ret;
2998 }
2999
3000
3001 static bool test_lease_breaking4(struct torture_context *tctx,
3002 struct smb2_tree *tree)
3003 {
3004 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3005 struct smb2_create io1 = {};
3006 struct smb2_create io2 = {};
3007 struct smb2_create io3 = {};
3008 struct smb2_lease ls1 = {};
3009 struct smb2_lease ls1t = {};
3010 struct smb2_handle h1 = {};
3011 struct smb2_handle h2 = {};
3012 struct smb2_handle h3 = {};
3013 struct smb2_request *req2 = NULL;
3014 struct lease_break_info lease_break_info_tmp = {};
3015 struct smb2_lease_break_ack ack = {};
3016 const char *fname = "lease_breaking4.dat";
3017 bool ret = true;
3018 NTSTATUS status;
3019 uint32_t caps;
3020
3021 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
3022 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3023
3024 smb2_util_unlink(tree, fname);
3025
3026 tree->session->transport->lease.handler = torture_lease_handler;
3027 tree->session->transport->lease.private_data = tree;
3028 tree->session->transport->oplock.handler = torture_oplock_handler;
3029 tree->session->transport->oplock.private_data = tree;
3030
3031 /*
3032 * we defer acking the lease break.
3033 */
3034 torture_reset_lease_break_info(tctx, &lease_break_info);
3035 lease_break_info.lease_skip_ack = true;
3036
3037 smb2_lease_create_share(&io1, &ls1, false, fname,
3038 smb2_util_share_access("RWD"),
3039 LEASE1,
3040 smb2_util_lease_state("RH"));
3041 status = smb2_create(tree, mem_ctx, &io1);
3042 CHECK_STATUS(status, NT_STATUS_OK);
3043 h1 = io1.out.file.handle;
3044 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3045 CHECK_LEASE(&io1, "RH", true, LEASE1, 0);
3046
3047 CHECK_NO_BREAK(tctx);
3048
3049 /*
3050 * a conflicting open is *not* blocked until we ack the
3051 * lease break
3052 */
3053 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
3054 io2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
3055 req2 = smb2_create_send(tree, &io2);
3056 torture_assert(tctx, req2 != NULL, "smb2_create_send");
3057
3058 /*
3059 * We got a break from RH to NONE, we're supported to ack
3060 * this downgrade
3061 */
3062 CHECK_BREAK_INFO("RH", "", LEASE1);
3063
3064 lease_break_info_tmp = lease_break_info;
3065 torture_reset_lease_break_info(tctx, &lease_break_info);
3066 CHECK_NO_BREAK(tctx);
3067
3068 torture_assert(tctx, req2->state == SMB2_REQUEST_DONE, "req2 done");
3069
3070 status = smb2_create_recv(req2, tctx, &io2);
3071 CHECK_STATUS(status, NT_STATUS_OK);
3072 h2 = io2.out.file.handle;
3073 CHECK_CREATED(&io2, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
3074 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
3075 smb2_util_close(tree, h2);
3076
3077 CHECK_NO_BREAK(tctx);
3078
3079 /*
3080 * a conflicting open is *not* blocked until we ack the
3081 * lease break, even if the lease is in breaking state.
3082 */
3083 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
3084 io2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
3085 req2 = smb2_create_send(tree, &io2);
3086 torture_assert(tctx, req2 != NULL, "smb2_create_send");
3087
3088 CHECK_NO_BREAK(tctx);
3089
3090 torture_assert(tctx, req2->state == SMB2_REQUEST_DONE, "req2 done");
3091
3092 status = smb2_create_recv(req2, tctx, &io2);
3093 CHECK_STATUS(status, NT_STATUS_OK);
3094 h2 = io2.out.file.handle;
3095 CHECK_CREATED(&io2, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
3096 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
3097 smb2_util_close(tree, h2);
3098
3099 CHECK_NO_BREAK(tctx);
3100
3101 /*
3102 * We now ask the server about the current lease state
3103 * which should still be "RH", but with
3104 * SMB2_LEASE_FLAG_BREAK_IN_PROGRESS.
3105 */
3106 smb2_lease_create_share(&io3, &ls1t, false, fname,
3107 smb2_util_share_access("RWD"),
3108 LEASE1,
3109 smb2_util_lease_state(""));
3110 status = smb2_create(tree, mem_ctx, &io3);
3111 CHECK_STATUS(status, NT_STATUS_OK);
3112 h3 = io3.out.file.handle;
3113 CHECK_CREATED(&io3, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3114 CHECK_LEASE(&io3, "RH", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS);
3115
3116 /*
3117 * We finally ack the lease break...
3118 */
3119 CHECK_NO_BREAK(tctx);
3120 lease_break_info = lease_break_info_tmp;
3121 ack.in.lease.lease_key =
3122 lease_break_info.lease_break.current_lease.lease_key;
3123 ack.in.lease.lease_state =
3124 lease_break_info.lease_break.new_lease_state;
3125 torture_reset_lease_break_info(tctx, &lease_break_info);
3126 lease_break_info.lease_skip_ack = true;
3127
3128 status = smb2_lease_break_ack(tree, &ack);
3129 CHECK_STATUS(status, NT_STATUS_OK);
3130 CHECK_LEASE_BREAK_ACK(&ack, "", LEASE1);
3131
3132 CHECK_NO_BREAK(tctx);
3133
3134 done:
3135 smb2_util_close(tree, h1);
3136 smb2_util_close(tree, h2);
3137 smb2_util_close(tree, h3);
3138
3139 smb2_util_unlink(tree, fname);
3140 talloc_free(mem_ctx);
3141 return ret;
3142 }
3143
3144 static bool test_lease_breaking5(struct torture_context *tctx,
3145 struct smb2_tree *tree)
3146 {
3147 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3148 struct smb2_create io1 = {};
3149 struct smb2_create io2 = {};
3150 struct smb2_create io3 = {};
3151 struct smb2_lease ls1 = {};
3152 struct smb2_lease ls1t = {};
3153 struct smb2_handle h1 = {};
3154 struct smb2_handle h2 = {};
3155 struct smb2_handle h3 = {};
3156 struct smb2_request *req2 = NULL;
3157 struct lease_break_info lease_break_info_tmp = {};
3158 struct smb2_lease_break_ack ack = {};
3159 const char *fname = "lease_breaking5.dat";
3160 bool ret = true;
3161 NTSTATUS status;
3162 uint32_t caps;
3163
3164 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
3165 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3166
3167 smb2_util_unlink(tree, fname);
3168
3169 tree->session->transport->lease.handler = torture_lease_handler;
3170 tree->session->transport->lease.private_data = tree;
3171 tree->session->transport->oplock.handler = torture_oplock_handler;
3172 tree->session->transport->oplock.private_data = tree;
3173
3174 /*
3175 * we defer acking the lease break.
3176 */
3177 torture_reset_lease_break_info(tctx, &lease_break_info);
3178 lease_break_info.lease_skip_ack = true;
3179
3180 smb2_lease_create_share(&io1, &ls1, false, fname,
3181 smb2_util_share_access("RWD"),
3182 LEASE1,
3183 smb2_util_lease_state("R"));
3184 status = smb2_create(tree, mem_ctx, &io1);
3185 CHECK_STATUS(status, NT_STATUS_OK);
3186 h1 = io1.out.file.handle;
3187 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3188 CHECK_LEASE(&io1, "R", true, LEASE1, 0);
3189
3190 CHECK_NO_BREAK(tctx);
3191
3192 /*
3193 * a conflicting open is *not* blocked until we ack the
3194 * lease break
3195 */
3196 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
3197 io2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
3198 req2 = smb2_create_send(tree, &io2);
3199 torture_assert(tctx, req2 != NULL, "smb2_create_send");
3200
3201 /*
3202 * We got a break from RH to NONE, we're supported to ack
3203 * this downgrade
3204 */
3205 CHECK_BREAK_INFO("R", "", LEASE1);
3206
3207 lease_break_info_tmp = lease_break_info;
3208 torture_reset_lease_break_info(tctx, &lease_break_info);
3209 CHECK_NO_BREAK(tctx);
3210
3211 torture_assert(tctx, req2->state == SMB2_REQUEST_DONE, "req2 done");
3212
3213 status = smb2_create_recv(req2, tctx, &io2);
3214 CHECK_STATUS(status, NT_STATUS_OK);
3215 h2 = io2.out.file.handle;
3216 CHECK_CREATED(&io2, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
3217 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
3218
3219 CHECK_NO_BREAK(tctx);
3220
3221 /*
3222 * We now ask the server about the current lease state
3223 * which should still be "RH", but with
3224 * SMB2_LEASE_FLAG_BREAK_IN_PROGRESS.
3225 */
3226 smb2_lease_create_share(&io3, &ls1t, false, fname,
3227 smb2_util_share_access("RWD"),
3228 LEASE1,
3229 smb2_util_lease_state(""));
3230 status = smb2_create(tree, mem_ctx, &io3);
3231 CHECK_STATUS(status, NT_STATUS_OK);
3232 h3 = io3.out.file.handle;
3233 CHECK_CREATED(&io3, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3234 CHECK_LEASE(&io3, "", true, LEASE1, 0);
3235
3236 /*
3237 * We send an ack without without being asked.
3238 */
3239 CHECK_NO_BREAK(tctx);
3240 lease_break_info = lease_break_info_tmp;
3241 ack.in.lease.lease_key =
3242 lease_break_info.lease_break.current_lease.lease_key;
3243 ack.in.lease.lease_state =
3244 lease_break_info.lease_break.new_lease_state;
3245 torture_reset_lease_break_info(tctx, &lease_break_info);
3246 status = smb2_lease_break_ack(tree, &ack);
3247 CHECK_STATUS(status, NT_STATUS_UNSUCCESSFUL);
3248
3249 CHECK_NO_BREAK(tctx);
3250
3251 done:
3252 smb2_util_close(tree, h1);
3253 smb2_util_close(tree, h2);
3254 smb2_util_close(tree, h3);
3255
3256 smb2_util_unlink(tree, fname);
3257 talloc_free(mem_ctx);
3258 return ret;
3259 }
3260
3261 static bool test_lease_breaking6(struct torture_context *tctx,
3262 struct smb2_tree *tree)
3263 {
3264 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3265 struct smb2_create io1 = {};
3266 struct smb2_create io2 = {};
3267 struct smb2_lease ls1 = {};
3268 struct smb2_handle h1a = {};
3269 struct smb2_handle h1b = {};
3270 struct smb2_handle h2 = {};
3271 struct smb2_request *req2 = NULL;
3272 struct smb2_lease_break_ack ack = {};
3273 const char *fname = "lease_breaking6.dat";
3274 bool ret = true;
3275 NTSTATUS status;
3276 uint32_t caps;
3277
3278 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
3279 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3280
3281 smb2_util_unlink(tree, fname);
3282
3283 tree->session->transport->lease.handler = torture_lease_handler;
3284 tree->session->transport->lease.private_data = tree;
3285 tree->session->transport->oplock.handler = torture_oplock_handler;
3286 tree->session->transport->oplock.private_data = tree;
3287
3288 /*
3289 * we defer acking the lease break.
3290 */
3291 torture_reset_lease_break_info(tctx, &lease_break_info);
3292 lease_break_info.lease_skip_ack = true;
3293
3294 smb2_lease_create_share(&io1, &ls1, false, fname,
3295 smb2_util_share_access("RWD"),
3296 LEASE1,
3297 smb2_util_lease_state("RWH"));
3298 status = smb2_create(tree, mem_ctx, &io1);
3299 CHECK_STATUS(status, NT_STATUS_OK);
3300 h1a = io1.out.file.handle;
3301 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3302 CHECK_LEASE(&io1, "RWH", true, LEASE1, 0);
3303
3304 /*
3305 * a conflicting open is blocked until we ack the
3306 * lease break
3307 */
3308 smb2_oplock_create(&io2, fname, SMB2_OPLOCK_LEVEL_NONE);
3309 req2 = smb2_create_send(tree, &io2);
3310 torture_assert(tctx, req2 != NULL, "smb2_create_send");
3311
3312 /*
3313 * we got the lease break, but defer the ack.
3314 */
3315 CHECK_BREAK_INFO("RWH", "RH", LEASE1);
3316
3317 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
3318
3319 ack.in.lease.lease_key =
3320 lease_break_info.lease_break.current_lease.lease_key;
3321 torture_reset_lease_break_info(tctx, &lease_break_info);
3322
3323 /*
3324 * a open using the same lease key is still works,
3325 * but reports SMB2_LEASE_FLAG_BREAK_IN_PROGRESS
3326 */
3327 status = smb2_create(tree, mem_ctx, &io1);
3328 CHECK_STATUS(status, NT_STATUS_OK);
3329 h1b = io1.out.file.handle;
3330 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3331 CHECK_LEASE(&io1, "RWH", true, LEASE1, SMB2_LEASE_FLAG_BREAK_IN_PROGRESS);
3332 smb2_util_close(tree, h1b);
3333
3334 CHECK_NO_BREAK(tctx);
3335
3336 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
3337
3338 /*
3339 * We are asked to break to "RH", but we are allowed to
3340 * break to any of "RH", "R" or NONE.
3341 */
3342 ack.in.lease.lease_state = SMB2_LEASE_NONE;
3343 status = smb2_lease_break_ack(tree, &ack);
3344 CHECK_STATUS(status, NT_STATUS_OK);
3345 CHECK_LEASE_BREAK_ACK(&ack, "", LEASE1);
3346
3347 torture_assert(tctx, req2->cancel.can_cancel,
3348 "req2 can_cancel");
3349
3350 status = smb2_create_recv(req2, tctx, &io2);
3351 CHECK_STATUS(status, NT_STATUS_OK);
3352 h2 = io2.out.file.handle;
3353 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3354 CHECK_VAL(io2.out.oplock_level, SMB2_OPLOCK_LEVEL_NONE);
3355
3356 CHECK_NO_BREAK(tctx);
3357 done:
3358 smb2_util_close(tree, h1a);
3359 smb2_util_close(tree, h1b);
3360 smb2_util_close(tree, h2);
3361 smb2_util_unlink(tree, fname);
3362 talloc_free(mem_ctx);
3363 return ret;
3364 }
3365
3366 static bool test_lease_lock1(struct torture_context *tctx,
3367 struct smb2_tree *tree1a,
3368 struct smb2_tree *tree2)
3369 {
3370 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3371 struct smb2_create io1 = {};
3372 struct smb2_create io2 = {};
3373 struct smb2_create io3 = {};
3374 struct smb2_lease ls1 = {};
3375 struct smb2_lease ls2 = {};
3376 struct smb2_lease ls3 = {};
3377 struct smb2_handle h1 = {};
3378 struct smb2_handle h2 = {};
3379 struct smb2_handle h3 = {};
3380 struct smb2_lock lck;
3381 struct smb2_lock_element el[1];
3382 const char *fname = "locktest.dat";
3383 bool ret = true;
3384 NTSTATUS status;
3385 uint32_t caps;
3386 struct smbcli_options options1;
3387 struct smb2_tree *tree1b = NULL;
3388
3389 options1 = tree1a->session->transport->options;
3390
3391 caps = smb2cli_conn_server_capabilities(tree1a->session->transport->conn);
3392 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3393
3394 /* Set up handlers. */
3395 tree2->session->transport->lease.handler = torture_lease_handler;
3396 tree2->session->transport->lease.private_data = tree2;
3397 tree2->session->transport->oplock.handler = torture_oplock_handler;
3398 tree2->session->transport->oplock.private_data = tree2;
3399
3400 tree1a->session->transport->lease.handler = torture_lease_handler;
3401 tree1a->session->transport->lease.private_data = tree1a;
3402 tree1a->session->transport->oplock.handler = torture_oplock_handler;
3403 tree1a->session->transport->oplock.private_data = tree1a;
3404
3405 /* create a new connection (same client_guid) */
3406 if (!torture_smb2_connection_ext(tctx, 0, &options1, &tree1b)) {
3407 torture_warning(tctx, "couldn't reconnect, bailing\n");
3408 ret = false;
3409 goto done;
3410 }
3411
3412 tree1b->session->transport->lease.handler = torture_lease_handler;
3413 tree1b->session->transport->lease.private_data = tree1b;
3414 tree1b->session->transport->oplock.handler = torture_oplock_handler;
3415 tree1b->session->transport->oplock.private_data = tree1b;
3416
3417 smb2_util_unlink(tree1a, fname);
3418
3419 torture_reset_lease_break_info(tctx, &lease_break_info);
3420 ZERO_STRUCT(lck);
3421
3422 /* Open a handle on tree1a. */
3423 smb2_lease_create_share(&io1, &ls1, false, fname,
3424 smb2_util_share_access("RWD"),
3425 LEASE1,
3426 smb2_util_lease_state("RWH"));
3427 status = smb2_create(tree1a, mem_ctx, &io1);
3428 CHECK_STATUS(status, NT_STATUS_OK);
3429 h1 = io1.out.file.handle;
3430 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3431 CHECK_LEASE(&io1, "RWH", true, LEASE1, 0);
3432
3433 /* Open a second handle on tree1b. */
3434 smb2_lease_create_share(&io2, &ls2, false, fname,
3435 smb2_util_share_access("RWD"),
3436 LEASE2,
3437 smb2_util_lease_state("RWH"));
3438 status = smb2_create(tree1b, mem_ctx, &io2);
3439 CHECK_STATUS(status, NT_STATUS_OK);
3440 h2 = io2.out.file.handle;
3441 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3442 CHECK_LEASE(&io2, "RH", true, LEASE2, 0);
3443 /* And LEASE1 got broken to RH. */
3444 CHECK_BREAK_INFO("RWH", "RH", LEASE1);
3445 torture_reset_lease_break_info(tctx, &lease_break_info);
3446
3447 /* Now open a lease on a different client guid. */
3448 smb2_lease_create_share(&io3, &ls3, false, fname,
3449 smb2_util_share_access("RWD"),
3450 LEASE3,
3451 smb2_util_lease_state("RWH"));
3452 status = smb2_create(tree2, mem_ctx, &io3);
3453 CHECK_STATUS(status, NT_STATUS_OK);
3454 h3 = io3.out.file.handle;
3455 CHECK_CREATED(&io3, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3456 CHECK_LEASE(&io3, "RH", true, LEASE3, 0);
3457 /* Doesn't break. */
3458 CHECK_NO_BREAK(tctx);
3459
3460 lck.in.locks = el;
3461 /*
3462 * Try and get get an exclusive byte
3463 * range lock on H1 (LEASE1).
3464 */
3465
3466 lck.in.lock_count = 1;
3467 lck.in.lock_sequence = 1;
3468 lck.in.file.handle = h1;
3469 el[0].offset = 0;
3470 el[0].length = 1;
3471 el[0].reserved = 0;
3472 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
3473 status = smb2_lock(tree1a, &lck);
3474 CHECK_STATUS(status, NT_STATUS_OK);
3475
3476 /* LEASE2 and LEASE3 should get broken to NONE. */
3477 torture_wait_for_lease_break(tctx);
3478 torture_wait_for_lease_break(tctx);
3479 torture_wait_for_lease_break(tctx);
3480 torture_wait_for_lease_break(tctx);
3481
3482 CHECK_VAL(lease_break_info.failures, 0); \
3483 CHECK_VAL(lease_break_info.count, 2); \
3484
3485 /* Get state of the H1 (LEASE1) */
3486 smb2_lease_create(&io1, &ls1, false, fname, LEASE1, smb2_util_lease_state(""));
3487 status = smb2_create(tree1a, mem_ctx, &io1);
3488 CHECK_STATUS(status, NT_STATUS_OK);
3489 /* Should still be RH. */
3490 CHECK_LEASE(&io1, "RH", true, LEASE1, 0);
3491 smb2_util_close(tree1a, io1.out.file.handle);
3492
3493 /* Get state of the H2 (LEASE2) */
3494 smb2_lease_create(&io2, &ls2, false, fname, LEASE2, smb2_util_lease_state(""));
3495 status = smb2_create(tree1b, mem_ctx, &io2);
3496 CHECK_STATUS(status, NT_STATUS_OK);
3497 CHECK_LEASE(&io2, "", true, LEASE2, 0);
3498 smb2_util_close(tree1b, io2.out.file.handle);
3499
3500 /* Get state of the H3 (LEASE3) */
3501 smb2_lease_create(&io3, &ls3, false, fname, LEASE3, smb2_util_lease_state(""));
3502 status = smb2_create(tree2, mem_ctx, &io3);
3503 CHECK_STATUS(status, NT_STATUS_OK);
3504 CHECK_LEASE(&io3, "", true, LEASE3, 0);
3505 smb2_util_close(tree2, io3.out.file.handle);
3506
3507 torture_reset_lease_break_info(tctx, &lease_break_info);
3508
3509 /*
3510 * Try and get get an exclusive byte
3511 * range lock on H3 (LEASE3).
3512 */
3513 lck.in.lock_count = 1;
3514 lck.in.lock_sequence = 2;
3515 lck.in.file.handle = h3;
3516 el[0].offset = 100;
3517 el[0].length = 1;
3518 el[0].reserved = 0;
3519 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
3520 status = smb2_lock(tree2, &lck);
3521 CHECK_STATUS(status, NT_STATUS_OK);
3522 /* LEASE1 got broken to NONE. */
3523 CHECK_BREAK_INFO("RH", "", LEASE1);
3524 torture_reset_lease_break_info(tctx, &lease_break_info);
3525
3526 done:
3527 smb2_util_close(tree1a, h1);
3528 smb2_util_close(tree1b, h2);
3529 smb2_util_close(tree2, h3);
3530
3531 smb2_util_unlink(tree1a, fname);
3532 talloc_free(mem_ctx);
3533 return ret;
3534 }
3535
3536 /*
3537 * Verifies byterange locks only affect lease state if the lock is actually
3538 * "backed" by the file. Eg, if a file has size 0, byterange locks will never
3539 * affect lease state.
3540 *
3541 * Client 1: create file with lease=RWH
3542 * Client 1: set brl off=0, size=1
3543 * Client 2: open file, expect pending
3544 * Server: expect lease break to RH
3545 * Client 2: expect open success with lease=RH
3546 */
3547 static bool test_lease_lock2(struct torture_context *tctx,
3548 struct smb2_tree *tree1,
3549 struct smb2_tree *tree2)
3550 {
3551 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3552 struct smb2_create io1 = {};
3553 struct smb2_create io2 = {};
3554 struct smb2_lease ls1 = {};
3555 struct smb2_lease ls2 = {};
3556 struct smb2_handle h1 = {};
3557 struct smb2_handle h2 = {};
3558 struct smb2_lock lck = {};
3559 struct smb2_lock_element el = {};
3560 const char *fname = __FUNCTION__;
3561 bool ret = true;
3562 NTSTATUS status;
3563 uint32_t caps;
3564
3565 caps = smb2cli_conn_server_capabilities(tree1->session->transport->conn);
3566 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3567
3568 /* Set up handlers. */
3569 tree1->session->transport->lease.handler = torture_lease_handler;
3570 tree1->session->transport->lease.private_data = tree1;
3571 tree2->session->transport->lease.handler = torture_lease_handler;
3572 tree2->session->transport->lease.private_data = tree2;
3573
3574 smb2_util_unlink(tree1, fname);
3575
3576 torture_reset_lease_break_info(tctx, &lease_break_info);
3577
3578 /* Open a handle on tree1. */
3579 smb2_lease_create_share(&io1, &ls1, false, fname,
3580 smb2_util_share_access("RWD"),
3581 LEASE1,
3582 smb2_util_lease_state("RWH"));
3583 status = smb2_create(tree1, mem_ctx, &io1);
3584 CHECK_STATUS(status, NT_STATUS_OK);
3585 h1 = io1.out.file.handle;
3586 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3587 CHECK_LEASE(&io1, "RWH", true, LEASE1, 0);
3588
3589 /*
3590 * Try and get get an exclusive byte
3591 * range lock on H1 (LEASE1).
3592 */
3593 lck.in.locks = &el;
3594 lck.in.lock_count = 1;
3595 lck.in.lock_sequence = 1;
3596 lck.in.file.handle = h1;
3597 el.offset = 0;
3598 el.length = 1;
3599 el.reserved = 0;
3600 el.flags = SMB2_LOCK_FLAG_EXCLUSIVE;
3601 status = smb2_lock(tree1, &lck);
3602 CHECK_STATUS(status, NT_STATUS_OK);
3603
3604 /* Open a second handle on tree2. */
3605 smb2_lease_create_share(&io2, &ls2, false, fname,
3606 smb2_util_share_access("RWD"),
3607 LEASE2,
3608 smb2_util_lease_state("RWH"));
3609 status = smb2_create(tree2, mem_ctx, &io2);
3610 CHECK_STATUS(status, NT_STATUS_OK);
3611 h2 = io2.out.file.handle;
3612 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3613 CHECK_LEASE(&io2, "RH", true, LEASE2, 0);
3614 /* And LEASE1 got broken to RH. */
3615 CHECK_BREAK_INFO("RWH", "RH", LEASE1);
3616 torture_reset_lease_break_info(tctx, &lease_break_info);
3617
3618 done:
3619 smb2_util_close(tree1, h1);
3620 smb2_util_close(tree2, h2);
3621
3622 smb2_util_unlink(tree1, fname);
3623 talloc_free(mem_ctx);
3624 return ret;
3625 }
3626
3627 /*
3628 * Verifies a create with overwrite disposition on a file with a byterange lock
3629 * can get an RH lease.
3630 *
3631 * Client 1: create file with lease=RWH
3632 * Client 1: write 1 byte to the file
3633 * Client 1: set brl off=0, size=1
3634 * Client 2: open file with overwrite disposition, expect status pending
3635 * Server -> Client 1: Break lease break to none
3636 * Client 2: expect open success with lease=RH
3637 */
3638 static bool test_lease_lock3(struct torture_context *tctx,
3639 struct smb2_tree *tree1,
3640 struct smb2_tree *tree2)
3641 {
3642 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3643 struct smb2_create io1 = {};
3644 struct smb2_create io2 = {};
3645 struct smb2_lease ls1 = {};
3646 struct smb2_lease ls2 = {};
3647 struct smb2_handle h1 = {};
3648 struct smb2_handle h2 = {};
3649 struct smb2_lock lck = {};
3650 struct smb2_lock_element el = {};
3651 const char *fname = __FUNCTION__;
3652 char c = 'x';
3653 bool ret = true;
3654 NTSTATUS status;
3655 uint32_t caps;
3656
3657 caps = smb2cli_conn_server_capabilities(tree1->session->transport->conn);
3658 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3659
3660 /* Set up handlers. */
3661 tree1->session->transport->lease.handler = torture_lease_handler;
3662 tree1->session->transport->lease.private_data = tree1;
3663 tree2->session->transport->lease.handler = torture_lease_handler;
3664 tree2->session->transport->lease.private_data = tree2;
3665
3666 smb2_util_unlink(tree1, fname);
3667
3668 torture_reset_lease_break_info(tctx, &lease_break_info);
3669
3670 /* Open a handle on tree1. */
3671 smb2_lease_create_share(&io1, &ls1, false, fname,
3672 smb2_util_share_access("RWD"),
3673 LEASE1,
3674 smb2_util_lease_state("RWH"));
3675 status = smb2_create(tree1, mem_ctx, &io1);
3676 CHECK_STATUS(status, NT_STATUS_OK);
3677 h1 = io1.out.file.handle;
3678 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3679 CHECK_LEASE(&io1, "RWH", true, LEASE1, 0);
3680
3681 status = smb2_util_write(tree1, h1, &c, 0, 1);
3682 CHECK_STATUS(status, NT_STATUS_OK);
3683
3684 /*
3685 * Try and get an exclusive byte
3686 * range lock on H1 (LEASE1).
3687 */
3688 lck.in.locks = &el;
3689 lck.in.lock_count = 1;
3690 lck.in.lock_sequence = 1;
3691 lck.in.file.handle = h1;
3692 el.offset = 0;
3693 el.length = 1;
3694 el.reserved = 0;
3695 el.flags = SMB2_LOCK_FLAG_EXCLUSIVE;
3696 status = smb2_lock(tree1, &lck);
3697 CHECK_STATUS(status, NT_STATUS_OK);
3698
3699 /* Open a second handle on tree2. */
3700 smb2_lease_create_share(&io2, &ls2, false, fname,
3701 smb2_util_share_access("RWD"),
3702 LEASE2,
3703 smb2_util_lease_state("RWH"));
3704 io2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
3705 status = smb2_create(tree2, mem_ctx, &io2);
3706 CHECK_STATUS(status, NT_STATUS_OK);
3707 h2 = io2.out.file.handle;
3708 CHECK_LEASE(&io2, "RH", true, LEASE2, 0);
3709 /* And LEASE1 got broken to NONE. */
3710 CHECK_BREAK_INFO("RWH", "", LEASE1);
3711 torture_reset_lease_break_info(tctx, &lease_break_info);
3712
3713 done:
3714 smb2_util_close(tree1, h1);
3715 smb2_util_close(tree2, h2);
3716
3717 smb2_util_unlink(tree1, fname);
3718 talloc_free(mem_ctx);
3719 return ret;
3720 }
3721
3722 /*
3723 * Verifies an existing RWH lease on a file is only broken to RW when a
3724 * contending create fails with STATUS_SHARING_VIOLATION.
3725 *
3726 * Client 1: open file with lease=RWH sharemode=none
3727 * Client 2: open file, expect STATUS_PENDING
3728 * Server: send lease break to RW to client 1
3729 * Client 2: expect open to fail with STATUS_SHARING_VIOLATION.
3730 */
3731 static bool test_lease_sharing_violation(struct torture_context *tctx,
3732 struct smb2_tree *tree1,
3733 struct smb2_tree *tree2)
3734 {
3735 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3736 struct smb2_create io1 = {};
3737 struct smb2_create io2 = {};
3738 struct smb2_lease ls1 = {};
3739 struct smb2_lease ls2 = {};
3740 struct smb2_handle h1 = {};
3741 struct smb2_handle h2 = {};
3742 const char *fname = __FUNCTION__;
3743 bool ret = true;
3744 NTSTATUS status;
3745 uint32_t caps;
3746
3747 caps = smb2cli_conn_server_capabilities(tree1->session->transport->conn);
3748 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3749
3750 /* Set up handlers. */
3751 tree1->session->transport->lease.handler = torture_lease_handler;
3752 tree1->session->transport->lease.private_data = tree1;
3753 tree2->session->transport->lease.handler = torture_lease_handler;
3754 tree2->session->transport->lease.private_data = tree2;
3755
3756 smb2_util_unlink(tree1, fname);
3757
3758 torture_reset_lease_break_info(tctx, &lease_break_info);
3759
3760 /* Open a handle on tree1. */
3761 smb2_lease_create_share(&io1, &ls1, false, fname,
3762 smb2_util_share_access(""),
3763 LEASE1,
3764 smb2_util_lease_state("RWH"));
3765 status = smb2_create(tree1, mem_ctx, &io1);
3766 CHECK_STATUS(status, NT_STATUS_OK);
3767 h1 = io1.out.file.handle;
3768 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3769 CHECK_LEASE(&io1, "RWH", true, LEASE1, 0);
3770
3771 /* Open a second handle on tree2. */
3772 smb2_lease_create_share(&io2, &ls2, false, fname,
3773 smb2_util_share_access("RWD"),
3774 LEASE2,
3775 smb2_util_lease_state("RWH"));
3776 io2.in.create_disposition = NTCREATEX_DISP_OVERWRITE;
3777 status = smb2_create(tree2, mem_ctx, &io2);
3778 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
3779 /* And LEASE1 got broken to RW. */
3780 CHECK_BREAK_INFO("RWH", "RW", LEASE1);
3781
3782 done:
3783 smb2_util_close(tree1, h1);
3784 smb2_util_close(tree2, h2);
3785
3786 smb2_util_unlink(tree1, fname);
3787 talloc_free(mem_ctx);
3788 return ret;
3789 }
3790
3791 static bool test_lease_complex1(struct torture_context *tctx,
3792 struct smb2_tree *tree1a)
3793 {
3794 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3795 struct smb2_create io1;
3796 struct smb2_create io2;
3797 struct smb2_lease ls1;
3798 struct smb2_lease ls2;
3799 struct smb2_handle h = {};
3800 struct smb2_handle h2 = {};
3801 struct smb2_handle h3 = {};
3802 struct smb2_write w;
3803 NTSTATUS status;
3804 const char *fname = "lease_complex1.dat";
3805 bool ret = true;
3806 uint32_t caps;
3807 struct smb2_tree *tree1b = NULL;
3808 struct smbcli_options options1;
3809
3810 options1 = tree1a->session->transport->options;
3811
3812 caps = smb2cli_conn_server_capabilities(tree1a->session->transport->conn);
3813 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3814
3815 tree1a->session->transport->lease.handler = torture_lease_handler;
3816 tree1a->session->transport->lease.private_data = tree1a;
3817 tree1a->session->transport->oplock.handler = torture_oplock_handler;
3818 tree1a->session->transport->oplock.private_data = tree1a;
3819
3820 /* create a new connection (same client_guid) */
3821 if (!torture_smb2_connection_ext(tctx, 0, &options1, &tree1b)) {
3822 torture_warning(tctx, "couldn't reconnect, bailing\n");
3823 ret = false;
3824 goto done;
3825 }
3826
3827 tree1b->session->transport->lease.handler = torture_lease_handler;
3828 tree1b->session->transport->lease.private_data = tree1b;
3829 tree1b->session->transport->oplock.handler = torture_oplock_handler;
3830 tree1b->session->transport->oplock.private_data = tree1b;
3831
3832 smb2_util_unlink(tree1a, fname);
3833
3834 torture_reset_lease_break_info(tctx, &lease_break_info);
3835
3836 /* Grab R lease over connection 1a */
3837 smb2_lease_create(&io1, &ls1, false, fname, LEASE1, smb2_util_lease_state("R"));
3838 status = smb2_create(tree1a, mem_ctx, &io1);
3839 CHECK_STATUS(status, NT_STATUS_OK);
3840 h = io1.out.file.handle;
3841 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3842 CHECK_LEASE(&io1, "R", true, LEASE1, 0);
3843
3844 /* Upgrade to RWH over connection 1b */
3845 ls1.lease_state = smb2_util_lease_state("RWH");
3846 status = smb2_create(tree1b, mem_ctx, &io1);
3847 CHECK_STATUS(status, NT_STATUS_OK);
3848 h2 = io1.out.file.handle;
3849 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3850 CHECK_LEASE(&io1, "RHW", true, LEASE1, 0);
3851
3852 /* close over connection 1b */
3853 status = smb2_util_close(tree1b, h2);
3854 CHECK_STATUS(status, NT_STATUS_OK);
3855
3856 /* Contend with LEASE2. */
3857 smb2_lease_create(&io2, &ls2, false, fname, LEASE2, smb2_util_lease_state("R"));
3858 status = smb2_create(tree1b, mem_ctx, &io2);
3859 CHECK_STATUS(status, NT_STATUS_OK);
3860 h3 = io2.out.file.handle;
3861 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3862 CHECK_LEASE(&io2, "R", true, LEASE2, 0);
3863
3864 /* Verify that we were only sent one break. */
3865 CHECK_BREAK_INFO("RHW", "RH", LEASE1);
3866
3867 /* again RH over connection 1b doesn't change the epoch */
3868 ls1.lease_state = smb2_util_lease_state("RH");
3869 status = smb2_create(tree1b, mem_ctx, &io1);
3870 CHECK_STATUS(status, NT_STATUS_OK);
3871 h2 = io1.out.file.handle;
3872 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3873 CHECK_LEASE(&io1, "RH", true, LEASE1, 0);
3874
3875 /* close over connection 1b */
3876 status = smb2_util_close(tree1b, h2);
3877 CHECK_STATUS(status, NT_STATUS_OK);
3878
3879 torture_reset_lease_break_info(tctx, &lease_break_info);
3880
3881 ZERO_STRUCT(w);
3882 w.in.file.handle = h;
3883 w.in.offset = 0;
3884 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
3885 memset(w.in.data.data, 'o', w.in.data.length);
3886 status = smb2_write(tree1a, &w);
3887 CHECK_STATUS(status, NT_STATUS_OK);
3888
3889 ls2.lease_epoch += 1;
3890 CHECK_BREAK_INFO("R", "", LEASE2);
3891
3892 torture_reset_lease_break_info(tctx, &lease_break_info);
3893
3894 ZERO_STRUCT(w);
3895 w.in.file.handle = h3;
3896 w.in.offset = 0;
3897 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
3898 memset(w.in.data.data, 'o', w.in.data.length);
3899 status = smb2_write(tree1b, &w);
3900 CHECK_STATUS(status, NT_STATUS_OK);
3901
3902 ls1.lease_epoch += 1;
3903 CHECK_BREAK_INFO("RH", "", LEASE1);
3904
3905 done:
3906 smb2_util_close(tree1a, h);
3907 smb2_util_close(tree1b, h2);
3908 smb2_util_close(tree1b, h3);
3909
3910 smb2_util_unlink(tree1a, fname);
3911
3912 talloc_free(mem_ctx);
3913
3914 return ret;
3915 }
3916
3917 static bool test_lease_v2_complex1(struct torture_context *tctx,
3918 struct smb2_tree *tree1a)
3919 {
3920 TALLOC_CTX *mem_ctx = talloc_new(tctx);
3921 struct smb2_create io1;
3922 struct smb2_create io2;
3923 struct smb2_lease ls1;
3924 struct smb2_lease ls2;
3925 struct smb2_handle h = {};
3926 struct smb2_handle h2 = {};
3927 struct smb2_handle h3 = {};
3928 struct smb2_write w;
3929 NTSTATUS status;
3930 const char *fname = "lease_v2_complex1.dat";
3931 bool ret = true;
3932 uint32_t caps;
3933 enum protocol_types protocol;
3934 struct smb2_tree *tree1b = NULL;
3935 struct smbcli_options options1;
3936
3937 options1 = tree1a->session->transport->options;
3938
3939 caps = smb2cli_conn_server_capabilities(tree1a->session->transport->conn);
3940 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
3941
3942 protocol = smbXcli_conn_protocol(tree1a->session->transport->conn);
3943 if (protocol < PROTOCOL_SMB3_00) {
3944 torture_skip(tctx, "v2 leases are not supported");
3945 }
3946
3947 tree1a->session->transport->lease.handler = torture_lease_handler;
3948 tree1a->session->transport->lease.private_data = tree1a;
3949 tree1a->session->transport->oplock.handler = torture_oplock_handler;
3950 tree1a->session->transport->oplock.private_data = tree1a;
3951
3952 /* create a new connection (same client_guid) */
3953 if (!torture_smb2_connection_ext(tctx, 0, &options1, &tree1b)) {
3954 torture_warning(tctx, "couldn't reconnect, bailing\n");
3955 ret = false;
3956 goto done;
3957 }
3958
3959 tree1b->session->transport->lease.handler = torture_lease_handler;
3960 tree1b->session->transport->lease.private_data = tree1b;
3961 tree1b->session->transport->oplock.handler = torture_oplock_handler;
3962 tree1b->session->transport->oplock.private_data = tree1b;
3963
3964 smb2_util_unlink(tree1a, fname);
3965
3966 torture_reset_lease_break_info(tctx, &lease_break_info);
3967
3968 /* Grab R lease over connection 1a */
3969 smb2_lease_v2_create(&io1, &ls1, false, fname, LEASE1, NULL,
3970 smb2_util_lease_state("R"), 0x4711);
3971 status = smb2_create(tree1a, mem_ctx, &io1);
3972 CHECK_STATUS(status, NT_STATUS_OK);
3973 h = io1.out.file.handle;
3974 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
3975 ls1.lease_epoch += 1;
3976 CHECK_LEASE_V2(&io1, "R", true, LEASE1,
3977 0, 0, ls1.lease_epoch);
3978
3979 /* Upgrade to RWH over connection 1b */
3980 ls1.lease_state = smb2_util_lease_state("RWH");
3981 status = smb2_create(tree1b, mem_ctx, &io1);
3982 CHECK_STATUS(status, NT_STATUS_OK);
3983 h2 = io1.out.file.handle;
3984 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
3985 ls1.lease_epoch += 1;
3986 CHECK_LEASE_V2(&io1, "RHW", true, LEASE1,
3987 0, 0, ls1.lease_epoch);
3988
3989 /* close over connection 1b */
3990 status = smb2_util_close(tree1b, h2);
3991 CHECK_STATUS(status, NT_STATUS_OK);
3992
3993 /* Contend with LEASE2. */
3994 smb2_lease_v2_create(&io2, &ls2, false, fname, LEASE2, NULL,
3995 smb2_util_lease_state("R"), 0x11);
3996 status = smb2_create(tree1b, mem_ctx, &io2);
3997 CHECK_STATUS(status, NT_STATUS_OK);
3998 h3 = io2.out.file.handle;
3999 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4000 ls2.lease_epoch += 1;
4001 CHECK_LEASE_V2(&io2, "R", true, LEASE2,
4002 0, 0, ls2.lease_epoch);
4003
4004 /* Verify that we were only sent one break. */
4005 ls1.lease_epoch += 1;
4006 CHECK_BREAK_INFO_V2(tree1a->session->transport,
4007 "RHW", "RH", LEASE1, ls1.lease_epoch);
4008
4009 /* again RH over connection 1b doesn't change the epoch */
4010 ls1.lease_state = smb2_util_lease_state("RH");
4011 status = smb2_create(tree1b, mem_ctx, &io1);
4012 CHECK_STATUS(status, NT_STATUS_OK);
4013 h2 = io1.out.file.handle;
4014 CHECK_CREATED(&io1, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4015 CHECK_LEASE_V2(&io1, "RH", true, LEASE1,
4016 0, 0, ls1.lease_epoch);
4017
4018 /* close over connection 1b */
4019 status = smb2_util_close(tree1b, h2);
4020 CHECK_STATUS(status, NT_STATUS_OK);
4021
4022 torture_reset_lease_break_info(tctx, &lease_break_info);
4023
4024 ZERO_STRUCT(w);
4025 w.in.file.handle = h;
4026 w.in.offset = 0;
4027 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
4028 memset(w.in.data.data, 'o', w.in.data.length);
4029 status = smb2_write(tree1a, &w);
4030 CHECK_STATUS(status, NT_STATUS_OK);
4031
4032 ls2.lease_epoch += 1;
4033 CHECK_BREAK_INFO_V2(tree1a->session->transport,
4034 "R", "", LEASE2, ls2.lease_epoch);
4035
4036 torture_reset_lease_break_info(tctx, &lease_break_info);
4037
4038 ZERO_STRUCT(w);
4039 w.in.file.handle = h3;
4040 w.in.offset = 0;
4041 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
4042 memset(w.in.data.data, 'o', w.in.data.length);
4043 status = smb2_write(tree1b, &w);
4044 CHECK_STATUS(status, NT_STATUS_OK);
4045
4046 ls1.lease_epoch += 1;
4047 CHECK_BREAK_INFO_V2(tree1a->session->transport,
4048 "RH", "", LEASE1, ls1.lease_epoch);
4049
4050 done:
4051 smb2_util_close(tree1a, h);
4052 smb2_util_close(tree1b, h2);
4053 smb2_util_close(tree1b, h3);
4054
4055 smb2_util_unlink(tree1a, fname);
4056
4057 talloc_free(mem_ctx);
4058
4059 return ret;
4060 }
4061
4062 static bool test_lease_v2_complex2(struct torture_context *tctx,
4063 struct smb2_tree *tree1a)
4064 {
4065 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4066 struct smb2_create io1;
4067 struct smb2_create io2;
4068 struct smb2_lease ls1;
4069 struct smb2_lease ls2;
4070 struct smb2_handle h = {};
4071 struct smb2_handle h2 = {};
4072 struct smb2_request *req2 = NULL;
4073 struct smb2_lease_break_ack ack = {};
4074 NTSTATUS status;
4075 const char *fname = "lease_v2_complex2.dat";
4076 bool ret = true;
4077 uint32_t caps;
4078 enum protocol_types protocol;
4079 struct smb2_tree *tree1b = NULL;
4080 struct smbcli_options options1;
4081
4082 options1 = tree1a->session->transport->options;
4083
4084 caps = smb2cli_conn_server_capabilities(tree1a->session->transport->conn);
4085 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
4086
4087 protocol = smbXcli_conn_protocol(tree1a->session->transport->conn);
4088 if (protocol < PROTOCOL_SMB3_00) {
4089 torture_skip(tctx, "v2 leases are not supported");
4090 }
4091
4092 tree1a->session->transport->lease.handler = torture_lease_handler;
4093 tree1a->session->transport->lease.private_data = tree1a;
4094 tree1a->session->transport->oplock.handler = torture_oplock_handler;
4095 tree1a->session->transport->oplock.private_data = tree1a;
4096
4097 /* create a new connection (same client_guid) */
4098 if (!torture_smb2_connection_ext(tctx, 0, &options1, &tree1b)) {
4099 torture_warning(tctx, "couldn't reconnect, bailing\n");
4100 ret = false;
4101 goto done;
4102 }
4103
4104 tree1b->session->transport->lease.handler = torture_lease_handler;
4105 tree1b->session->transport->lease.private_data = tree1b;
4106 tree1b->session->transport->oplock.handler = torture_oplock_handler;
4107 tree1b->session->transport->oplock.private_data = tree1b;
4108
4109 smb2_util_unlink(tree1a, fname);
4110
4111 torture_reset_lease_break_info(tctx, &lease_break_info);
4112
4113 /* Grab RWH lease over connection 1a */
4114 smb2_lease_v2_create(&io1, &ls1, false, fname, LEASE1, NULL,
4115 smb2_util_lease_state("RWH"), 0x4711);
4116 status = smb2_create(tree1a, mem_ctx, &io1);
4117 CHECK_STATUS(status, NT_STATUS_OK);
4118 h = io1.out.file.handle;
4119 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4120 ls1.lease_epoch += 1;
4121 CHECK_LEASE_V2(&io1, "RWH", true, LEASE1,
4122 0, 0, ls1.lease_epoch);
4123
4124 /*
4125 * we defer acking the lease break.
4126 */
4127 torture_reset_lease_break_info(tctx, &lease_break_info);
4128 lease_break_info.lease_skip_ack = true;
4129
4130 /* Ask for RWH on connection 1b, different lease. */
4131 smb2_lease_v2_create(&io2, &ls2, false, fname, LEASE2, NULL,
4132 smb2_util_lease_state("RWH"), 0x11);
4133 req2 = smb2_create_send(tree1b, &io2);
4134 torture_assert(tctx, req2 != NULL, "smb2_create_send");
4135
4136 ls1.lease_epoch += 1;
4137
4138 CHECK_BREAK_INFO_V2(tree1a->session->transport,
4139 "RWH", "RH", LEASE1, ls1.lease_epoch);
4140
4141 /* Send the break ACK on tree1b. */
4142 ack.in.lease.lease_key =
4143 lease_break_info.lease_break.current_lease.lease_key;
4144 ack.in.lease.lease_state = SMB2_LEASE_HANDLE|SMB2_LEASE_READ;
4145
4146 status = smb2_lease_break_ack(tree1b, &ack);
4147 CHECK_STATUS(status, NT_STATUS_OK);
4148 CHECK_LEASE_BREAK_ACK(&ack, "RH", LEASE1);
4149
4150 torture_reset_lease_break_info(tctx, &lease_break_info);
4151
4152 status = smb2_create_recv(req2, tctx, &io2);
4153 CHECK_STATUS(status, NT_STATUS_OK);
4154 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4155 CHECK_LEASE_V2(&io2, "RH", true, LEASE2,
4156 0, 0, ls2.lease_epoch+1);
4157 h2 = io2.out.file.handle;
4158
4159 done:
4160 smb2_util_close(tree1a, h);
4161 smb2_util_close(tree1b, h2);
4162
4163 smb2_util_unlink(tree1a, fname);
4164
4165 talloc_free(mem_ctx);
4166
4167 return ret;
4168 }
4169
4170
4171 static bool test_lease_timeout(struct torture_context *tctx,
4172 struct smb2_tree *tree)
4173 {
4174 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4175 struct smb2_create io;
4176 struct smb2_lease ls1;
4177 struct smb2_lease ls2;
4178 struct smb2_handle h = {};
4179 struct smb2_handle hnew = {};
4180 struct smb2_handle h1b = {};
4181 NTSTATUS status;
4182 const char *fname = "lease_timeout.dat";
4183 bool ret = true;
4184 struct smb2_lease_break_ack ack = {};
4185 struct smb2_request *req2 = NULL;
4186 struct smb2_write w;
4187 uint32_t caps;
4188
4189 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
4190 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
4191
4192 smb2_util_unlink(tree, fname);
4193
4194 /* Grab a RWH lease. */
4195 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("RWH"));
4196 status = smb2_create(tree, mem_ctx, &io);
4197 CHECK_STATUS(status, NT_STATUS_OK);
4198 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4199 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
4200 h = io.out.file.handle;
4201
4202 tree->session->transport->lease.handler = torture_lease_handler;
4203 tree->session->transport->lease.private_data = tree;
4204 tree->session->transport->oplock.handler = torture_oplock_handler;
4205 tree->session->transport->oplock.private_data = tree;
4206
4207 /*
4208 * Just don't ack the lease break.
4209 */
4210 torture_reset_lease_break_info(tctx, &lease_break_info);
4211 lease_break_info.lease_skip_ack = true;
4212
4213 /* Break with a RWH request. */
4214 smb2_lease_create(&io, &ls2, false, fname, LEASE2, smb2_util_lease_state("RWH"));
4215 req2 = smb2_create_send(tree, &io);
4216 torture_assert(tctx, req2 != NULL, "smb2_create_send");
4217 torture_assert(tctx, req2->state == SMB2_REQUEST_RECV, "req2 pending");
4218
4219 CHECK_BREAK_INFO("RWH", "RH", LEASE1);
4220
4221 /* Copy the break request. */
4222 ack.in.lease.lease_key =
4223 lease_break_info.lease_break.current_lease.lease_key;
4224 ack.in.lease.lease_state =
4225 lease_break_info.lease_break.new_lease_state;
4226
4227 /* Now wait for the timeout and get the reply. */
4228 status = smb2_create_recv(req2, tctx, &io);
4229 CHECK_STATUS(status, NT_STATUS_OK);
4230 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4231 CHECK_LEASE(&io, "RH", true, LEASE2, 0);
4232 hnew = io.out.file.handle;
4233
4234 /* Ack the break after the timeout... */
4235 status = smb2_lease_break_ack(tree, &ack);
4236 CHECK_STATUS(status, NT_STATUS_UNSUCCESSFUL);
4237
4238 /* Get state of the original handle. */
4239 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state(""));
4240 status = smb2_create(tree, mem_ctx, &io);
4241 CHECK_STATUS(status, NT_STATUS_OK);
4242 CHECK_LEASE(&io, "", true, LEASE1, 0);
4243 smb2_util_close(tree, io.out.file.handle);
4244
4245 /* Write on the original handle and make sure it's still valid. */
4246 torture_reset_lease_break_info(tctx, &lease_break_info);
4247 ZERO_STRUCT(w);
4248 w.in.file.handle = h;
4249 w.in.offset = 0;
4250 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
4251 memset(w.in.data.data, '1', w.in.data.length);
4252 status = smb2_write(tree, &w);
4253 CHECK_STATUS(status, NT_STATUS_OK);
4254
4255 /* Causes new handle to break to NONE. */
4256 CHECK_BREAK_INFO("RH", "", LEASE2);
4257
4258 /* Write on the new handle. */
4259 torture_reset_lease_break_info(tctx, &lease_break_info);
4260 ZERO_STRUCT(w);
4261 w.in.file.handle = hnew;
4262 w.in.offset = 0;
4263 w.in.data = data_blob_talloc(mem_ctx, NULL, 1024);
4264 memset(w.in.data.data, '2', w.in.data.length);
4265 status = smb2_write(tree, &w);
4266 CHECK_STATUS(status, NT_STATUS_OK);
4267 /* No break - original handle was already NONE. */
4268 CHECK_NO_BREAK(tctx);
4269 smb2_util_close(tree, hnew);
4270
4271 /* Upgrade to R on LEASE1. */
4272 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("R"));
4273 status = smb2_create(tree, mem_ctx, &io);
4274 CHECK_STATUS(status, NT_STATUS_OK);
4275 CHECK_LEASE(&io, "R", true, LEASE1, 0);
4276 h1b = io.out.file.handle;
4277 smb2_util_close(tree, h1b);
4278
4279 /* Upgrade to RWH on LEASE1. */
4280 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("RWH"));
4281 status = smb2_create(tree, mem_ctx, &io);
4282 CHECK_STATUS(status, NT_STATUS_OK);
4283 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
4284 h1b = io.out.file.handle;
4285 smb2_util_close(tree, h1b);
4286
4287 done:
4288 smb2_util_close(tree, h);
4289 smb2_util_close(tree, hnew);
4290 smb2_util_close(tree, h1b);
4291
4292 smb2_util_unlink(tree, fname);
4293
4294 talloc_free(mem_ctx);
4295
4296 return ret;
4297 }
4298
4299 static bool test_lease_rename_wait(struct torture_context *tctx,
4300 struct smb2_tree *tree)
4301 {
4302 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4303 struct smb2_create io;
4304 struct smb2_lease ls1;
4305 struct smb2_lease ls2;
4306 struct smb2_lease ls3;
4307 struct smb2_handle h1 = {};
4308 struct smb2_handle h2 = {};
4309 struct smb2_handle h3 = {};
4310 union smb_setfileinfo sinfo;
4311 NTSTATUS status;
4312 const char *fname_src = "lease_rename_src.dat";
4313 const char *fname_dst = "lease_rename_dst.dat";
4314 bool ret = true;
4315 struct smb2_lease_break_ack ack = {};
4316 struct smb2_request *rename_req = NULL;
4317 uint32_t caps;
4318 unsigned int i;
4319
4320 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
4321 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
4322
4323 smb2_util_unlink(tree, fname_src);
4324 smb2_util_unlink(tree, fname_dst);
4325
4326 /* Short timeout for fails. */
4327 tree->session->transport->options.request_timeout = 15;
4328
4329 /* Grab a RH lease. */
4330 smb2_lease_create(&io,
4331 &ls1,
4332 false,
4333 fname_src,
4334 LEASE1,
4335 smb2_util_lease_state("RH"));
4336 status = smb2_create(tree, mem_ctx, &io);
4337 CHECK_STATUS(status, NT_STATUS_OK);
4338 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4339 CHECK_LEASE(&io, "RH", true, LEASE1, 0);
4340 h1 = io.out.file.handle;
4341
4342 /* Second open with a RH lease. */
4343 smb2_lease_create(&io,
4344 &ls2,
4345 false,
4346 fname_src,
4347 LEASE2,
4348 smb2_util_lease_state("RH"));
4349 io.in.create_disposition = NTCREATEX_DISP_OPEN;
4350 io.in.desired_access = GENERIC_READ_ACCESS;
4351 status = smb2_create(tree, mem_ctx, &io);
4352 CHECK_STATUS(status, NT_STATUS_OK);
4353 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4354 CHECK_LEASE(&io, "RH", true, LEASE2, 0);
4355 h2 = io.out.file.handle;
4356
4357 /*
4358 * Don't ack a lease break.
4359 */
4360 tree->session->transport->lease.handler = torture_lease_handler;
4361 tree->session->transport->lease.private_data = tree;
4362 torture_reset_lease_break_info(tctx, &lease_break_info);
4363 lease_break_info.lease_skip_ack = true;
4364
4365 /* Break with a rename. */
4366 ZERO_STRUCT(sinfo);
4367 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
4368 sinfo.rename_information.in.file.handle = h1;
4369 sinfo.rename_information.in.overwrite = true;
4370 sinfo.rename_information.in.new_name = fname_dst;
4371 rename_req = smb2_setinfo_file_send(tree, &sinfo);
4372
4373 torture_assert(tctx,
4374 rename_req != NULL,
4375 "smb2_setinfo_file_send");
4376 torture_assert(tctx,
4377 rename_req->state == SMB2_REQUEST_RECV,
4378 "rename pending");
4379
4380 /* Try and open the destination with a RH lease. */
4381 smb2_lease_create(&io,
4382 &ls3,
4383 false,
4384 fname_dst,
4385 LEASE3,
4386 smb2_util_lease_state("RH"));
4387 /* We want to open, not create. */
4388 io.in.create_disposition = NTCREATEX_DISP_OPEN;
4389 io.in.desired_access = GENERIC_READ_ACCESS;
4390 status = smb2_create(tree, mem_ctx, &io);
4391 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
4392
4393 /*
4394 * The smb2_create() I/O should have picked up the break request
4395 * caused by the pending rename.
4396 */
4397
4398 /* Copy the break request. */
4399 ack.in.lease.lease_key =
4400 lease_break_info.lease_break.current_lease.lease_key;
4401 ack.in.lease.lease_state =
4402 lease_break_info.lease_break.new_lease_state;
4403
4404 /*
4405 * Give the server 3 more chances to have renamed
4406 * the file. Better than doing a sleep.
4407 */
4408 for (i = 0; i < 3; i++) {
4409 status = smb2_create(tree, mem_ctx, &io);
4410 CHECK_STATUS(status, NT_STATUS_OBJECT_NAME_NOT_FOUND);
4411 }
4412
4413 /* Ack the break. The server is now free to rename. */
4414 status = smb2_lease_break_ack(tree, &ack);
4415 CHECK_STATUS(status, NT_STATUS_OK);
4416
4417 /* Get the rename reply. */
4418 status = smb2_setinfo_recv(rename_req);
4419 CHECK_STATUS(status, NT_STATUS_OK);
4420
4421 /* The target should now exist. */
4422 status = smb2_create(tree, mem_ctx, &io);
4423 CHECK_STATUS(status, NT_STATUS_OK);
4424 h3 = io.out.file.handle;
4425
4426 done:
4427 smb2_util_close(tree, h1);
4428 smb2_util_close(tree, h2);
4429 smb2_util_close(tree, h3);
4430
4431 smb2_util_unlink(tree, fname_src);
4432 smb2_util_unlink(tree, fname_dst);
4433
4434 talloc_free(mem_ctx);
4435
4436 return ret;
4437 }
4438
4439 static bool test_lease_v2_rename(struct torture_context *tctx,
4440 struct smb2_tree *tree)
4441 {
4442 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4443 struct smb2_create io;
4444 struct smb2_lease ls1;
4445 struct smb2_lease ls2;
4446 struct smb2_handle h = {};
4447 struct smb2_handle h1 = {};
4448 struct smb2_handle h2 = {};
4449 union smb_setfileinfo sinfo;
4450 const char *fname = "lease_v2_rename_src.dat";
4451 const char *fname_dst = "lease_v2_rename_dst.dat";
4452 bool ret = true;
4453 NTSTATUS status;
4454 uint32_t caps;
4455 enum protocol_types protocol;
4456
4457 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
4458 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
4459
4460 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
4461 if (protocol < PROTOCOL_SMB3_00) {
4462 torture_skip(tctx, "v2 leases are not supported");
4463 }
4464
4465 smb2_util_unlink(tree, fname);
4466 smb2_util_unlink(tree, fname_dst);
4467
4468 tree->session->transport->lease.handler = torture_lease_handler;
4469 tree->session->transport->lease.private_data = tree;
4470 tree->session->transport->oplock.handler = torture_oplock_handler;
4471 tree->session->transport->oplock.private_data = tree;
4472
4473 torture_reset_lease_break_info(tctx, &lease_break_info);
4474
4475 ZERO_STRUCT(io);
4476 smb2_lease_v2_create_share(&io, &ls1, false, fname,
4477 smb2_util_share_access("RWD"),
4478 LEASE1, NULL,
4479 smb2_util_lease_state("RHW"),
4480 0x4711);
4481 status = smb2_create(tree, mem_ctx, &io);
4482 CHECK_STATUS(status, NT_STATUS_OK);
4483 h = io.out.file.handle;
4484 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4485 ls1.lease_epoch += 1;
4486 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0, ls1.lease_epoch);
4487
4488 /* Now rename - what happens ? */
4489 ZERO_STRUCT(sinfo);
4490 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
4491 sinfo.rename_information.in.file.handle = h;
4492 sinfo.rename_information.in.overwrite = true;
4493 sinfo.rename_information.in.new_name = fname_dst;
4494 status = smb2_setinfo_file(tree, &sinfo);
4495 CHECK_STATUS(status, NT_STATUS_OK);
4496
4497 /* No lease break. */
4498 CHECK_NO_BREAK(tctx);
4499
4500 /* Check we can open another handle on the new name. */
4501 smb2_lease_v2_create_share(&io, &ls1, false, fname_dst,
4502 smb2_util_share_access("RWD"),
4503 LEASE1, NULL,
4504 smb2_util_lease_state(""),
4505 ls1.lease_epoch);
4506 status = smb2_create(tree, mem_ctx, &io);
4507 CHECK_STATUS(status, NT_STATUS_OK);
4508 h1 = io.out.file.handle;
4509 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4510 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0, ls1.lease_epoch);
4511 smb2_util_close(tree, h1);
4512
4513 /* Try another lease key. */
4514 smb2_lease_v2_create_share(&io, &ls2, false, fname_dst,
4515 smb2_util_share_access("RWD"),
4516 LEASE2, NULL,
4517 smb2_util_lease_state("RWH"),
4518 0x44);
4519 status = smb2_create(tree, mem_ctx, &io);
4520 CHECK_STATUS(status, NT_STATUS_OK);
4521 h2 = io.out.file.handle;
4522 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4523 ls2.lease_epoch += 1;
4524 CHECK_LEASE_V2(&io, "RH", true, LEASE2, 0, 0, ls2.lease_epoch );
4525 CHECK_BREAK_INFO_V2(tree->session->transport,
4526 "RWH", "RH", LEASE1, ls1.lease_epoch + 1);
4527 ls1.lease_epoch += 1;
4528 torture_reset_lease_break_info(tctx, &lease_break_info);
4529
4530 /* Now rename back. */
4531 ZERO_STRUCT(sinfo);
4532 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
4533 sinfo.rename_information.in.file.handle = h;
4534 sinfo.rename_information.in.overwrite = true;
4535 sinfo.rename_information.in.new_name = fname;
4536 status = smb2_setinfo_file(tree, &sinfo);
4537 CHECK_STATUS(status, NT_STATUS_OK);
4538
4539 /* Breaks to R on LEASE2. */
4540 CHECK_BREAK_INFO_V2(tree->session->transport,
4541 "RH", "R", LEASE2, ls2.lease_epoch + 1);
4542 ls2.lease_epoch += 1;
4543
4544 /* Check we can open another handle on the current name. */
4545 smb2_lease_v2_create_share(&io, &ls1, false, fname,
4546 smb2_util_share_access("RWD"),
4547 LEASE1, NULL,
4548 smb2_util_lease_state(""),
4549 ls1.lease_epoch);
4550 status = smb2_create(tree, mem_ctx, &io);
4551 CHECK_STATUS(status, NT_STATUS_OK);
4552 h1 = io.out.file.handle;
4553 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4554 CHECK_LEASE_V2(&io, "RH", true, LEASE1, 0, 0, ls1.lease_epoch);
4555 smb2_util_close(tree, h1);
4556
4557 done:
4558
4559 smb2_util_close(tree, h);
4560 smb2_util_close(tree, h1);
4561 smb2_util_close(tree, h2);
4562
4563 smb2_util_unlink(tree, fname);
4564 smb2_util_unlink(tree, fname_dst);
4565
4566 smb2_util_unlink(tree, fname);
4567 talloc_free(mem_ctx);
4568 return ret;
4569 }
4570
4571 /*
4572 * Try doing a rename overwrite where the target file is open
4573 * with a RWH lease.
4574 */
4575
4576 static bool test_lease_v2_rename_target_overwrite(struct torture_context *tctx,
4577 struct smb2_tree *tree)
4578 {
4579 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4580 struct smb2_create io;
4581 struct smb2_create io_dst;
4582 struct smb2_lease ls1;
4583 struct smb2_lease ls_dst;
4584 struct smb2_handle h = {};
4585 struct smb2_handle h_dst = {};
4586 union smb_setfileinfo sinfo;
4587 const char *fname = "lease_v2_rename_overwrite_src.dat";
4588 const char *fname_dst = "lease_v2_rename_overwrite_dst.dat";
4589 bool ret = true;
4590 NTSTATUS status;
4591 uint32_t caps;
4592 enum protocol_types protocol;
4593 struct smb2_request *rename_req = NULL;
4594
4595 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
4596 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
4597
4598 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
4599 if (protocol < PROTOCOL_SMB3_00) {
4600 torture_skip(tctx, "v2 leases are not supported");
4601 }
4602
4603 smb2_util_unlink(tree, fname);
4604 smb2_util_unlink(tree, fname_dst);
4605
4606 tree->session->transport->lease.handler = torture_lease_handler;
4607 tree->session->transport->lease.private_data = tree;
4608 tree->session->transport->oplock.handler = torture_oplock_handler;
4609 tree->session->transport->oplock.private_data = tree;
4610
4611 torture_reset_lease_break_info(tctx, &lease_break_info);
4612
4613 ZERO_STRUCT(io);
4614 smb2_lease_v2_create_share(&io, &ls1, false, fname,
4615 smb2_util_share_access("RWD"),
4616 LEASE1, NULL,
4617 smb2_util_lease_state("RHW"),
4618 0x4711);
4619 status = smb2_create(tree, mem_ctx, &io);
4620 CHECK_STATUS(status, NT_STATUS_OK);
4621 h = io.out.file.handle;
4622 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4623 ls1.lease_epoch += 1;
4624 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0, ls1.lease_epoch);
4625
4626 /* Create the target file with a lease and leave open. */
4627 ZERO_STRUCT(io_dst);
4628 smb2_lease_v2_create_share(&io_dst, &ls_dst, false, fname_dst,
4629 smb2_util_share_access("RWD"),
4630 LEASE2, NULL,
4631 smb2_util_lease_state("RHW"),
4632 0x4711);
4633 status = smb2_create(tree, mem_ctx, &io_dst);
4634 CHECK_STATUS(status, NT_STATUS_OK);
4635 h_dst = io_dst.out.file.handle;
4636 CHECK_CREATED(&io_dst, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4637 ls_dst.lease_epoch += 1;
4638 CHECK_LEASE_V2(&io_dst, "RHW", true, LEASE2, 0, 0, ls_dst.lease_epoch);
4639
4640 /*
4641 * Now rename - should break the target lease then return
4642 * ACCESS_DENIED.
4643 * */
4644 ZERO_STRUCT(sinfo);
4645 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
4646 sinfo.rename_information.in.file.handle = h;
4647 sinfo.rename_information.in.overwrite = true;
4648 sinfo.rename_information.in.new_name = fname_dst;
4649 status = smb2_setinfo_file(tree, &sinfo);
4650 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
4651
4652 CHECK_BREAK_INFO_V2(tree->session->transport,
4653 "RWH", "RW", LEASE2, ls_dst.lease_epoch + 1);
4654
4655 torture_reset_lease_break_info(tctx, &lease_break_info);
4656 lease_break_info.lease_skip_ack = true;
4657
4658 /*
4659 * Do the rename again, this time there's no h-lease on the dst anymore,
4660 * so we should get no break and the rename should still fail.
4661 */
4662
4663 torture_reset_lease_break_info(tctx, &lease_break_info);
4664
4665 status = smb2_setinfo_file(tree, &sinfo);
4666 CHECK_STATUS(status, NT_STATUS_ACCESS_DENIED);
4667
4668 CHECK_NO_BREAK(tctx);
4669
4670 /*
4671 * Do the rename again, but this time close the handle on the
4672 * destination when receiving the h-lease break.
4673 */
4674
4675 torture_reset_lease_break_info(tctx, &lease_break_info);
4676 lease_break_info.lease_skip_ack = true;
4677
4678 status = smb2_util_close(tree, h_dst);
4679 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
4680 "smb2_util_close failed\n");
4681 ZERO_STRUCT(h_dst);
4682
4683 status = smb2_create(tree, mem_ctx, &io_dst);
4684 CHECK_STATUS(status, NT_STATUS_OK);
4685 h_dst = io_dst.out.file.handle;
4686 ls_dst.lease_epoch += 1;
4687
4688 ZERO_STRUCT(sinfo);
4689 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
4690 sinfo.rename_information.in.file.handle = h;
4691 sinfo.rename_information.in.overwrite = true;
4692 sinfo.rename_information.in.new_name = fname_dst;
4693 rename_req = smb2_setinfo_file_send(tree, &sinfo);
4694
4695 torture_assert(tctx,
4696 rename_req != NULL,
4697 "smb2_setinfo_file_send");
4698 torture_assert(tctx,
4699 rename_req->state == SMB2_REQUEST_RECV,
4700 "rename pending");
4701
4702 CHECK_BREAK_INFO_V2(tree->session->transport,
4703 "RWH", "RW", LEASE2, ls_dst.lease_epoch + 1);
4704
4705 status = smb2_util_close(tree, h_dst);
4706 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
4707 "smb2_util_close failed\n");
4708 ZERO_STRUCT(h_dst);
4709
4710 /* Get the rename reply. */
4711 status = smb2_setinfo_recv(rename_req);
4712 CHECK_STATUS(status, NT_STATUS_OK);
4713
4714 done:
4715
4716 smb2_util_close(tree, h);
4717 smb2_util_close(tree, h_dst);
4718
4719 smb2_util_unlink(tree, fname);
4720 smb2_util_unlink(tree, fname_dst);
4721
4722 talloc_free(mem_ctx);
4723 return ret;
4724 }
4725
4726 static bool test_lease_dynamic_share(struct torture_context *tctx,
4727 struct smb2_tree *tree1a)
4728 {
4729 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4730 struct smb2_create io;
4731 struct smb2_lease ls1;
4732 struct smb2_handle h = {}, h1 = {}, h2 = {};
4733 struct smb2_write w = {};
4734 NTSTATUS status;
4735 const char *fname = "dynamic_path.dat";
4736 bool ret = true;
4737 uint32_t caps;
4738 struct smb2_tree *tree_2 = NULL;
4739 struct smb2_tree *tree_3 = NULL;
4740 struct smbcli_options options;
4741 const char *orig_share = NULL;
4742
4743 if (!TARGET_IS_SAMBA3(tctx)) {
4744 torture_skip(tctx, "dynamic shares are not supported");
4745 return true;
4746 }
4747
4748 options = tree1a->session->transport->options;
4749 options.client_guid = GUID_random();
4750
4751 caps = smb2cli_conn_server_capabilities(tree1a->session->transport->conn);
4752 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
4753
4754 /*
4755 * Save off original share name and change it to dynamic_share.
4756 * This must have been pre-created with a dynamic path containing
4757 * %t. It means we'll sleep between the connects in order to
4758 * get a different timestamp for the share path.
4759 */
4760
4761 orig_share = lpcfg_parm_string(tctx->lp_ctx, NULL, "torture", "share");
4762 orig_share = talloc_strdup(tctx->lp_ctx, orig_share);
4763 if (orig_share == NULL) {
4764 torture_result(tctx, TORTURE_FAIL, __location__ "no memory\n");
4765 ret = false;
4766 goto done;
4767 }
4768 lpcfg_set_cmdline(tctx->lp_ctx, "torture:share", "dynamic_share");
4769
4770 /* create a new connection (same client_guid) */
4771 sleep(2);
4772 if (!torture_smb2_connection_ext(tctx, 0, &options, &tree_2)) {
4773 torture_result(tctx, TORTURE_FAIL,
4774 __location__ "couldn't reconnect "
4775 "max protocol 2.1, bailing\n");
4776 ret = false;
4777 goto done;
4778 }
4779
4780 tree_2->session->transport->lease.handler = torture_lease_handler;
4781 tree_2->session->transport->lease.private_data = tree_2;
4782 tree_2->session->transport->oplock.handler = torture_oplock_handler;
4783 tree_2->session->transport->oplock.private_data = tree_2;
4784
4785 smb2_util_unlink(tree_2, fname);
4786
4787 /* create a new connection (same client_guid) */
4788 sleep(2);
4789 if (!torture_smb2_connection_ext(tctx, 0, &options, &tree_3)) {
4790 torture_result(tctx, TORTURE_FAIL,
4791 __location__ "couldn't reconnect "
4792 "max protocol 3.0, bailing\n");
4793 ret = false;
4794 goto done;
4795 }
4796
4797 tree_3->session->transport->lease.handler = torture_lease_handler;
4798 tree_3->session->transport->lease.private_data = tree_3;
4799 tree_3->session->transport->oplock.handler = torture_oplock_handler;
4800 tree_3->session->transport->oplock.private_data = tree_3;
4801
4802 smb2_util_unlink(tree_3, fname);
4803
4804 torture_reset_lease_break_info(tctx, &lease_break_info);
4805
4806 /* Get RWH lease over connection 2 */
4807 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("RWH"));
4808 status = smb2_create(tree_2, mem_ctx, &io);
4809 CHECK_STATUS(status, NT_STATUS_OK);
4810 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4811 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
4812 h = io.out.file.handle;
4813
4814 /* Write some data into it. */
4815 w.in.file.handle = h;
4816 w.in.offset = 0;
4817 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
4818 memset(w.in.data.data, '1', w.in.data.length);
4819 status = smb2_write(tree_2, &w);
4820 CHECK_STATUS(status, NT_STATUS_OK);
4821
4822 /* Open the same name over connection 3. */
4823 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("RWH"));
4824 status = smb2_create(tree_3, mem_ctx, &io);
4825 CHECK_STATUS(status, NT_STATUS_OK);
4826 h1 = io.out.file.handle;
4827 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4828
4829 /* h1 should have replied with NONE. */
4830 CHECK_LEASE(&io, "", true, LEASE1, 0);
4831
4832 /* We should have broken h to NONE. */
4833 CHECK_BREAK_INFO("RWH", "", LEASE1);
4834
4835 /* Try to upgrade to RWH over connection 2 */
4836 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("RWH"));
4837 status = smb2_create(tree_2, mem_ctx, &io);
4838 CHECK_STATUS(status, NT_STATUS_OK);
4839 h2 = io.out.file.handle;
4840 CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_EXISTED);
4841 CHECK_VAL(io.out.size, 4096);
4842 CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
4843 /* Should have been denied. */
4844 CHECK_LEASE(&io, "", true, LEASE1, 0);
4845 smb2_util_close(tree_2, h2);
4846
4847 /* Try to upgrade to RWH over connection 3 */
4848 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("RWH"));
4849 status = smb2_create(tree_3, mem_ctx, &io);
4850 CHECK_STATUS(status, NT_STATUS_OK);
4851 h2 = io.out.file.handle;
4852 CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_EXISTED);
4853 CHECK_VAL(io.out.size, 0);
4854 CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
4855 /* Should have been denied. */
4856 CHECK_LEASE(&io, "", true, LEASE1, 0);
4857 smb2_util_close(tree_3, h2);
4858
4859 /* Write some data into it. */
4860 w.in.file.handle = h1;
4861 w.in.offset = 0;
4862 w.in.data = data_blob_talloc(mem_ctx, NULL, 1024);
4863 memset(w.in.data.data, '2', w.in.data.length);
4864 status = smb2_write(tree_3, &w);
4865 CHECK_STATUS(status, NT_STATUS_OK);
4866
4867 /* Close everything.. */
4868 smb2_util_close(tree_2, h);
4869 smb2_util_close(tree_3, h1);
4870
4871 /* And ensure we can get a lease ! */
4872 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("RWH"));
4873 status = smb2_create(tree_2, mem_ctx, &io);
4874 CHECK_STATUS(status, NT_STATUS_OK);
4875 CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_EXISTED);
4876 CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
4877 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
4878 h = io.out.file.handle;
4879 /* And the file is the right size. */
4880 CHECK_VAL(io.out.size, 4096); \
4881 /* Close it. */
4882 smb2_util_close(tree_2, h);
4883
4884 /* And ensure we can get a lease ! */
4885 smb2_lease_create(&io, &ls1, false, fname, LEASE1, smb2_util_lease_state("RWH"));
4886 status = smb2_create(tree_3, mem_ctx, &io);
4887 CHECK_STATUS(status, NT_STATUS_OK);
4888 CHECK_VAL(io.out.create_action, NTCREATEX_ACTION_EXISTED);
4889 CHECK_VAL(io.out.file_attr, FILE_ATTRIBUTE_ARCHIVE);
4890 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
4891 h = io.out.file.handle;
4892 /* And the file is the right size. */
4893 CHECK_VAL(io.out.size, 1024); \
4894 /* Close it. */
4895 smb2_util_close(tree_3, h);
4896
4897 done:
4898
4899 if (tree_2 != NULL) {
4900 smb2_util_close(tree_2, h);
4901 smb2_util_unlink(tree_2, fname);
4902 }
4903 if (tree_3 != NULL) {
4904 smb2_util_close(tree_3, h1);
4905 smb2_util_close(tree_3, h2);
4906
4907 smb2_util_unlink(tree_3, fname);
4908 }
4909
4910 /* Set sharename back. */
4911 lpcfg_set_cmdline(tctx->lp_ctx, "torture:share", orig_share);
4912
4913 talloc_free(mem_ctx);
4914
4915 return ret;
4916 }
4917
4918 /*
4919 * Test identifies a bug where the Samba server will not trigger a lease break
4920 * for a handle caching lease held by a client when the underlying file is
4921 * deleted.
4922 * Test:
4923 * Connect session2.
4924 * open file in session1
4925 * session1 should have RWH lease.
4926 * open file in session2
4927 * lease break sent to session1 to downgrade lease to RH
4928 * close file in session 2
4929 * unlink file in session 2
4930 * lease break sent to session1 to downgrade lease to R
4931 * Cleanup
4932 */
4933 static bool test_lease_unlink(struct torture_context *tctx,
4934 struct smb2_tree *tree1)
4935 {
4936 TALLOC_CTX *mem_ctx = talloc_new(tctx);
4937 NTSTATUS status;
4938 bool ret = true;
4939 struct smbcli_options transport2_options;
4940 struct smb2_tree *tree2 = NULL;
4941 struct smb2_transport *transport1 = tree1->session->transport;
4942 struct smb2_transport *transport2;
4943 struct smb2_handle h1 = {};
4944 struct smb2_handle h2 = {};
4945 const char *fname = "lease_unlink.dat";
4946 uint32_t caps;
4947 struct smb2_create io1;
4948 struct smb2_create io2;
4949 struct smb2_lease ls1;
4950 struct smb2_lease ls2;
4951 union smb_setfileinfo sfinfo = {};
4952
4953 caps = smb2cli_conn_server_capabilities(
4954 tree1->session->transport->conn);
4955 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
4956
4957 /* Connect 2nd connection */
4958 transport2_options = transport1->options;
4959 transport2_options.client_guid = GUID_random();
4960 if (!torture_smb2_connection_ext(tctx, 0, &transport2_options, &tree2)) {
4961 torture_warning(tctx, "couldn't reconnect, bailing\n");
4962 return false;
4963 }
4964 transport2 = tree2->session->transport;
4965
4966 /* Set lease handlers */
4967 transport1->lease.handler = torture_lease_handler;
4968 transport1->lease.private_data = tree1;
4969 transport2->lease.handler = torture_lease_handler;
4970 transport2->lease.private_data = tree2;
4971
4972
4973 smb2_lease_create(&io1, &ls1, false, fname, LEASE1,
4974 smb2_util_lease_state("RHW"));
4975 smb2_lease_create(&io2, &ls2, false, fname, LEASE2,
4976 smb2_util_lease_state("RHW"));
4977
4978 smb2_util_unlink(tree1, fname);
4979
4980 torture_comment(tctx, "Client opens fname with session 1\n");
4981 torture_reset_lease_break_info(tctx, &lease_break_info);
4982 status = smb2_create(tree1, mem_ctx, &io1);
4983 CHECK_STATUS(status, NT_STATUS_OK);
4984 h1 = io1.out.file.handle;
4985 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
4986 CHECK_LEASE(&io1, "RHW", true, LEASE1, 0);
4987 CHECK_VAL(lease_break_info.count, 0);
4988
4989 torture_comment(tctx, "Client opens fname with session 2\n");
4990 torture_reset_lease_break_info(tctx, &lease_break_info);
4991 status = smb2_create(tree2, mem_ctx, &io2);
4992 CHECK_STATUS(status, NT_STATUS_OK);
4993 h2 = io2.out.file.handle;
4994 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
4995 CHECK_LEASE(&io2, "RH", true, LEASE2, 0);
4996 CHECK_VAL(lease_break_info.count, 1);
4997 CHECK_BREAK_INFO("RHW", "RH", LEASE1);
4998
4999 torture_comment(tctx,
5000 "Client closes and then unlinks fname with session 2\n");
5001 torture_reset_lease_break_info(tctx, &lease_break_info);
5002 smb2_util_close(tree2, h2);
5003 smb2_util_unlink(tree2, fname);
5004 CHECK_VAL(lease_break_info.count, 1);
5005 CHECK_BREAK_INFO("RH", "R", LEASE1);
5006
5007 smb2_util_close(tree1, h1);
5008
5009 torture_comment(tctx, "Client 1 recreates file with RH lease\n");
5010
5011 torture_reset_lease_break_info(tctx, &lease_break_info);
5012
5013 smb2_lease_create(&io1, &ls1, false, fname, LEASE1,
5014 smb2_util_lease_state("RH"));
5015
5016 status = smb2_create(tree1, mem_ctx, &io1);
5017 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5018 "create failed\n");
5019 h1 = io1.out.file.handle;
5020 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
5021 CHECK_LEASE(&io1, "RH", true, LEASE1, 0);
5022 CHECK_VAL(lease_break_info.count, 0);
5023
5024 torture_comment(tctx, "Client 2 opens with RH lease\n");
5025
5026 smb2_lease_create(&io2, &ls2, false, fname, LEASE2,
5027 smb2_util_lease_state("RH"));
5028 status = smb2_create(tree2, mem_ctx, &io2);
5029 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5030 "create failed\n");
5031
5032 h2 = io2.out.file.handle;
5033 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
5034 CHECK_LEASE(&io2, "RH", true, LEASE2, 0);
5035 CHECK_VAL(lease_break_info.count, 0);
5036
5037 torture_comment(tctx, "Client 2 sets delete on close, "
5038 "triggering lease break\n");
5039
5040 sfinfo.disposition_info.in.delete_on_close = 1;
5041 sfinfo.generic.level = RAW_SFILEINFO_DISPOSITION_INFORMATION;
5042 sfinfo.generic.in.file.handle = h2;
5043
5044 status = smb2_setinfo_file(tree2, &sfinfo);
5045 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5046 "Set DELETE_ON_CLOSE disposition "
5047 "returned un expected status.\n");
5048
5049 CHECK_LEASE(&io1, "RH", true, LEASE1, 0);
5050 CHECK_VAL(lease_break_info.count, 1);
5051
5052 status = smb2_util_close(tree2, h2);
5053 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5054 "smb2_util_close failed\n");
5055 ZERO_STRUCT(h2);
5056
5057 done:
5058 smb2_util_close(tree1, h1);
5059 smb2_util_close(tree2, h2);
5060 smb2_util_unlink(tree1, fname);
5061
5062 return ret;
5063 }
5064
5065 static bool test_lease_timeout_disconnect(struct torture_context *tctx,
5066 struct smb2_tree *tree1)
5067 {
5068 TALLOC_CTX *mem_ctx = talloc_new(tctx);
5069 NTSTATUS status;
5070 bool ret = true;
5071 struct smbcli_options transport2_options;
5072 struct smbcli_options transport3_options;
5073 struct smb2_tree *tree2 = NULL;
5074 struct smb2_tree *tree3 = NULL;
5075 struct smb2_transport *transport1 = tree1->session->transport;
5076 struct smb2_transport *transport2;
5077 struct smb2_transport *transport3;
5078 const char *fname = "lease_timeout_logoff.dat" ;
5079 uint32_t caps;
5080 struct smb2_create io1;
5081 struct smb2_create io2;
5082 struct smb2_request *req2 = NULL;
5083 struct smb2_lease ls1;
5084
5085 caps = smb2cli_conn_server_capabilities(
5086 tree1->session->transport->conn);
5087 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
5088
5089 smb2_util_unlink(tree1, fname);
5090
5091 /* Connect 2nd connection */
5092 torture_comment(tctx, "connect tree2 with the same client_guid\n");
5093 transport2_options = transport1->options;
5094 if (!torture_smb2_connection_ext(tctx, 0, &transport2_options, &tree2)) {
5095 torture_warning(tctx, "couldn't reconnect, bailing\n");
5096 return false;
5097 }
5098 transport2 = tree2->session->transport;
5099
5100 /* Connect 3rd connection */
5101 torture_comment(tctx, "connect tree3 with the same client_guid\n");
5102 transport3_options = transport1->options;
5103 if (!torture_smb2_connection_ext(tctx, 0, &transport3_options, &tree3)) {
5104 torture_warning(tctx, "couldn't reconnect, bailing\n");
5105 return false;
5106 }
5107 transport3 = tree3->session->transport;
5108
5109 /* Set lease handlers */
5110 transport1->lease.handler = torture_lease_handler;
5111 transport1->lease.private_data = tree1;
5112 transport2->lease.handler = torture_lease_handler;
5113 transport2->lease.private_data = tree2;
5114 transport3->lease.handler = torture_lease_handler;
5115 transport3->lease.private_data = tree3;
5116
5117 smb2_lease_create_share(&io1, &ls1, false, fname,
5118 smb2_util_share_access(""),
5119 LEASE1,
5120 smb2_util_lease_state("RH"));
5121 io1.in.durable_open = true;
5122 smb2_generic_create(&io2, NULL, false, fname,
5123 NTCREATEX_DISP_OPEN_IF,
5124 SMB2_OPLOCK_LEVEL_NONE, 0, 0);
5125
5126 torture_comment(tctx, "tree1: create file[%s] with durable RH lease (SHARE NONE)\n", fname);
5127 torture_reset_lease_break_info(tctx, &lease_break_info);
5128 lease_break_info.lease_skip_ack = true;
5129 status = smb2_create(tree1, mem_ctx, &io1);
5130 CHECK_STATUS(status, NT_STATUS_OK);
5131 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
5132 CHECK_LEASE(&io1, "RH", true, LEASE1, 0);
5133 CHECK_VAL(lease_break_info.count, 0);
5134
5135 torture_comment(tctx, "tree1: skip lease acks\n");
5136 torture_reset_lease_break_info(tctx, &lease_break_info);
5137 lease_break_info.lease_skip_ack = true;
5138 torture_comment(tctx, "tree2: open file[%s] without lease (SHARE RWD)\n", fname);
5139 req2 = smb2_create_send(tree2, &io2);
5140 torture_assert(tctx, req2 != NULL, "req2 started");
5141
5142 torture_comment(tctx, "tree1: wait for lease break\n");
5143 torture_wait_for_lease_break(tctx);
5144 CHECK_VAL(lease_break_info.count, 1);
5145 CHECK_BREAK_INFO("RH", "R", LEASE1);
5146
5147 torture_comment(tctx, "tree1: reset lease handler\n");
5148 torture_reset_lease_break_info(tctx, &lease_break_info);
5149 lease_break_info.lease_skip_ack = true;
5150 CHECK_VAL(lease_break_info.count, 0);
5151
5152 torture_comment(tctx, "tree2: check for SMB2_REQUEST_RECV\n");
5153 torture_assert_int_equal(tctx, req2->state,
5154 SMB2_REQUEST_RECV,
5155 "SMB2_REQUEST_RECV");
5156
5157 torture_comment(tctx, "sleep 1\n");
5158 smb_msleep(1000);
5159
5160 torture_comment(tctx, "transport1: keepalive\n");
5161 status = smb2_keepalive(transport1);
5162 CHECK_STATUS(status, NT_STATUS_OK);
5163
5164 torture_comment(tctx, "transport2: keepalive\n");
5165 status = smb2_keepalive(transport2);
5166 CHECK_STATUS(status, NT_STATUS_OK);
5167
5168 torture_comment(tctx, "transport3: keepalive\n");
5169 status = smb2_keepalive(transport3);
5170 CHECK_STATUS(status, NT_STATUS_OK);
5171
5172 torture_comment(tctx, "tree2: check for SMB2_REQUEST_RECV\n");
5173 torture_assert_int_equal(tctx, req2->state,
5174 SMB2_REQUEST_RECV,
5175 "SMB2_REQUEST_RECV");
5176 torture_comment(tctx, "tree2: check for STATUS_PENDING\n");
5177 torture_assert(tctx, req2->cancel.can_cancel, "STATUS_PENDING");
5178
5179 torture_comment(tctx, "sleep 1\n");
5180 smb_msleep(1000);
5181 torture_comment(tctx, "transport1: keepalive\n");
5182 status = smb2_keepalive(transport1);
5183 CHECK_STATUS(status, NT_STATUS_OK);
5184 torture_comment(tctx, "transport2: disconnect\n");
5185 TALLOC_FREE(tree2);
5186
5187 torture_comment(tctx, "sleep 1\n");
5188 smb_msleep(1000);
5189 torture_comment(tctx, "transport1: keepalive\n");
5190 status = smb2_keepalive(transport1);
5191 CHECK_STATUS(status, NT_STATUS_OK);
5192 torture_comment(tctx, "transport1: disconnect\n");
5193 TALLOC_FREE(tree1);
5194
5195 torture_comment(tctx, "sleep 1\n");
5196 smb_msleep(1000);
5197 torture_comment(tctx, "transport3: keepalive\n");
5198 status = smb2_keepalive(transport3);
5199 CHECK_STATUS(status, NT_STATUS_OK);
5200 torture_comment(tctx, "transport3: disconnect\n");
5201 TALLOC_FREE(tree3);
5202
5203 done:
5204
5205 return ret;
5206 }
5207
5208 static bool test_lease_duplicate_create(struct torture_context *tctx,
5209 struct smb2_tree *tree)
5210 {
5211 TALLOC_CTX *mem_ctx = talloc_new(tctx);
5212 struct smb2_create io;
5213 struct smb2_lease ls;
5214 struct smb2_handle h1 = {};
5215 struct smb2_handle h2 = {};
5216 NTSTATUS status;
5217 const char *fname1 = "duplicate_create1.dat";
5218 const char *fname2 = "duplicate_create2.dat";
5219 bool ret = true;
5220 uint32_t caps;
5221
5222 caps = smb2cli_conn_server_capabilities(
5223 tree->session->transport->conn);
5224 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
5225
5226 /* Ensure files don't exist. */
5227 smb2_util_unlink(tree, fname1);
5228 smb2_util_unlink(tree, fname2);
5229
5230 /* Create file1 - LEASE1 key. */
5231 smb2_lease_create(&io, &ls, false, fname1, LEASE1,
5232 smb2_util_lease_state("RWH"));
5233 status = smb2_create(tree, mem_ctx, &io);
5234 CHECK_STATUS(status, NT_STATUS_OK);
5235 h1 = io.out.file.handle;
5236 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
5237 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
5238
5239 /*
5240 * Create file2 with the same LEASE1 key - this should fail with.
5241 * INVALID_PARAMETER.
5242 */
5243 smb2_lease_create(&io, &ls, false, fname2, LEASE1,
5244 smb2_util_lease_state("RWH"));
5245 status = smb2_create(tree, mem_ctx, &io);
5246 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
5247 smb2_util_close(tree, h1);
5248
5249 done:
5250 smb2_util_close(tree, h2);
5251 smb2_util_close(tree, h1);
5252 smb2_util_unlink(tree, fname1);
5253 smb2_util_unlink(tree, fname2);
5254 talloc_free(mem_ctx);
5255 return ret;
5256 }
5257
5258 static bool test_lease_duplicate_open(struct torture_context *tctx,
5259 struct smb2_tree *tree)
5260 {
5261 TALLOC_CTX *mem_ctx = talloc_new(tctx);
5262 struct smb2_create io;
5263 struct smb2_lease ls;
5264 struct smb2_handle h1 = {};
5265 struct smb2_handle h2 = {};
5266 NTSTATUS status;
5267 const char *fname1 = "duplicate_open1.dat";
5268 const char *fname2 = "duplicate_open2.dat";
5269 bool ret = true;
5270 uint32_t caps;
5271
5272 caps = smb2cli_conn_server_capabilities(
5273 tree->session->transport->conn);
5274 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
5275
5276 /* Ensure files don't exist. */
5277 smb2_util_unlink(tree, fname1);
5278 smb2_util_unlink(tree, fname2);
5279
5280 /* Create file1 - LEASE1 key. */
5281 smb2_lease_create(&io, &ls, false, fname1, LEASE1,
5282 smb2_util_lease_state("RWH"));
5283 status = smb2_create(tree, mem_ctx, &io);
5284 CHECK_STATUS(status, NT_STATUS_OK);
5285 h1 = io.out.file.handle;
5286 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
5287 CHECK_LEASE(&io, "RWH", true, LEASE1, 0);
5288
5289 /* Leave file1 open and leased. */
5290
5291 /* Create file2 - no lease. */
5292 smb2_lease_create(&io, NULL, false, fname2, 0,
5293 smb2_util_lease_state("RWH"));
5294 status = smb2_create(tree, mem_ctx, &io);
5295 CHECK_STATUS(status, NT_STATUS_OK);
5296 h2 = io.out.file.handle;
5297 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
5298 /* Close it. */
5299 smb2_util_close(tree, h2);
5300
5301 /*
5302 * Try and open file2 with the same LEASE1 key - this should fail with.
5303 * INVALID_PARAMETER.
5304 */
5305 smb2_lease_create(&io, &ls, false, fname2, LEASE1,
5306 smb2_util_lease_state("RWH"));
5307 status = smb2_create(tree, mem_ctx, &io);
5308 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
5309 /*
5310 * If we did open this is an error, but save off
5311 * the handle so we close below.
5312 */
5313 h2 = io.out.file.handle;
5314
5315 done:
5316 smb2_util_close(tree, h2);
5317 smb2_util_close(tree, h1);
5318 smb2_util_unlink(tree, fname1);
5319 smb2_util_unlink(tree, fname2);
5320 talloc_free(mem_ctx);
5321 return ret;
5322 }
5323
5324 static bool test_lease_v1_bug_15148(struct torture_context *tctx,
5325 struct smb2_tree *tree)
5326 {
5327 TALLOC_CTX *mem_ctx = talloc_new(tctx);
5328 struct smb2_create io1;
5329 struct smb2_create io2;
5330 struct smb2_lease ls1;
5331 struct smb2_lease ls2;
5332 struct smb2_handle h1 = {};
5333 struct smb2_handle h2 = {};
5334 struct smb2_write w;
5335 NTSTATUS status;
5336 const char *fname = "lease_v1_bug_15148.dat";
5337 bool ret = true;
5338 uint32_t caps;
5339
5340 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
5341 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
5342
5343 tree->session->transport->lease.handler = torture_lease_handler;
5344 tree->session->transport->lease.private_data = tree;
5345 tree->session->transport->oplock.handler = torture_oplock_handler;
5346 tree->session->transport->oplock.private_data = tree;
5347
5348 smb2_util_unlink(tree, fname);
5349
5350 torture_reset_lease_break_info(tctx, &lease_break_info);
5351
5352 /* Grab R lease over connection 1a */
5353 smb2_lease_create(&io1, &ls1, false, fname, LEASE1, smb2_util_lease_state("R"));
5354 status = smb2_create(tree, mem_ctx, &io1);
5355 CHECK_STATUS(status, NT_STATUS_OK);
5356 h1 = io1.out.file.handle;
5357 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
5358 CHECK_LEASE(&io1, "R", true, LEASE1, 0);
5359
5360 CHECK_NO_BREAK(tctx);
5361
5362 /* Contend with LEASE2. */
5363 smb2_lease_create(&io2, &ls2, false, fname, LEASE2, smb2_util_lease_state("R"));
5364 status = smb2_create(tree, mem_ctx, &io2);
5365 CHECK_STATUS(status, NT_STATUS_OK);
5366 h2 = io2.out.file.handle;
5367 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
5368 CHECK_LEASE(&io2, "R", true, LEASE2, 0);
5369
5370 CHECK_NO_BREAK(tctx);
5371
5372 ZERO_STRUCT(w);
5373 w.in.file.handle = h1;
5374 w.in.offset = 0;
5375 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
5376 memset(w.in.data.data, 'o', w.in.data.length);
5377 status = smb2_write(tree, &w);
5378 CHECK_STATUS(status, NT_STATUS_OK);
5379
5380 ls2.lease_epoch += 1;
5381 CHECK_BREAK_INFO("R", "", LEASE2);
5382
5383 torture_reset_lease_break_info(tctx, &lease_break_info);
5384
5385 ZERO_STRUCT(w);
5386 w.in.file.handle = h1;
5387 w.in.offset = 0;
5388 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
5389 memset(w.in.data.data, 'O', w.in.data.length);
5390 status = smb2_write(tree, &w);
5391 CHECK_STATUS(status, NT_STATUS_OK);
5392
5393 CHECK_NO_BREAK(tctx);
5394
5395 ZERO_STRUCT(w);
5396 w.in.file.handle = h2;
5397 w.in.offset = 0;
5398 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
5399 memset(w.in.data.data, 'o', w.in.data.length);
5400 status = smb2_write(tree, &w);
5401 CHECK_STATUS(status, NT_STATUS_OK);
5402
5403 ls1.lease_epoch += 1;
5404 CHECK_BREAK_INFO("R", "", LEASE1);
5405
5406 done:
5407 smb2_util_close(tree, h1);
5408 smb2_util_close(tree, h2);
5409
5410 smb2_util_unlink(tree, fname);
5411
5412 talloc_free(mem_ctx);
5413
5414 return ret;
5415 }
5416
5417 static bool test_lease_v2_bug_15148(struct torture_context *tctx,
5418 struct smb2_tree *tree)
5419 {
5420 TALLOC_CTX *mem_ctx = talloc_new(tctx);
5421 struct smb2_create io1;
5422 struct smb2_create io2;
5423 struct smb2_lease ls1;
5424 struct smb2_lease ls2;
5425 struct smb2_handle h1 = {};
5426 struct smb2_handle h2 = {};
5427 struct smb2_write w;
5428 NTSTATUS status;
5429 const char *fname = "lease_v2_bug_15148.dat";
5430 bool ret = true;
5431 uint32_t caps;
5432 enum protocol_types protocol;
5433
5434 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
5435 torture_assert_goto(tctx, caps & SMB2_CAP_LEASING, ret, done, "leases are not supported");
5436
5437 protocol = smbXcli_conn_protocol(tree->session->transport->conn);
5438 if (protocol < PROTOCOL_SMB3_00) {
5439 torture_skip(tctx, "v2 leases are not supported");
5440 }
5441
5442 tree->session->transport->lease.handler = torture_lease_handler;
5443 tree->session->transport->lease.private_data = tree;
5444 tree->session->transport->oplock.handler = torture_oplock_handler;
5445 tree->session->transport->oplock.private_data = tree;
5446
5447 smb2_util_unlink(tree, fname);
5448
5449 torture_reset_lease_break_info(tctx, &lease_break_info);
5450
5451 /* Grab R lease over connection 1a */
5452 smb2_lease_v2_create(&io1, &ls1, false, fname, LEASE1, NULL,
5453 smb2_util_lease_state("R"), 0x4711);
5454 status = smb2_create(tree, mem_ctx, &io1);
5455 CHECK_STATUS(status, NT_STATUS_OK);
5456 h1 = io1.out.file.handle;
5457 CHECK_CREATED(&io1, CREATED, FILE_ATTRIBUTE_ARCHIVE);
5458 ls1.lease_epoch += 1;
5459 CHECK_LEASE_V2(&io1, "R", true, LEASE1,
5460 0, 0, ls1.lease_epoch);
5461
5462 CHECK_NO_BREAK(tctx);
5463
5464 /* Contend with LEASE2. */
5465 smb2_lease_v2_create(&io2, &ls2, false, fname, LEASE2, NULL,
5466 smb2_util_lease_state("R"), 0x11);
5467 status = smb2_create(tree, mem_ctx, &io2);
5468 CHECK_STATUS(status, NT_STATUS_OK);
5469 h2 = io2.out.file.handle;
5470 CHECK_CREATED(&io2, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
5471 ls2.lease_epoch += 1;
5472 CHECK_LEASE_V2(&io2, "R", true, LEASE2,
5473 0, 0, ls2.lease_epoch);
5474
5475 CHECK_NO_BREAK(tctx);
5476
5477 ZERO_STRUCT(w);
5478 w.in.file.handle = h1;
5479 w.in.offset = 0;
5480 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
5481 memset(w.in.data.data, 'o', w.in.data.length);
5482 status = smb2_write(tree, &w);
5483 CHECK_STATUS(status, NT_STATUS_OK);
5484
5485 ls2.lease_epoch += 1;
5486 CHECK_BREAK_INFO_V2(tree->session->transport,
5487 "R", "", LEASE2, ls2.lease_epoch);
5488
5489 torture_reset_lease_break_info(tctx, &lease_break_info);
5490
5491 ZERO_STRUCT(w);
5492 w.in.file.handle = h1;
5493 w.in.offset = 0;
5494 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
5495 memset(w.in.data.data, 'O', w.in.data.length);
5496 status = smb2_write(tree, &w);
5497 CHECK_STATUS(status, NT_STATUS_OK);
5498
5499 CHECK_NO_BREAK(tctx);
5500
5501 ZERO_STRUCT(w);
5502 w.in.file.handle = h2;
5503 w.in.offset = 0;
5504 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
5505 memset(w.in.data.data, 'o', w.in.data.length);
5506 status = smb2_write(tree, &w);
5507 CHECK_STATUS(status, NT_STATUS_OK);
5508
5509 ls1.lease_epoch += 1;
5510 CHECK_BREAK_INFO_V2(tree->session->transport,
5511 "R", "", LEASE1, ls1.lease_epoch);
5512
5513 done:
5514 smb2_util_close(tree, h1);
5515 smb2_util_close(tree, h2);
5516
5517 smb2_util_unlink(tree, fname);
5518
5519 talloc_free(mem_ctx);
5520
5521 return ret;
5522 }
5523
5524 static bool test_initial_delete_tdis(struct torture_context *tctx,
5525 struct smb2_tree *tree1)
5526 {
5527 struct smb2_tree *tree2 = NULL;
5528 struct smb2_create c = {};
5529 struct smb2_handle h1 = {};
5530 struct smb2_lease lease1 = {};
5531 const char *fname = "test_initial_delete_tdis.dat";
5532 NTSTATUS status;
5533 bool ret = true;
5534
5535 tree1->session->transport->lease.handler = torture_lease_handler;
5536 tree1->session->transport->lease.private_data = tree1;
5537 torture_reset_lease_break_info(tctx, &lease_break_info);
5538
5539 ret = torture_smb2_connection(tctx, &tree2);
5540 torture_assert_goto(tctx, ret, ret, done, "torture_smb2_connection failed\n");
5541
5542 smb2_util_unlink(tree1, fname);
5543
5544 smb2_lease_v2_create_share(&c, &lease1, false, fname,
5545 smb2_util_share_access("RWD"),
5546 LEASE1,
5547 NULL,
5548 smb2_util_lease_state("RH"),
5549 0);
5550 status = smb2_create(tree1, tree1, &c);
5551 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5552 "smb2_create failed\n");
5553 h1 = c.out.file.handle;
5554
5555 c = (struct smb2_create) {
5556 .in.desired_access = SEC_RIGHTS_FILE_ALL ,
5557 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
5558 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
5559 .in.create_disposition = NTCREATEX_DISP_OPEN,
5560 .in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE,
5561 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
5562 .in.fname = fname,
5563 };
5564
5565 status = smb2_create(tree2, tree2, &c);
5566 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5567 "smb2_create failed\n");
5568
5569 status = smb2_tdis(tree2);
5570 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5571 "smb2_create failed\n");
5572
5573 CHECK_BREAK_INFO_V2(tree1->session->transport,
5574 "RH", "R",
5575 LEASE1,
5576 2);
5577
5578 status = smb2_util_close(tree1, h1);
5579 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5580 "smb2_util_close failed\n");
5581 ZERO_STRUCT(h1);
5582
5583 c = (struct smb2_create) {
5584 .in.desired_access = SEC_RIGHTS_FILE_ALL ,
5585 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
5586 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
5587 .in.create_disposition = NTCREATEX_DISP_OPEN,
5588 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
5589 .in.fname = fname,
5590 };
5591
5592 status = smb2_create(tree1, tree1, &c);
5593 torture_assert_ntstatus_equal_goto(tctx, status,
5594 NT_STATUS_OBJECT_NAME_NOT_FOUND,
5595 ret, done,
5596 "file still there?\n");
5597
5598 done:
5599 smb2_util_unlink(tree1, fname);
5600 return ret;
5601 }
5602
5603 static bool test_initial_delete_logoff(struct torture_context *tctx,
5604 struct smb2_tree *tree1)
5605 {
5606 struct smb2_tree *tree2 = NULL;
5607 struct smb2_create c = {};
5608 struct smb2_handle h1 = {};
5609 struct smb2_lease lease1 = {};
5610 const char *fname = "test_initial_delete_logoff.dat";
5611 NTSTATUS status;
5612 bool ret = true;
5613
5614 tree1->session->transport->lease.handler = torture_lease_handler;
5615 tree1->session->transport->lease.private_data = tree1;
5616 torture_reset_lease_break_info(tctx, &lease_break_info);
5617
5618 ret = torture_smb2_connection(tctx, &tree2);
5619 torture_assert_goto(tctx, ret, ret, done, "torture_smb2_connection failed\n");
5620
5621 smb2_util_unlink(tree2, fname);
5622
5623 smb2_lease_v2_create_share(&c, &lease1, false, fname,
5624 smb2_util_share_access("RWD"),
5625 LEASE1,
5626 NULL,
5627 smb2_util_lease_state("RH"),
5628 0);
5629 status = smb2_create(tree1, tree1, &c);
5630 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5631 "smb2_create failed\n");
5632 h1 = c.out.file.handle;
5633
5634 c = (struct smb2_create) {
5635 .in.desired_access = SEC_RIGHTS_FILE_ALL ,
5636 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
5637 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
5638 .in.create_disposition = NTCREATEX_DISP_OPEN,
5639 .in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE,
5640 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
5641 .in.fname = fname,
5642 };
5643
5644 status = smb2_create(tree2, tree2, &c);
5645 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5646 "smb2_create failed\n");
5647
5648 status = smb2_logoff(tree2->session);
5649 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5650 "smb2_create failed\n");
5651
5652 CHECK_BREAK_INFO_V2(tree1->session->transport,
5653 "RH", "R",
5654 LEASE1,
5655 2);
5656
5657 status = smb2_util_close(tree1, h1);
5658 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5659 "smb2_util_close failed\n");
5660 ZERO_STRUCT(h1);
5661
5662 c = (struct smb2_create) {
5663 .in.desired_access = SEC_RIGHTS_FILE_ALL ,
5664 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
5665 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
5666 .in.create_disposition = NTCREATEX_DISP_OPEN,
5667 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
5668 .in.fname = fname,
5669 };
5670
5671 status = smb2_create(tree1, tree1, &c);
5672 torture_assert_ntstatus_equal_goto(tctx, status,
5673 NT_STATUS_OBJECT_NAME_NOT_FOUND,
5674 ret, done,
5675 "file still there?\n");
5676
5677 done:
5678 return ret;
5679 }
5680
5681 static bool test_initial_delete_disconnect(struct torture_context *tctx,
5682 struct smb2_tree *tree1)
5683 {
5684 struct smb2_tree *tree2 = NULL;
5685 struct smb2_create c = {};
5686 struct smb2_handle h1 = {};
5687 struct smb2_lease lease1 = {};
5688 const char *fname = "test_initial_delete_disconnect.dat";
5689 NTSTATUS status;
5690 bool ret = true;
5691
5692 tree1->session->transport->lease.handler = torture_lease_handler;
5693 tree1->session->transport->lease.private_data = tree1;
5694 torture_reset_lease_break_info(tctx, &lease_break_info);
5695
5696 ret = torture_smb2_connection(tctx, &tree2);
5697 torture_assert_goto(tctx, ret, ret, done, "torture_smb2_connection failed\n");
5698
5699 smb2_util_unlink(tree2, fname);
5700
5701 smb2_lease_v2_create_share(&c, &lease1, false, fname,
5702 smb2_util_share_access("RWD"),
5703 LEASE1,
5704 NULL,
5705 smb2_util_lease_state("RH"),
5706 0);
5707 status = smb2_create(tree1, tree1, &c);
5708 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5709 "smb2_create failed\n");
5710 h1 = c.out.file.handle;
5711
5712 c = (struct smb2_create) {
5713 .in.desired_access = SEC_RIGHTS_FILE_ALL ,
5714 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
5715 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
5716 .in.create_disposition = NTCREATEX_DISP_OPEN,
5717 .in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE,
5718 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
5719 .in.fname = fname,
5720 };
5721
5722 status = smb2_create(tree2, tree2, &c);
5723 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5724 "smb2_create failed\n");
5725
5726 TALLOC_FREE(tree2);
5727
5728 CHECK_BREAK_INFO_V2(tree1->session->transport,
5729 "RH", "R",
5730 LEASE1,
5731 2);
5732
5733 status = smb2_util_close(tree1, h1);
5734 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5735 "smb2_util_close failed\n");
5736 ZERO_STRUCT(h1);
5737
5738 c = (struct smb2_create) {
5739 .in.desired_access = SEC_RIGHTS_FILE_ALL ,
5740 .in.file_attributes = FILE_ATTRIBUTE_NORMAL,
5741 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
5742 .in.create_disposition = NTCREATEX_DISP_OPEN,
5743 .in.impersonation_level = SMB2_IMPERSONATION_ANONYMOUS,
5744 .in.fname = fname,
5745 };
5746
5747 status = smb2_create(tree1, tree1, &c);
5748 torture_assert_ntstatus_equal_goto(tctx, status,
5749 NT_STATUS_OBJECT_NAME_NOT_FOUND,
5750 ret, done,
5751 "file still there?\n");
5752
5753 done:
5754 return ret;
5755 }
5756
5757 struct rename_tcase_open {
5758 bool hlease;
5759 bool close_on_break;
5760 };
5761
5762 struct rename_tcase {
5763 const char *name;
5764 bool disabled;
5765 struct rename_tcase_open o1;
5766 struct rename_tcase_open o2;
5767 bool do_o3;
5768 struct rename_tcase_open o3;
5769 NTSTATUS status;
5770 };
5771
5772 static bool torture_rename_dir_openfile_do(struct torture_context *tctx,
5773 struct smb2_tree *tree1,
5774 struct smb2_tree *tree2,
5775 struct rename_tcase *t)
5776 {
5777 struct smb2_create c = {};
5778 union smb_setfileinfo sinfo = {};
5779 struct smb2_handle d1 = {};
5780 struct smb2_handle h1 = {};
5781 struct smb2_handle h2 = {};
5782 struct smb2_handle h3 = {};
5783 struct smb2_handle *h = NULL;
5784 struct smb2_lease *please1 = NULL;
5785 struct smb2_lease *please2 = NULL;
5786 struct smb2_lease *please3 = NULL;
5787 struct smb2_lease lease1 = {};
5788 struct smb2_lease lease2 = {};
5789 struct smb2_lease lease3 = {};
5790 struct smb2_request *req = NULL;
5791 struct smb2_lease_break_ack ack = {};
5792 struct rename_tcase_open *to = NULL;
5793 const char *dname = "torture_rename_dir_openfile_dir";
5794 const char *fname1 = "torture_rename_dir_openfile_dir\\torture_rename_dir_openfile_file1";
5795 const char *fname2 = "torture_rename_dir_openfile_dir\\torture_rename_dir_openfile_file2";
5796 const char *fname3 = "torture_rename_dir_openfile_dir\\torture_rename_dir_openfile_file3";
5797 const char *new_dname = "torture_rename_dir_openfile_dir-renamed";
5798 bool expect_immediate_fail = false;
5799 bool ret = true;
5800 NTSTATUS status;
5801
5802 torture_comment(tctx, "Subtest: %s\n", t->name);
5803 if (t->disabled) {
5804 torture_comment(tctx, "...skipped\n");
5805 return true;
5806 }
5807
5808 tree2->session->transport->lease.handler = torture_lease_handler;
5809 tree2->session->transport->lease.private_data = tree2;
5810 torture_reset_lease_break_info(tctx, &lease_break_info);
5811 lease_break_info.lease_skip_ack = true;
5812
5813 smb2_deltree(tree1, dname);
5814 smb2_deltree(tree1, new_dname);
5815
5816 torture_comment(tctx, "Creating base directory\n");
5817
5818 smb2_lease_v2_create_share(&c, NULL, true, dname,
5819 smb2_util_share_access("RWD"),
5820 0,
5821 NULL,
5822 smb2_util_lease_state(""),
5823 0);
5824 status = smb2_create(tree1, tree1, &c);
5825 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5826 "smb2_create failed\n");
5827 d1 = c.out.file.handle;
5828
5829 torture_comment(tctx, "Creating test file1\n");
5830
5831 if (t->o1.hlease) {
5832 please1 = &lease1;
5833 }
5834 smb2_lease_v2_create_share(&c, please1, false, fname1,
5835 smb2_util_share_access("RWD"),
5836 LEASE1,
5837 NULL,
5838 smb2_util_lease_state("RH"),
5839 0);
5840 status = smb2_create(tree2, tree2, &c);
5841 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5842 "smb2_create failed\n");
5843 h1 = c.out.file.handle;
5844
5845 torture_comment(tctx, "Creating test file2\n");
5846
5847 if (t->o2.hlease) {
5848 please2 = &lease2;
5849 }
5850 smb2_lease_v2_create_share(&c, please2, false, fname2,
5851 smb2_util_share_access("RWD"),
5852 LEASE2,
5853 NULL,
5854 smb2_util_lease_state("RH"),
5855 0);
5856 status = smb2_create(tree2, tree2, &c);
5857 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5858 "smb2_create failed\n");
5859 h2 = c.out.file.handle;
5860
5861 torture_comment(tctx, "Renaming directory\n");
5862
5863 sinfo.rename_information.level = RAW_SFILEINFO_RENAME_INFORMATION;
5864 sinfo.rename_information.in.file.handle = d1;
5865 sinfo.rename_information.in.new_name = new_dname;
5866
5867 req = smb2_setinfo_file_send(tree1, &sinfo);
5868 torture_assert_goto(tctx, req != NULL, ret, done,
5869 "smb2_setinfo_file_send");
5870
5871 torture_assert(tctx, req->state == SMB2_REQUEST_RECV, "bad req state");
5872
5873 if (t->o1.hlease || t->o2.hlease) {
5874 /* Get the first break */
5875 torture_wait_for_lease_break(tctx);
5876
5877 if (lease_break_info.count == 0) {
5878 /*
5879 * If one of the two opens was without a h-lease, the
5880 * scan for opens might hit the open without h-lease
5881 * first triggering an immediate STATUS_ACCESS_DENIED
5882 * for the rename without sending out any lease break.
5883 */
5884 torture_assert_goto(tctx, (!t->o1.hlease || !t->o2.hlease),
5885 ret, done,
5886 "Expected only one hlease when getting no hlease break\n");
5887
5888 status = smb2_setinfo_recv(req);
5889 torture_assert_ntstatus_equal_goto(tctx, status, t->status, ret, done,
5890 "Rename didn't work as expected\n");
5891 goto done;
5892 }
5893
5894 if (lease_break_info.lease_break.current_lease.lease_key.data[0] == LEASE1 &&
5895 lease_break_info.lease_break.current_lease.lease_key.data[1] == ~LEASE1)
5896 {
5897 torture_comment(tctx, "Got break for file 1\n");
5898 please1 = &lease1;
5899 h = &h1;
5900 to = &t->o1;
5901 } else {
5902 torture_comment(tctx, "Got break for file 2\n");
5903 please1 = &lease2;
5904 h = &h2;
5905 to = &t->o2;
5906 }
5907 please1->lease_epoch += 2;
5908
5909 CHECK_BREAK_INFO_V2_NOWAIT(tree2->session->transport,
5910 "RH", "R",
5911 please1->lease_key.data[0],
5912 please1->lease_epoch);
5913
5914 ack.in.lease.lease_key = lease_break_info.lease_break.current_lease.lease_key;
5915 ack.in.lease.lease_state = lease_break_info.lease_break.new_lease_state;
5916 torture_reset_lease_break_info(tctx, &lease_break_info);
5917 lease_break_info.lease_skip_ack = true;
5918
5919 if (to->close_on_break) {
5920 status = smb2_util_close(tree2, *h);
5921 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5922 "smb2_util_close failed\n");
5923 ZERO_STRUCTP(h);
5924 } else {
5925 status = smb2_lease_break_ack(tree2, &ack);
5926 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5927 "ack failed\n");
5928 expect_immediate_fail = true;
5929 }
5930 }
5931
5932 if (t->do_o3) {
5933 torture_comment(tctx, "Doing additional open after first break\n");
5934
5935 if (t->o3.hlease) {
5936 please3 = &lease3;
5937 }
5938 smb2_lease_v2_create_share(&c, please3, false, fname3,
5939 smb2_util_share_access("RWD"),
5940 LEASE3,
5941 NULL,
5942 smb2_util_lease_state("RH"),
5943 0);
5944 status = smb2_create(tree2, tree2, &c);
5945 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5946 "smb2_create failed\n");
5947 h3 = c.out.file.handle;
5948 }
5949
5950 if (!expect_immediate_fail && t->o1.hlease && t->o2.hlease) {
5951 /* Get the second break */
5952 torture_wait_for_lease_break(tctx);
5953
5954 if (lease_break_info.lease_break.current_lease.lease_key.data[0] == LEASE1 &&
5955 lease_break_info.lease_break.current_lease.lease_key.data[1] == ~LEASE1)
5956 {
5957 torture_comment(tctx, "Got break for file 1\n");
5958 please1 = &lease1;
5959 h = &h1;
5960 to = &t->o1;
5961 } else {
5962 torture_comment(tctx, "Got break for file 2\n");
5963 please1 = &lease2;
5964 h = &h2;
5965 to = &t->o2;
5966 }
5967 please1->lease_epoch += 2;
5968
5969 CHECK_BREAK_INFO_V2_NOWAIT(tree2->session->transport,
5970 "RH", "R",
5971 please1->lease_key.data[0],
5972 please1->lease_epoch);
5973
5974 ack.in.lease.lease_key = lease_break_info.lease_break.current_lease.lease_key;
5975 ack.in.lease.lease_state = lease_break_info.lease_break.new_lease_state;
5976 torture_reset_lease_break_info(tctx, &lease_break_info);
5977 lease_break_info.lease_skip_ack = true;
5978
5979 if (to->close_on_break) {
5980 status = smb2_util_close(tree2, *h);
5981 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5982 "smb2_util_close failed\n");
5983 ZERO_STRUCTP(h);
5984 } else {
5985 status = smb2_lease_break_ack(tree2, &ack);
5986 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
5987 "ack failed\n");
5988 }
5989 }
5990
5991 status = smb2_setinfo_recv(req);
5992 torture_assert_ntstatus_equal_goto(tctx, status, t->status, ret, done,
5993 "Rename didn't work as expected\n");
5994
5995 done:
5996 if (!smb2_util_handle_empty(d1)) {
5997 smb2_util_close(tree1, d1);
5998 }
5999 if (!smb2_util_handle_empty(h1)) {
6000 smb2_util_close(tree2, h1);
6001 }
6002 if (!smb2_util_handle_empty(h2)) {
6003 smb2_util_close(tree2, h2);
6004 }
6005 if (!smb2_util_handle_empty(h3)) {
6006 smb2_util_close(tree2, h3);
6007 }
6008 smb2_deltree(tree1, dname);
6009 smb2_deltree(tree1, new_dname);
6010 return ret;
6011 }
6012
6013 static bool torture_rename_dir_openfile(struct torture_context *tctx,
6014 struct smb2_tree *tree1,
6015 struct smb2_tree *tree2)
6016 {
6017 struct rename_tcase tcases[] = {
6018 {
6019 .name = "two-hleases-two-closes",
6020 .o1 = { .hlease = true, .close_on_break = true },
6021 .o2 = { .hlease = true, .close_on_break = true },
6022 .do_o3 = false,
6023 .status = NT_STATUS_OK,
6024 },
6025 {
6026 .name = "no-hleases",
6027 .o1 = { .hlease = false, },
6028 .o2 = { .hlease = false, },
6029 .do_o3 = false,
6030 .status = NT_STATUS_ACCESS_DENIED,
6031 },
6032 {
6033 .name = "two-hleases-second-hlease-close",
6034 .o1 = { .hlease = true, .close_on_break = false },
6035 .o2 = { .hlease = true, .close_on_break = true },
6036 .do_o3 = false,
6037 .status = NT_STATUS_ACCESS_DENIED,
6038 },
6039 {
6040 .name = "two-hleases-first-hlease-close",
6041 .o1 = { .hlease = true, .close_on_break = true },
6042 .o2 = { .hlease = true, .close_on_break = false },
6043 .do_o3 = false,
6044 .status = NT_STATUS_ACCESS_DENIED,
6045 },
6046 {
6047 .name = "first-hlease-close",
6048 .o1 = { .hlease = true, .close_on_break = true },
6049 .o2 = { .hlease = false, },
6050 .do_o3 = false,
6051 .status = NT_STATUS_ACCESS_DENIED,
6052 },
6053 {
6054 .name = "second-hlease-close",
6055 .o1 = { .hlease = false, },
6056 .o2 = { .hlease = true, .close_on_break = true },
6057 .do_o3 = false,
6058 .status = NT_STATUS_ACCESS_DENIED,
6059 },
6060 {
6061 .name = "two-hleases-two-closes-addopen-w-hlease",
6062 .o1 = { .hlease = true, .close_on_break = true },
6063 .o2 = { .hlease = true, .close_on_break = true },
6064 .do_o3 = true,
6065 .o3 = { .hlease = true, .close_on_break = true },
6066 .status = NT_STATUS_ACCESS_DENIED,
6067 },
6068 {
6069 .name = "two-hleases-two-closes-addopen-wo-hlease",
6070 .o1 = { .hlease = true, .close_on_break = true },
6071 .o2 = { .hlease = true, .close_on_break = true },
6072 .do_o3 = true,
6073 .o3 = { .hlease = false, },
6074 .status = NT_STATUS_ACCESS_DENIED,
6075 },
6076 };
6077 size_t i;
6078 bool ret;
6079
6080 tree1->session->transport->lease.handler = torture_lease_handler;
6081 tree1->session->transport->lease.private_data = tree2;
6082 torture_reset_lease_break_info(tctx, &lease_break_info);
6083
6084 for (i = 0; i < ARRAY_SIZE(tcases); i++) {
6085 ret = torture_rename_dir_openfile_do(tctx, tree1, tree2, &tcases[i]);
6086 torture_assert_goto(tctx, ret, ret, done, "test failed\n");
6087 }
6088
6089 done:
6090 return ret;
6091 }
6092
6093 /*
6094 * Verifies the lease epoch is not incremented by the server (returns what the
6095 * client sent in the request) if a lease was not granted ie lease_level=NONE.
6096 */
6097 static bool test_lease_epoch(struct torture_context *tctx,
6098 struct smb2_tree *tree)
6099 {
6100 struct smb2_create c;
6101 struct smb2_lease ls1;
6102 struct smb2_handle h1 = {};
6103 struct smb2_write wr;
6104 char dat = 'x';
6105 DATA_BLOB data = (DATA_BLOB) {.data = (uint8_t *)&dat, .length = 1};
6106 struct smb2_lock lck = {0};
6107 struct smb2_lock_element el[1];
6108 uint64_t lease1 = 1;
6109 struct GUID create_guid = GUID_random();
6110 char *fname = NULL;
6111 NTSTATUS status;
6112 bool ret = true;
6113
6114 fname = talloc_asprintf(tctx, "lease_break-%ld.dat", random());
6115 torture_assert_not_null_goto(tctx, fname, ret, done,
6116 "talloc_asprintf failed\n");
6117
6118 c = (struct smb2_create) {
6119 .in.desired_access = SEC_RIGHTS_FILE_ALL,
6120 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
6121 .in.create_disposition = NTCREATEX_DISP_OPEN_IF,
6122 .in.fname = fname,
6123 };
6124
6125 status = smb2_create(tree, tctx, &c);
6126 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6127 "smb2_create failed\n");
6128 h1 = c.out.file.handle;
6129
6130 ZERO_STRUCT(wr);
6131 wr.in.file.handle = h1;
6132 wr.in.offset = 0;
6133 wr.in.data = data;
6134 status = smb2_write(tree, &wr);
6135 torture_assert_ntstatus_ok(tctx, status, "smb2_write failed\n");
6136
6137 ZERO_ARRAY(el);
6138 ZERO_STRUCT(lck);
6139 el[0].offset = 0;
6140 el[0].length = 1;
6141 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE|SMB2_LOCK_FLAG_FAIL_IMMEDIATELY;
6142 lck.in.locks = el;
6143 lck.in.lock_count = 1;
6144 lck.in.file.handle = h1;
6145
6146 status = smb2_lock(tree, &lck);
6147 torture_assert_ntstatus_equal_goto(
6148 tctx, status, NT_STATUS_OK,
6149 ret, done, "smb2_lock failed\n");
6150
6151
6152 smb2_lease_v2_create_share(&c,
6153 &ls1,
6154 false,
6155 fname,
6156 smb2_util_share_access("RWD"),
6157 lease1,
6158 NULL,
6159 smb2_util_lease_state("R"),
6160 100);
6161 c.in.durable_open_v2 = true;
6162 c.in.create_guid = create_guid;
6163 status = smb2_create(tree, tree, &c);
6164 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6165 "smb2_create failed\n");
6166
6167 torture_assert_int_equal_goto(
6168 tctx,
6169 c.out.oplock_level,
6170 SMB2_OPLOCK_LEVEL_LEASE,
6171 ret, done,
6172 "Bad lease level\n");
6173 torture_assert_int_equal_goto(
6174 tctx,
6175 c.out.lease_response_v2.lease_state,
6176 0,
6177 ret, done,
6178 "Bad lease level\n");
6179 torture_assert_int_equal_goto(
6180 tctx,
6181 c.out.lease_response_v2.lease_epoch,
6182 100,
6183 ret,
6184 done,
6185 "Bad lease epoch\n");
6186
6187 done:
6188 return ret;
6189 }
6190
6191 /*
6192 * Verify a redispatched deferred open doesn't send a lease break to the client
6193 *
6194 * 1. Client 1: Open file with RH lease
6195 * 2. Client 1: Second open with RH lease, different lease key
6196 * 3. Client 2: Try to open file with incompatible mode, triggers sharing
6197 * violation, triggers H lease breaks and gets deferred.
6198 * 4. Client 1: close handle 1, this will trigger a redispatch of the deferred
6199 * open from 3.
6200 * 5. Check the client doesn't get a lease break.
6201 */
6202 static bool test_two_leases(struct torture_context *tctx,
6203 struct smb2_tree *_tree)
6204 {
6205 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6206 struct smbcli_options options = _tree->session->transport->options;
6207 struct smb2_tree *tree1 = NULL;
6208 struct smb2_tree *tree2 = NULL;
6209 struct smb2_request *req = NULL;
6210 struct smb2_create c;
6211 struct smb2_lease ls;
6212 uint64_t broken_ls_key;
6213 struct smb2_handle h1 = {};
6214 struct smb2_handle h2 = {};
6215 struct smb2_handle ch1 = {};
6216 struct smb2_handle ch2 = {};
6217 char *fname = NULL;
6218 int rc;
6219 NTSTATUS status;
6220 bool ret = true;
6221
6222 fname = talloc_asprintf(mem_ctx, "lease_break-%ld.dat", random());
6223 torture_assert_not_null_goto(tctx, fname, ret, done,
6224 "talloc_asprintf failed\n");
6225
6226 options.client_guid = GUID_random();
6227 ret = torture_smb2_connection_ext(tctx, 0, &options, &tree1);
6228 torture_assert_goto(tctx, ret, ret, done, "torture_smb2_connection_ext failed\n");
6229
6230 options.client_guid = GUID_random();
6231 ret = torture_smb2_connection_ext(tctx, 0, &options, &tree2);
6232 torture_assert_goto(tctx, ret, ret, done,
6233 "torture_smb2_connection_ext failed\n");
6234
6235 torture_reset_lease_break_info(tctx, &lease_break_info);
6236 lease_break_info.lease_skip_ack = true;
6237 tree1->session->transport->lease.handler = torture_lease_handler;
6238 tree1->session->transport->lease.private_data = tree1;
6239
6240 status = torture_setup_simple_file(tctx, tree1, fname);
6241 torture_assert_ntstatus_ok(tctx, status, "setup file failed\n");
6242
6243 /*
6244 * First open with RH lease
6245 */
6246 smb2_lease_v2_create_share(&c,
6247 &ls,
6248 false,
6249 fname,
6250 smb2_util_share_access("R"),
6251 1,
6252 NULL,
6253 smb2_util_lease_state("RH"),
6254 0);
6255 c.in.durable_open_v2 = true;
6256 c.in.create_guid = GUID_random();
6257 c.in.desired_access = SEC_RIGHTS_FILE_READ;
6258
6259 status = smb2_create(tree1, mem_ctx, &c);
6260 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6261 "smb2_create failed\n");
6262 h1 = c.out.file.handle;
6263
6264 torture_assert_int_equal_goto(
6265 tctx,
6266 c.out.oplock_level,
6267 SMB2_OPLOCK_LEVEL_LEASE,
6268 ret, done,
6269 "Bad lease level\n");
6270 torture_assert_int_equal_goto(
6271 tctx,
6272 c.out.lease_response_v2.lease_state,
6273 smb2_util_lease_state("RH"),
6274 ret, done,
6275 "Bad lease level\n");
6276
6277 /*
6278 * Second open with RH lease
6279 */
6280 smb2_lease_v2_create_share(&c,
6281 &ls,
6282 false,
6283 fname,
6284 smb2_util_share_access("R"),
6285 2,
6286 NULL,
6287 smb2_util_lease_state("RH"),
6288 0);
6289 c.in.durable_open_v2 = true;
6290 c.in.create_guid = GUID_random();
6291 c.in.desired_access = SEC_RIGHTS_FILE_READ;
6292
6293 status = smb2_create(tree1, mem_ctx, &c);
6294 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6295 "smb2_create failed\n");
6296 h2 = c.out.file.handle;
6297
6298 torture_assert_int_equal_goto(
6299 tctx,
6300 c.out.oplock_level,
6301 SMB2_OPLOCK_LEVEL_LEASE,
6302 ret, done,
6303 "Bad lease level\n");
6304 torture_assert_int_equal_goto(
6305 tctx,
6306 c.out.lease_response_v2.lease_state,
6307 smb2_util_lease_state("RH"),
6308 ret, done,
6309 "Bad lease level\n");
6310
6311 /*
6312 * Third open triggering a sharing violation and two H-lease breaks
6313 */
6314
6315 smb2_lease_v2_create_share(&c,
6316 &ls,
6317 false,
6318 fname,
6319 smb2_util_share_access(""),
6320 3,
6321 NULL,
6322 smb2_util_lease_state("RH"),
6323 0);
6324 c.in.durable_open_v2 = true;
6325 c.in.create_guid = GUID_random();
6326
6327 req = smb2_create_send(tree2, &c);
6328 torture_assert_not_null_goto(tctx, req, ret, done,
6329 "smb2_create_send failed\n");
6330
6331 while (!req->cancel.can_cancel &&
6332 (req->state < SMB2_REQUEST_DONE))
6333 {
6334 rc = tevent_loop_once(req->transport->ev);
6335 torture_assert_goto(tctx, rc == 0, ret, done,
6336 "tevent_loop_once failed\n");
6337 }
6338 torture_assert_goto(tctx, req->state < SMB2_REQUEST_DONE,
6339 ret, done,
6340 "Expected async interim response\n");
6341
6342 /* Wait for first break */
6343 torture_wait_for_lease_break(tctx);
6344
6345 if (lease_break_info.lease_break.current_lease.lease_key.data[0] == 1) {
6346 broken_ls_key = 1;
6347 ch1 = h1;
6348 ch2 = h2;
6349 ZERO_STRUCT(h1);
6350 ZERO_STRUCT(h2);
6351 } else {
6352 broken_ls_key = 2;
6353 ch1 = h2;
6354 ch2 = h1;
6355 ZERO_STRUCT(h1);
6356 ZERO_STRUCT(h2);
6357 }
6358
6359 /* Wait for second break */
6360 torture_wait_for_lease_break(tctx);
6361
6362 CHECK_VAL(lease_break_info.count, 2);
6363 lease_break_info.count = 1; /* trick CHECK_BREAK_INFO_V2_NOWAIT() */
6364 CHECK_BREAK_INFO_V2_NOWAIT(tree1->session->transport,
6365 "RH",
6366 "R",
6367 broken_ls_key,
6368 2);
6369
6370 torture_reset_lease_break_info(tctx, &lease_break_info);
6371 lease_break_info.lease_skip_ack = true;
6372
6373 status = smb2_util_close(tree1, ch1);
6374 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6375 "smb2_create failed\n");
6376 ZERO_STRUCT(ch1);
6377
6378 CHECK_NO_BREAK(tctx);
6379
6380 status = smb2_util_close(tree1, ch2);
6381 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6382 "smb2_create failed\n");
6383 ZERO_STRUCT(ch2);
6384
6385 status = smb2_create_recv(req, tctx, &c);
6386 torture_assert_ntstatus_equal_goto(
6387 tctx, status, NT_STATUS_OK,
6388 ret, done, "smb2_create failed\n");
6389
6390 status = smb2_util_close(tree2, c.out.file.handle);
6391 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6392 "smb2_create failed\n");
6393
6394 done:
6395 if (!smb2_util_handle_empty(h1)) {
6396 smb2_util_close(tree1, h1);
6397 }
6398 if (!smb2_util_handle_empty(h2)) {
6399 smb2_util_close(tree1, h2);
6400 }
6401 if (!smb2_util_handle_empty(ch1)) {
6402 smb2_util_close(tree1, ch1);
6403 }
6404 if (!smb2_util_handle_empty(ch2)) {
6405 smb2_util_close(tree1, ch2);
6406 }
6407 smb2_util_unlink(_tree, fname);
6408 TALLOC_FREE(tree1);
6409 TALLOC_FREE(tree2);
6410 TALLOC_FREE(mem_ctx);
6411 return ret;
6412 }
6413
6414 struct torture_suite *torture_smb2_lease_init(TALLOC_CTX *ctx)
6415 {
6416 struct torture_suite *suite =
6417 torture_suite_create(ctx, "lease");
6418
6419 torture_suite_add_1smb2_test(suite, "request", test_lease_request);
6420 torture_suite_add_1smb2_test(suite, "break_twice",
6421 test_lease_break_twice);
6422 torture_suite_add_1smb2_test(suite, "nobreakself",
6423 test_lease_nobreakself);
6424 torture_suite_add_1smb2_test(suite, "statopen", test_lease_statopen);
6425 torture_suite_add_1smb2_test(suite, "statopen2", test_lease_statopen2);
6426 torture_suite_add_1smb2_test(suite, "statopen3", test_lease_statopen3);
6427 torture_suite_add_1smb2_test(suite, "statopen4", test_lease_statopen4);
6428 torture_suite_add_1smb2_test(suite, "upgrade", test_lease_upgrade);
6429 torture_suite_add_1smb2_test(suite, "upgrade2", test_lease_upgrade2);
6430 torture_suite_add_1smb2_test(suite, "upgrade3", test_lease_upgrade3);
6431 torture_suite_add_1smb2_test(suite, "break", test_lease_break);
6432 torture_suite_add_1smb2_test(suite, "oplock", test_lease_oplock);
6433 torture_suite_add_1smb2_test(suite, "multibreak", test_lease_multibreak);
6434 torture_suite_add_1smb2_test(suite, "breaking1", test_lease_breaking1);
6435 torture_suite_add_1smb2_test(suite, "breaking2", test_lease_breaking2);
6436 torture_suite_add_1smb2_test(suite, "breaking3", test_lease_breaking3);
6437 torture_suite_add_1smb2_test(suite, "v2_breaking3", test_lease_v2_breaking3);
6438 torture_suite_add_1smb2_test(suite, "breaking4", test_lease_breaking4);
6439 torture_suite_add_1smb2_test(suite, "breaking5", test_lease_breaking5);
6440 torture_suite_add_1smb2_test(suite, "breaking6", test_lease_breaking6);
6441 torture_suite_add_2smb2_test(suite, "lock1", test_lease_lock1);
6442 torture_suite_add_2smb2_test(suite, "lock2", test_lease_lock2);
6443 torture_suite_add_2smb2_test(suite, "lock3", test_lease_lock3);
6444 torture_suite_add_2smb2_test(suite, "sharing_violation", test_lease_sharing_violation);
6445 torture_suite_add_1smb2_test(suite, "complex1", test_lease_complex1);
6446 torture_suite_add_1smb2_test(suite, "v2_flags_breaking", test_lease_v2_flags_breaking);
6447 torture_suite_add_1smb2_test(suite, "v2_flags_parentkey", test_lease_v2_flags_parentkey);
6448 torture_suite_add_1smb2_test(suite, "v2_epoch1", test_lease_v2_epoch1);
6449 torture_suite_add_1smb2_test(suite, "v2_epoch2", test_lease_v2_epoch2);
6450 torture_suite_add_1smb2_test(suite, "v2_epoch3", test_lease_v2_epoch3);
6451 torture_suite_add_1smb2_test(suite, "v2_complex1", test_lease_v2_complex1);
6452 torture_suite_add_1smb2_test(suite, "v2_complex2", test_lease_v2_complex2);
6453 torture_suite_add_1smb2_test(suite, "v2_rename", test_lease_v2_rename);
6454 torture_suite_add_1smb2_test(suite, "dynamic_share", test_lease_dynamic_share);
6455 torture_suite_add_1smb2_test(suite, "timeout", test_lease_timeout);
6456 torture_suite_add_1smb2_test(suite, "unlink", test_lease_unlink);
6457 torture_suite_add_1smb2_test(suite, "timeout-disconnect", test_lease_timeout_disconnect);
6458 torture_suite_add_1smb2_test(suite, "rename_wait",
6459 test_lease_rename_wait);
6460 torture_suite_add_1smb2_test(suite, "duplicate_create",
6461 test_lease_duplicate_create);
6462 torture_suite_add_1smb2_test(suite, "duplicate_open",
6463 test_lease_duplicate_open);
6464 torture_suite_add_1smb2_test(suite, "v1_bug15148",
6465 test_lease_v1_bug_15148);
6466 torture_suite_add_1smb2_test(suite, "v2_bug15148",
6467 test_lease_v2_bug_15148);
6468 torture_suite_add_1smb2_test(suite, "v2_rename_target_overwrite",
6469 test_lease_v2_rename_target_overwrite);
6470 torture_suite_add_1smb2_test(suite, "initial_delete_tdis",
6471 test_initial_delete_tdis);
6472 torture_suite_add_1smb2_test(suite, "initial_delete_logoff",
6473 test_initial_delete_logoff);
6474 torture_suite_add_1smb2_test(suite, "initial_delete_disconnect",
6475 test_initial_delete_disconnect);
6476 torture_suite_add_2smb2_test(suite, "rename_dir_openfile",
6477 torture_rename_dir_openfile);
6478 torture_suite_add_1smb2_test(suite, "lease-epoch", test_lease_epoch);
6479 torture_suite_add_1smb2_test(suite, "two-leases", test_two_leases);
6480
6481 suite->description = talloc_strdup(suite, "SMB2-LEASE tests");
6482
6483 return suite;
6484 }
6485
6486 enum dirlease_test {
6487 DLT_SETEOF,
6488 DLT_SETDOS,
6489 DLT_BTIME,
6490 DLT_MTIME,
6491 DLT_CTIME,
6492 DLT_ATIME,
6493 };
6494
6495 static void prepare_setinfo(enum dirlease_test t,
6496 union smb_setfileinfo *s,
6497 struct smb2_handle *h)
6498 {
6499 s->generic.in.file.handle = *h;
6500
6501 switch (t) {
6502 case DLT_SETEOF:
6503 s->end_of_file_info.in.size++;
6504 break;
6505 case DLT_SETDOS:
6506 s->basic_info.in.attrib ^= FILE_ATTRIBUTE_HIDDEN;
6507 if (s->basic_info.in.attrib == 0) {
6508 s->basic_info.in.attrib = FILE_ATTRIBUTE_NORMAL;
6509 }
6510 break;
6511 case DLT_BTIME:
6512 s->basic_info.in.create_time++;
6513 break;
6514 case DLT_MTIME:
6515 s->basic_info.in.write_time++;
6516 break;
6517 case DLT_CTIME:
6518 s->basic_info.in.change_time++;
6519 break;
6520 case DLT_ATIME:
6521 s->basic_info.in.access_time++;
6522 break;
6523 default:
6524 break;
6525 }
6526 }
6527
6528 static bool test_dirlease_setinfo(struct torture_context *tctx,
6529 TALLOC_CTX *mem_ctx,
6530 enum dirlease_test t,
6531 struct smb2_tree *tree,
6532 struct smb2_tree *tree2,
6533 const char *dname,
6534 const char *dnamefname,
6535 struct smb2_handle *dirh,
6536 struct smb2_lease *dirlease,
6537 union smb_setfileinfo *s)
6538 {
6539 struct smb2_create c;
6540 struct smb2_lease ls1;
6541 struct smb2_handle h1 = {};
6542 NTSTATUS status;
6543 bool ret = true;
6544
6545 /* 1. Same client */
6546
6547 /* 1.1. Handle with correct parent lease key -> no break */
6548 smb2_lease_v2_create_share(&c, &ls1, false, dnamefname,
6549 smb2_util_share_access("RWD"),
6550 LEASE2, &LEASE1,
6551 smb2_util_lease_state("RHW"), 0);
6552 status = smb2_create(tree, mem_ctx, &c);
6553 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6554 "smb2_create failed\n");
6555 h1 = c.out.file.handle;
6556
6557 prepare_setinfo(t, s, &h1);
6558 status = smb2_setinfo_file(tree, s);
6559 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6560 "smb2_setinfo_filefailed");
6561 CHECK_NO_BREAK(tctx);
6562
6563 smb2_util_close(tree, h1);
6564 ZERO_STRUCT(h1);
6565
6566 /* 1.2. Handle with bad parent lease key -> break */
6567 smb2_lease_v2_create_share(&c, &ls1, false, dnamefname,
6568 smb2_util_share_access("RWD"),
6569 LEASE2, &LEASE3,
6570 smb2_util_lease_state("RHW"), 0);
6571 status = smb2_create(tree, mem_ctx, &c);
6572 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6573 "smb2_create failed\n");
6574 h1 = c.out.file.handle;
6575
6576 prepare_setinfo(t, s, &h1);
6577 status = smb2_setinfo_file(tree, s);
6578 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6579 "smb2_setinfo_filefailed");
6580 CHECK_BREAK_INFO_V2(tree->session->transport,
6581 "RH", "", LEASE1, ++(dirlease->lease_epoch));
6582 torture_reset_lease_break_info(tctx, &lease_break_info);
6583 ret = test_rearm_dirlease(mem_ctx, tctx, tree, dname,
6584 LEASE1, &dirlease->lease_epoch);
6585 torture_assert_goto(tctx, ret == true, ret, done,
6586 "Rearm dirlease failed\n");
6587
6588 smb2_util_close(tree, h1);
6589 ZERO_STRUCT(h1);
6590
6591 /* 1.3. Handle with no parent lease key -> break */
6592 smb2_lease_v2_create_share(&c, &ls1, false, dnamefname,
6593 smb2_util_share_access("RWD"),
6594 LEASE2, NULL,
6595 smb2_util_lease_state("RHW"), 0);
6596 status = smb2_create(tree, mem_ctx, &c);
6597 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6598 "smb2_create failed\n");
6599 h1 = c.out.file.handle;
6600
6601 prepare_setinfo(t, s, &h1);
6602 status = smb2_setinfo_file(tree, s);
6603 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6604 "smb2_setinfo_filefailed");
6605 CHECK_BREAK_INFO_V2(tree->session->transport,
6606 "RH", "", LEASE1, ++(dirlease->lease_epoch));
6607 torture_reset_lease_break_info(tctx, &lease_break_info);
6608 ret = test_rearm_dirlease(mem_ctx, tctx, tree, dname,
6609 LEASE1, &dirlease->lease_epoch);
6610 torture_assert_goto(tctx, ret == true, ret, done,
6611 "Rearm dirlease failed\n");
6612
6613 smb2_util_close(tree, h1);
6614 ZERO_STRUCT(h1);
6615
6616 /* 2. Second client */
6617
6618 /* 2.1. Handle with correct parent lease key -> no break */
6619 smb2_lease_v2_create_share(&c, &ls1, false, dnamefname,
6620 smb2_util_share_access("RWD"),
6621 LEASE2, &LEASE1,
6622 smb2_util_lease_state("RHW"), 0);
6623 status = smb2_create(tree2, mem_ctx, &c);
6624 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6625 "smb2_create failed\n");
6626 h1 = c.out.file.handle;
6627
6628 prepare_setinfo(t, s, &h1);
6629 status = smb2_setinfo_file(tree2, s);
6630 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6631 "smb2_setinfo_filefailed");
6632 CHECK_NO_BREAK(tctx);
6633
6634 smb2_util_close(tree2, h1);
6635 ZERO_STRUCT(h1);
6636
6637 /* 2.2. Handle with bad parent lease key -> break */
6638 smb2_lease_v2_create_share(&c, &ls1, false, dnamefname,
6639 smb2_util_share_access("RWD"),
6640 LEASE2, &LEASE3,
6641 smb2_util_lease_state("RHW"), 0);
6642 status = smb2_create(tree2, mem_ctx, &c);
6643 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6644 "smb2_create failed\n");
6645 h1 = c.out.file.handle;
6646
6647 prepare_setinfo(t, s, &h1);
6648 status = smb2_setinfo_file(tree2, s);
6649 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6650 "smb2_setinfo_filefailed");
6651 CHECK_BREAK_INFO_V2(tree->session->transport,
6652 "RH", "", LEASE1, ++(dirlease->lease_epoch));
6653 torture_reset_lease_break_info(tctx, &lease_break_info);
6654 ret = test_rearm_dirlease(mem_ctx, tctx, tree, dname,
6655 LEASE1, &dirlease->lease_epoch);
6656 torture_assert_goto(tctx, ret == true, ret, done,
6657 "Rearm dirlease failed\n");
6658
6659 smb2_util_close(tree2, h1);
6660 ZERO_STRUCT(h1);
6661
6662 /* 2.3. Handle with no parent lease key -> break */
6663 smb2_lease_v2_create_share(&c, &ls1, false, dnamefname,
6664 smb2_util_share_access("RWD"),
6665 LEASE2, NULL,
6666 smb2_util_lease_state("RHW"), 0);
6667 status = smb2_create(tree2, mem_ctx, &c);
6668 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6669 "smb2_create failed\n");
6670 h1 = c.out.file.handle;
6671
6672 prepare_setinfo(t, s, &h1);
6673 status = smb2_setinfo_file(tree2, s);
6674 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6675 "smb2_setinfo_filefailed");
6676 CHECK_BREAK_INFO_V2(tree->session->transport,
6677 "RH", "", LEASE1, ++(dirlease->lease_epoch));
6678 torture_reset_lease_break_info(tctx, &lease_break_info);
6679 ret = test_rearm_dirlease(mem_ctx, tctx, tree, dname,
6680 LEASE1, &dirlease->lease_epoch);
6681 torture_assert_goto(tctx, ret == true, ret, done,
6682 "Rearm dirlease failed\n");
6683
6684 smb2_util_close(tree2, h1);
6685 ZERO_STRUCT(h1);
6686
6687 done:
6688 if (!smb2_util_handle_empty(h1)) {
6689 smb2_util_close(tree2, h1);
6690 }
6691 return ret;
6692 }
6693
6694 static bool test_dirlease_seteof(struct torture_context *tctx,
6695 struct smb2_tree *tree,
6696 struct smb2_tree *tree2)
6697 {
6698 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6699 struct smb2_create c;
6700 struct smb2_lease dirlease;
6701 struct smb2_handle dirh = {};
6702 const char *dname = "test_dirlease_seteof_dir";
6703 const char *dnamefname = "test_dirlease_seteof_dir\\lease.dat";
6704 union smb_setfileinfo sfinfo = {};
6705 NTSTATUS status;
6706 bool ret = true;
6707
6708 smb2_deltree(tree, dname);
6709
6710 tree->session->transport->lease.handler = torture_lease_handler;
6711 tree->session->transport->lease.private_data = tree;
6712 torture_reset_lease_break_info(tctx, &lease_break_info);
6713
6714 /* Get an RH directory lease on the test directory */
6715
6716 smb2_lease_v2_create_share(&c, &dirlease, true, dname,
6717 smb2_util_share_access("RWD"),
6718 LEASE1, NULL,
6719 smb2_util_lease_state("RHW"), 0);
6720 status = smb2_create(tree, mem_ctx, &c);
6721 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6722 "smb2_create failed\n");
6723 dirh = c.out.file.handle;
6724 CHECK_LEASE_V2(&c, "RH", true, LEASE1, 0, 0, ++dirlease.lease_epoch);
6725
6726 /*
6727 * TEST: test setting EOF
6728 *
6729 * Test from same and second client, and test with correct, bad and no
6730 * parent lease key.
6731 */
6732
6733 sfinfo.generic.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
6734
6735 ret = test_dirlease_setinfo(tctx, mem_ctx, DLT_SETEOF, tree, tree2,
6736 dname, dnamefname,
6737 &dirh, &dirlease, &sfinfo);
6738 torture_assert_goto(tctx, ret, ret, done, "seteof test failed\n");
6739
6740 done:
6741 if (!smb2_util_handle_empty(dirh)) {
6742 smb2_util_close(tree, dirh);
6743 }
6744 smb2_deltree(tree, dname);
6745 talloc_free(mem_ctx);
6746 return ret;
6747 }
6748
6749 static bool test_dirlease_setdos(struct torture_context *tctx,
6750 struct smb2_tree *tree,
6751 struct smb2_tree *tree2)
6752 {
6753 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6754 struct smb2_create c;
6755 struct smb2_lease dirlease;
6756 struct smb2_handle dirh = {};
6757 const char *dname = "test_dirlease_setdos_dir";
6758 const char *dnamefname = "test_dirlease_setdos_dir\\lease.dat";
6759 union smb_setfileinfo sfinfo = {};
6760 NTSTATUS status;
6761 bool ret = true;
6762
6763 smb2_deltree(tree, dname);
6764
6765 tree->session->transport->lease.handler = torture_lease_handler;
6766 tree->session->transport->lease.private_data = tree;
6767 torture_reset_lease_break_info(tctx, &lease_break_info);
6768
6769 /* Get an RH directory lease on the test directory */
6770
6771 smb2_lease_v2_create_share(&c, &dirlease, true, dname,
6772 smb2_util_share_access("RWD"),
6773 LEASE1, NULL,
6774 smb2_util_lease_state("RHW"), 0);
6775 status = smb2_create(tree, mem_ctx, &c);
6776 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6777 "smb2_create failed\n");
6778 dirh = c.out.file.handle;
6779 CHECK_LEASE_V2(&c, "RH", true, LEASE1, 0, 0, ++dirlease.lease_epoch);
6780
6781 /*
6782 * TEST: Test setting DOS attributes
6783 *
6784 * Test from same and second client, and test with correct, bad and no
6785 * parent lease key.
6786 */
6787
6788 sfinfo.basic_info.in.attrib = FILE_ATTRIBUTE_HIDDEN;
6789 sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
6790
6791 ret = test_dirlease_setinfo(tctx, mem_ctx, DLT_SETDOS, tree, tree2,
6792 dname, dnamefname,
6793 &dirh, &dirlease, &sfinfo);
6794 torture_assert_goto(tctx, ret, ret, done, "setdos test failed\n");
6795
6796 done:
6797 if (!smb2_util_handle_empty(dirh)) {
6798 smb2_util_close(tree, dirh);
6799 }
6800 smb2_deltree(tree, dname);
6801 talloc_free(mem_ctx);
6802 return ret;
6803 }
6804
6805 /*
6806 * TEST: Test setting creation date
6807 */
6808 static bool test_dirlease_setbtime(struct torture_context *tctx,
6809 struct smb2_tree *tree,
6810 struct smb2_tree *tree2)
6811 {
6812 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6813 struct smb2_create c;
6814 struct smb2_lease dirlease;
6815 struct smb2_handle dirh = {};
6816 const char *dname = "test_dirlease_setbtime_dir";
6817 const char *dnamefname = "test_dirlease_setbtime_dir\\lease.dat";
6818 union smb_setfileinfo sfinfo = {};
6819 NTSTATUS status;
6820 bool ret = true;
6821
6822 smb2_deltree(tree, dname);
6823
6824 tree->session->transport->lease.handler = torture_lease_handler;
6825 tree->session->transport->lease.private_data = tree;
6826 torture_reset_lease_break_info(tctx, &lease_break_info);
6827
6828 /* Get an RH directory lease on the test directory */
6829
6830 smb2_lease_v2_create_share(&c, &dirlease, true, dname,
6831 smb2_util_share_access("RWD"),
6832 LEASE1, NULL,
6833 smb2_util_lease_state("RHW"), 0);
6834 status = smb2_create(tree, mem_ctx, &c);
6835 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6836 "smb2_create failed\n");
6837 dirh = c.out.file.handle;
6838 CHECK_LEASE_V2(&c, "RH", true, LEASE1, 0, 0, ++dirlease.lease_epoch);
6839
6840 sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
6841 unix_to_nt_time(&sfinfo.basic_info.in.create_time, time(NULL) + 9*30*24*60*60);
6842
6843 ret = test_dirlease_setinfo(tctx, mem_ctx, DLT_BTIME, tree, tree2,
6844 dname, dnamefname,
6845 &dirh, &dirlease, &sfinfo);
6846 torture_assert_goto(tctx, ret, ret, done, "setbtime test failed\n");
6847
6848 done:
6849 if (!smb2_util_handle_empty(dirh)) {
6850 smb2_util_close(tree, dirh);
6851 }
6852 smb2_deltree(tree, dname);
6853 talloc_free(mem_ctx);
6854 return ret;
6855 }
6856
6857 /*
6858 * TEST: Test setting modification date
6859 */
6860 static bool test_dirlease_setmtime(struct torture_context *tctx,
6861 struct smb2_tree *tree,
6862 struct smb2_tree *tree2)
6863 {
6864 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6865 struct smb2_create c;
6866 struct smb2_lease dirlease;
6867 struct smb2_handle dirh = {};
6868 const char *dname = "test_dirlease_setmtime_dir";
6869 const char *dnamefname = "test_dirlease_setmtime_dir\\lease.dat";
6870 union smb_setfileinfo sfinfo = {};
6871 NTSTATUS status;
6872 bool ret = true;
6873
6874 smb2_deltree(tree, dname);
6875
6876 tree->session->transport->lease.handler = torture_lease_handler;
6877 tree->session->transport->lease.private_data = tree;
6878 torture_reset_lease_break_info(tctx, &lease_break_info);
6879
6880 /* Get an RH directory lease on the test directory */
6881
6882 smb2_lease_v2_create_share(&c, &dirlease, true, dname,
6883 smb2_util_share_access("RWD"),
6884 LEASE1, NULL,
6885 smb2_util_lease_state("RHW"), 0);
6886 status = smb2_create(tree, mem_ctx, &c);
6887 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6888 "smb2_create failed\n");
6889 dirh = c.out.file.handle;
6890 CHECK_LEASE_V2(&c, "RH", true, LEASE1, 0, 0, ++dirlease.lease_epoch);
6891
6892 sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
6893 unix_to_nt_time(&sfinfo.basic_info.in.create_time, time(NULL) + 9*30*24*60*60);
6894
6895 ret = test_dirlease_setinfo(tctx, mem_ctx, DLT_MTIME, tree, tree2,
6896 dname, dnamefname,
6897 &dirh, &dirlease, &sfinfo);
6898 torture_assert_goto(tctx, ret, ret, done, "setmtime test failed\n");
6899
6900 done:
6901 if (!smb2_util_handle_empty(dirh)) {
6902 smb2_util_close(tree, dirh);
6903 }
6904 smb2_deltree(tree, dname);
6905 talloc_free(mem_ctx);
6906 return ret;
6907 }
6908
6909 /*
6910 * TEST: Test setting inode change date
6911 */
6912 static bool test_dirlease_setctime(struct torture_context *tctx,
6913 struct smb2_tree *tree,
6914 struct smb2_tree *tree2)
6915 {
6916 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6917 struct smb2_create c;
6918 struct smb2_lease dirlease;
6919 struct smb2_handle dirh = {};
6920 const char *dname = "test_dirlease_setctime_dir";
6921 const char *dnamefname = "test_dirlease_setctime_dir\\lease.dat";
6922 union smb_setfileinfo sfinfo = {};
6923 NTSTATUS status;
6924 bool ret = true;
6925
6926 smb2_deltree(tree, dname);
6927
6928 tree->session->transport->lease.handler = torture_lease_handler;
6929 tree->session->transport->lease.private_data = tree;
6930 torture_reset_lease_break_info(tctx, &lease_break_info);
6931
6932 /* Get an RH directory lease on the test directory */
6933
6934 smb2_lease_v2_create_share(&c, &dirlease, true, dname,
6935 smb2_util_share_access("RWD"),
6936 LEASE1, NULL,
6937 smb2_util_lease_state("RHW"), 0);
6938 status = smb2_create(tree, mem_ctx, &c);
6939 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6940 "smb2_create failed\n");
6941 dirh = c.out.file.handle;
6942 CHECK_LEASE_V2(&c, "RH", true, LEASE1, 0, 0, ++dirlease.lease_epoch);
6943
6944 sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
6945 unix_to_nt_time(&sfinfo.basic_info.in.change_time, time(NULL) + 9*30*24*60*60);
6946
6947 ret = test_dirlease_setinfo(tctx, mem_ctx, DLT_CTIME, tree, tree2,
6948 dname, dnamefname,
6949 &dirh, &dirlease, &sfinfo);
6950 torture_assert_goto(tctx, ret, ret, done, "setctime test failed\n");
6951
6952 done:
6953 if (!smb2_util_handle_empty(dirh)) {
6954 smb2_util_close(tree, dirh);
6955 }
6956 smb2_deltree(tree, dname);
6957 talloc_free(mem_ctx);
6958 return ret;
6959 }
6960
6961 /*
6962 * TEST: Test setting last access date
6963 */
6964 static bool test_dirlease_setatime(struct torture_context *tctx,
6965 struct smb2_tree *tree,
6966 struct smb2_tree *tree2)
6967 {
6968 TALLOC_CTX *mem_ctx = talloc_new(tctx);
6969 struct smb2_create c;
6970 struct smb2_lease dirlease;
6971 struct smb2_handle dirh = {};
6972 const char *dname = "test_dirlease_setatime_dir";
6973 const char *dnamefname = "test_dirlease_setatime_dir\\lease.dat";
6974 union smb_setfileinfo sfinfo = {};
6975 NTSTATUS status;
6976 bool ret = true;
6977
6978 smb2_deltree(tree, dname);
6979
6980 tree->session->transport->lease.handler = torture_lease_handler;
6981 tree->session->transport->lease.private_data = tree;
6982 torture_reset_lease_break_info(tctx, &lease_break_info);
6983
6984 /* Get an RH directory lease on the test directory */
6985
6986 smb2_lease_v2_create_share(&c, &dirlease, true, dname,
6987 smb2_util_share_access("RWD"),
6988 LEASE1, NULL,
6989 smb2_util_lease_state("RHW"), 0);
6990 status = smb2_create(tree, mem_ctx, &c);
6991 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
6992 "smb2_create failed\n");
6993 dirh = c.out.file.handle;
6994 CHECK_LEASE_V2(&c, "RH", true, LEASE1, 0, 0, ++dirlease.lease_epoch);
6995
6996 sfinfo.generic.level = RAW_SFILEINFO_BASIC_INFORMATION;
6997 unix_to_nt_time(&sfinfo.basic_info.in.access_time, time(NULL) + 9*30*24*60*60);
6998
6999 ret = test_dirlease_setinfo(tctx, mem_ctx, DLT_ATIME, tree, tree2,
7000 dname, dnamefname,
7001 &dirh, &dirlease, &sfinfo);
7002 torture_assert_goto(tctx, ret, ret, done, "setctime test failed\n");
7003
7004 done:
7005 if (!smb2_util_handle_empty(dirh)) {
7006 smb2_util_close(tree, dirh);
7007 }
7008 smb2_deltree(tree, dname);
7009 talloc_free(mem_ctx);
7010 return ret;
7011 }
7012
7013 #define DLEASE1 0x0000000000000001ull
7014 #define DLEASE2 0x0000000000000002ull
7015 #define DLEASE3 0x0000000000000003ull
7016
7017 static struct dlt_rename {
7018 const char *testname;
7019 bool expect_srcdir_break;
7020 bool expect_dstdir_break;
7021 const char *srcdir;
7022 const char *dstdir;
7023 uint64_t srcdir_leasekey;
7024 uint64_t dstdir_leasekey;
7025 uint64_t parent_leasekey;
7026 const char *srcfname;
7027 const char *dstfname;
7028 } dlt_renames[] = {
7029 {
7030 .testname = "samedir-correct-parent-leaskey",
7031 .expect_srcdir_break = false,
7032 .expect_dstdir_break = false,
7033 .srcdir = "test_dirlease_rename_dir",
7034 .dstdir = "test_dirlease_rename_dir",
7035 .srcdir_leasekey = DLEASE1,
7036 .dstdir_leasekey = DLEASE2,
7037 .parent_leasekey = DLEASE1,
7038 .srcfname = "test_dirlease_rename_dir\\srcfile",
7039 .dstfname = "test_dirlease_rename_dir\\dstfile",
7040 }, {
7041 .testname = "samedir-wrong-parent-leaskey",
7042 .expect_srcdir_break = true,
7043 .expect_dstdir_break = false,
7044 .srcdir = "test_dirlease_rename_dir",
7045 .dstdir = "test_dirlease_rename_dir",
7046 .srcdir_leasekey = DLEASE1,
7047 .dstdir_leasekey = DLEASE2,
7048 .parent_leasekey = DLEASE3,
7049 .srcfname = "test_dirlease_rename_dir\\srcfile",
7050 .dstfname = "test_dirlease_rename_dir\\dstfile",
7051 }, {
7052 .testname = "samedir-no-parent-leaskey",
7053 .expect_srcdir_break = true,
7054 .expect_dstdir_break = false,
7055 .srcdir = "test_dirlease_rename_dir",
7056 .dstdir = "test_dirlease_rename_dir",
7057 .srcdir_leasekey = DLEASE1,
7058 .dstdir_leasekey = DLEASE2,
7059 .parent_leasekey = 0,
7060 .srcfname = "test_dirlease_rename_dir\\srcfile",
7061 .dstfname = "test_dirlease_rename_dir\\dstfile",
7062 }, {
7063 .testname = "otherdir-correct-srcparent-leaskey",
7064 .expect_srcdir_break = false,
7065 .expect_dstdir_break = true,
7066 .srcdir = "test_dirlease_rename_dir",
7067 .dstdir = "test_dirlease_rename_dir2",
7068 .srcdir_leasekey = DLEASE1,
7069 .dstdir_leasekey = DLEASE2,
7070 .parent_leasekey = DLEASE1,
7071 .srcfname = "test_dirlease_rename_dir\\srcfile",
7072 .dstfname = "test_dirlease_rename_dir2\\dstfile",
7073 }, {
7074 .testname = "otherdir-correct-dstparent-leaskey",
7075 .expect_srcdir_break = true,
7076 .expect_dstdir_break = false,
7077 .srcdir = "test_dirlease_rename_dir",
7078 .dstdir = "test_dirlease_rename_dir2",
7079 .srcdir_leasekey = DLEASE1,
7080 .dstdir_leasekey = DLEASE2,
7081 .parent_leasekey = DLEASE2,
7082 .srcfname = "test_dirlease_rename_dir\\srcfile",
7083 .dstfname = "test_dirlease_rename_dir2\\dstfile",
7084 }, {
7085 .testname = "otherdir-wrong-parent-leaskey",
7086 .expect_srcdir_break = true,
7087 .expect_dstdir_break = true,
7088 .srcdir = "test_dirlease_rename_dir",
7089 .dstdir = "test_dirlease_rename_dir2",
7090 .srcdir_leasekey = DLEASE1,
7091 .dstdir_leasekey = DLEASE2,
7092 .parent_leasekey = DLEASE3,
7093 .srcfname = "test_dirlease_rename_dir\\srcfile",
7094 .dstfname = "test_dirlease_rename_dir2\\dstfile",
7095 }, {
7096 .testname = "otherdir-no-parent-leaskey",
7097 .expect_srcdir_break = true,
7098 .expect_dstdir_break = true,
7099 .srcdir = "test_dirlease_rename_dir",
7100 .dstdir = "test_dirlease_rename_dir2",
7101 .srcdir_leasekey = DLEASE1,
7102 .dstdir_leasekey = DLEASE2,
7103 .parent_leasekey = 0,
7104 .srcfname = "test_dirlease_rename_dir\\srcfile",
7105 .dstfname = "test_dirlease_rename_dir2\\dstfile",
7106 }, {
7107 .testname = NULL,
7108 }
7109 };
7110
7111 static bool test_rename_one(struct torture_context *tctx,
7112 struct smb2_tree *tree,
7113 struct dlt_rename *t)
7114 {
7115 TALLOC_CTX *mem_ctx = talloc_new(tctx);
7116 struct smb2_create c;
7117 struct smb2_lease dirlease1;
7118 struct smb2_lease dirlease2;
7119 struct smb2_handle dirh1 = {};
7120 struct smb2_handle dirh2 = {};
7121 struct smb2_lease lease1;
7122 struct smb2_handle h1 = {};
7123 struct smb2_lease_break_ack ack = {};
7124 bool samedir = strequal(t->srcdir, t->dstdir);
7125 union smb_setfileinfo sfinfo = {};
7126 NTSTATUS status;
7127 bool ret = true;
7128
7129 torture_comment(tctx, "\nRename subtest: %s\n"
7130 "==================================\n",
7131 t->testname);
7132
7133 smb2_deltree(tree, t->srcdir);
7134 smb2_deltree(tree, t->dstdir);
7135 torture_reset_lease_break_info(tctx, &lease_break_info);
7136
7137
7138 /* Get an RH directory lease on the src directory */
7139 smb2_lease_v2_create_share(&c, &dirlease1, true, t->srcdir,
7140 smb2_util_share_access("RWD"),
7141 t->srcdir_leasekey, NULL,
7142 smb2_util_lease_state("RHW"), 0);
7143 c.in.desired_access &= ~DELETE_ACCESS;
7144 status = smb2_create(tree, mem_ctx, &c);
7145 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7146 "smb2_create failed\n");
7147 dirh1 = c.out.file.handle;
7148 CHECK_LEASE_V2(&c, "RH", true, t->srcdir_leasekey, 0, 0, ++dirlease1.lease_epoch);
7149
7150 if (!samedir) {
7151 /* Get an RH directory lease on the dst directory */
7152 smb2_lease_v2_create_share(&c, &dirlease2, true, t->dstdir,
7153 smb2_util_share_access("RWD"),
7154 t->dstdir_leasekey, NULL,
7155 smb2_util_lease_state("RHW"), 0);
7156 c.in.desired_access &= ~DELETE_ACCESS;
7157 status = smb2_create(tree, mem_ctx, &c);
7158 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7159 "smb2_create failed\n");
7160 dirh2 = c.out.file.handle;
7161 CHECK_LEASE_V2(&c, "RH", true, t->dstdir_leasekey, 0, 0, ++dirlease2.lease_epoch);
7162 }
7163
7164 /* Create the to be renamed file */
7165 smb2_lease_v2_create_share(&c, &lease1, false, t->srcfname,
7166 smb2_util_share_access("RWD"),
7167 LEASE4, &t->srcdir_leasekey,
7168 smb2_util_lease_state("RHW"),
7169 0x33);
7170 status = smb2_create(tree, mem_ctx, &c);
7171 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7172 "smb2_create failed\n");
7173 h1 = c.out.file.handle;
7174 smb2_util_close(tree, h1);
7175 ZERO_STRUCT(h1);
7176
7177 /* Open the testfile, possibly with a bad parent leasekey */
7178 smb2_lease_v2_create_share(&c, &lease1, false, t->srcfname,
7179 smb2_util_share_access("RWD"),
7180 LEASE4,
7181 t->parent_leasekey != 0 ? &t->parent_leasekey : NULL,
7182 smb2_util_lease_state("RHW"),
7183 0x33);
7184 status = smb2_create(tree, mem_ctx, &c);
7185 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7186 "smb2_create failed\n");
7187 h1 = c.out.file.handle;
7188
7189 sfinfo.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
7190 sfinfo.generic.in.file.handle = h1;
7191 sfinfo.rename_information.in.new_name = t->dstfname;
7192
7193 status = smb2_setinfo_file(tree, &sfinfo);
7194 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7195 "smb2_setinfo_file failed\n");
7196 if (t->expect_srcdir_break) {
7197 /* Delay the ack in order to be able to possibly process two breaks */
7198 lease_break_info.lease_skip_ack = true;
7199 CHECK_BREAK_INFO_V2(tree->session->transport,
7200 "RH", "",
7201 t->srcdir_leasekey,
7202 ++dirlease1.lease_epoch);
7203 ack.in.lease.lease_key = lease_break_info.lease_break.current_lease.lease_key;
7204 ack.in.lease.lease_state = lease_break_info.lease_break.new_lease_state;
7205 torture_reset_lease_break_info(tctx, &lease_break_info);
7206 if (!t->expect_dstdir_break) {
7207 CHECK_NO_BREAK(tctx);
7208 }
7209 }
7210 if (t->expect_dstdir_break) {
7211 CHECK_BREAK_INFO_V2(tree->session->transport,
7212 "RH", "",
7213 t->dstdir_leasekey,
7214 ++dirlease2.lease_epoch);
7215 torture_reset_lease_break_info(tctx, &lease_break_info);
7216 if (!t->expect_srcdir_break) {
7217 CHECK_NO_BREAK(tctx);
7218 }
7219 }
7220 if (!t->expect_srcdir_break && !t->expect_dstdir_break) {
7221 CHECK_NO_BREAK(tctx);
7222 }
7223
7224 if (t->expect_srcdir_break) {
7225 /* ack the first lease break. */
7226 status = smb2_lease_break_ack(tree, &ack);
7227 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7228 "smb2_lease_break_ack failed\n");
7229 CHECK_LEASE_BREAK_ACK(&ack, "", t->srcdir_leasekey);
7230 }
7231
7232
7233 done:
7234 if (!smb2_util_handle_empty(h1)) {
7235 smb2_util_close(tree, h1);
7236 }
7237 if (!smb2_util_handle_empty(dirh1)) {
7238 smb2_util_close(tree, dirh1);
7239 }
7240 if (!smb2_util_handle_empty(dirh2)) {
7241 smb2_util_close(tree, dirh2);
7242 }
7243 smb2_deltree(tree, t->srcdir);
7244 smb2_deltree(tree, t->dstdir);
7245 return ret;
7246 }
7247
7248 static bool test_rename(struct torture_context *tctx,
7249 struct smb2_tree *tree)
7250 {
7251 struct dlt_rename *t = NULL;
7252 bool ret = true;
7253
7254 tree->session->transport->lease.handler = torture_lease_handler;
7255 tree->session->transport->lease.private_data = tree;
7256 torture_reset_lease_break_info(tctx, &lease_break_info);
7257
7258 for (t = dlt_renames; t->testname != NULL; t++) {
7259 ret = test_rename_one(tctx, tree, t);
7260 torture_assert_goto(tctx, ret, ret, done,
7261 talloc_asprintf(tctx, "%s failed\n",
7262 t->testname));
7263 }
7264
7265 done:
7266 return ret;
7267 }
7268
7269 static bool test_rename_dst_parent(struct torture_context *tctx,
7270 struct smb2_tree *tree)
7271 {
7272 TALLOC_CTX *mem_ctx = talloc_new(tctx);
7273 const char *srcdir = "test_rename_dst_parent_src";
7274 const char *srcfile = "test_rename_dst_parent_src\\file";
7275 const char *dstdir = "test_rename_dst_parent_dst";
7276 const char *dstfile = "test_rename_dst_parent_dst\\file";
7277 struct smb2_create create_dp;
7278 struct smb2_lease lease_dp;
7279 struct smb2_handle h1 = {};
7280 struct smb2_handle handle_sf = {};
7281 struct smb2_handle handle_dp = {};
7282 union smb_setfileinfo sfinfo = {};
7283 NTSTATUS status;
7284 bool ret = true;
7285
7286 tree->session->transport->lease.handler = torture_lease_handler;
7287 tree->session->transport->lease.private_data = tree;
7288 torture_reset_lease_break_info(tctx, &lease_break_info);
7289
7290 status = torture_smb2_testdir(tree, srcdir, &h1);
7291 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7292 "torture_smb2_testdir\n");
7293 smb2_util_close(tree, h1);
7294
7295 status = torture_smb2_testdir(tree, dstdir, &h1);
7296 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7297 "torture_smb2_testdir\n");
7298 smb2_util_close(tree, h1);
7299
7300 status = smb2_create_simple_file(tctx, tree, srcfile, &handle_sf);
7301 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7302 "smb2_create_simple_file\n");
7303
7304 /* Get a RH lease on the destination parent */
7305
7306 smb2_lease_v2_create_share(&create_dp, &lease_dp, true, dstdir,
7307 smb2_util_share_access("RWD"),
7308 0x01, NULL,
7309 smb2_util_lease_state("RH"), 0);
7310 create_dp.in.desired_access = DELETE_ACCESS;
7311 status = smb2_create(tree, mem_ctx, &create_dp);
7312 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7313 "smb2_create failed\n");
7314 handle_dp = create_dp.out.file.handle;
7315 CHECK_LEASE_V2(&create_dp, "RH", true, 0x01, 0, 0, 1);
7316
7317 /*
7318 * Rename, expect break on dst parent. As we'll be keeping our
7319 * conflicting open, the rename should fail.
7320 */
7321
7322 sfinfo.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
7323 sfinfo.generic.in.file.handle = handle_sf;
7324 sfinfo.rename_information.in.new_name = dstfile;
7325
7326 status = smb2_setinfo_file(tree, &sfinfo);
7327 torture_assert_ntstatus_equal_goto(
7328 tctx, status, NT_STATUS_SHARING_VIOLATION, ret, done,
7329 "smb2_setinfo_file\n");
7330
7331 CHECK_BREAK_INFO_V2(tree->session->transport,
7332 "RH", "R", 0x01, 2);
7333
7334 /* Upgrade lease to "RH" */
7335
7336 smb2_lease_v2_create_share(&create_dp, &lease_dp, true, dstdir,
7337 smb2_util_share_access("RWD"),
7338 0x01, NULL,
7339 smb2_util_lease_state("RH"), 0);
7340 create_dp.in.desired_access = DELETE_ACCESS;
7341 status = smb2_create(tree, mem_ctx, &create_dp);
7342 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7343 "smb2_create failed\n");
7344 h1 = create_dp.out.file.handle;
7345 smb2_util_close(tree, h1);
7346 CHECK_LEASE_V2(&create_dp, "RH", true, 0x01, 0, 0, 3);
7347
7348 /*
7349 * Rename, expect break on dst parent. Let the break
7350 * handler close the handle so the rename should pass.
7351 */
7352
7353 torture_reset_lease_break_info(tctx, &lease_break_info);
7354 lease_break_info.lease_handle = handle_dp;
7355
7356 sfinfo.generic.level = RAW_SFILEINFO_RENAME_INFORMATION;
7357 sfinfo.generic.in.file.handle = handle_sf;
7358 sfinfo.rename_information.in.new_name = dstfile;
7359
7360 status = smb2_setinfo_file(tree, &sfinfo);
7361 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7362 "smb2_setinfo_file failed\n");
7363
7364 CHECK_LEASE_BREAK(&lease_break_info.lease_break, "RH", "R", 0x01);
7365
7366 done:
7367 if (!smb2_util_handle_empty(handle_sf)) {
7368 smb2_util_close(tree, handle_sf);
7369 }
7370 if (!smb2_util_handle_empty(handle_dp)) {
7371 smb2_util_close(tree, handle_dp);
7372 }
7373 smb2_deltree(tree, srcdir);
7374 smb2_deltree(tree, dstdir);
7375 return ret;
7376 }
7377
7378 static bool test_overwrite(struct torture_context *tctx,
7379 struct smb2_tree *tree,
7380 struct smb2_tree *tree2)
7381 {
7382 struct smb2_create c = {};
7383 struct smb2_lease dirlease1 = {};
7384 struct smb2_handle dirh1 = {};
7385 struct smb2_lease lease1 = {};
7386 struct smb2_handle h1 = {};
7387 struct smb2_handle h2 = {};
7388 struct smb2_request *req = NULL;
7389 struct smb2_lease_break_ack ack = {};
7390 struct smb2_lease *expected_lease1 = NULL;
7391 struct smb2_lease *expected_lease2 = NULL;
7392 uint64_t expected_leasekey1;
7393 uint64_t expected_leasekey2;
7394 const char *dname = "test_overwrite_dir";
7395 const char *fname = "test_overwrite_dir\\fname";
7396 int n;
7397 NTSTATUS status;
7398 bool ret = true;
7399
7400 tree->session->transport->lease.handler = torture_lease_handler;
7401 tree->session->transport->lease.private_data = tree;
7402 torture_reset_lease_break_info(tctx, &lease_break_info);
7403 lease_break_info.lease_skip_ack = true;
7404
7405 n = smb2_deltree(tree, dname);
7406 torture_assert_goto(tctx, n != -1, ret, done, "smb2_deltree failed\n");
7407
7408 /* Get an RH directory lease on the directory */
7409 smb2_lease_v2_create_share(&c, &dirlease1, true, dname,
7410 smb2_util_share_access("RWD"),
7411 LEASE1, NULL,
7412 smb2_util_lease_state("RH"), 0);
7413 c.in.desired_access &= ~DELETE_ACCESS;
7414 status = smb2_create(tree, tree, &c);
7415 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7416 "smb2_create failed\n");
7417 dirh1 = c.out.file.handle;
7418 CHECK_LEASE_V2(&c, "RH", true, LEASE1, 0, 0, ++dirlease1.lease_epoch);
7419
7420 /* Create a file with parent leasekey set*/
7421 smb2_lease_v2_create_share(&c, &lease1, false, fname,
7422 smb2_util_share_access("RWD"),
7423 LEASE2, &LEASE1,
7424 smb2_util_lease_state("RH"), 0);
7425 c.in.desired_access &= ~DELETE_ACCESS;
7426 status = smb2_create(tree, tree, &c);
7427 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7428 "smb2_create failed\n");
7429 h1 = c.out.file.handle;
7430 CHECK_LEASE_V2(&c, "RH", true, LEASE2,
7431 SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET, LEASE1,
7432 ++lease1.lease_epoch);
7433
7434 CHECK_NO_BREAK(tctx);
7435
7436 /* Second client opens with overwrite disposition */
7437 c = (struct smb2_create) {
7438 .in.desired_access = SEC_FILE_READ_DATA,
7439 .in.share_access = NTCREATEX_SHARE_ACCESS_MASK,
7440 .in.create_disposition = NTCREATEX_DISP_OVERWRITE,
7441 .in.file_attributes = FILE_ATTRIBUTE_ARCHIVE,
7442 .in.fname = fname,
7443 };
7444 req = smb2_create_send(tree2, &c);
7445 torture_assert(tctx, req != NULL, "smb2_create_send failed\n");
7446 torture_assert(tctx, req->state == SMB2_REQUEST_RECV, "req2 pending");
7447
7448 torture_wait_for_lease_break(tctx);
7449
7450 /*
7451 * Expect two lease breaks (dir and file) and accept the lease breaks in
7452 * any order.
7453 */
7454 ack.in.lease.lease_key = lease_break_info.lease_break.current_lease.lease_key;
7455 ack.in.lease.lease_state = lease_break_info.lease_break.new_lease_state;
7456 if (ack.in.lease.lease_key.data[0] == LEASE1) {
7457 expected_leasekey1 = LEASE1;
7458 expected_lease1 = &dirlease1;
7459 expected_leasekey2 = LEASE2;
7460 expected_lease2 = &lease1;
7461 } else {
7462 expected_leasekey1 = LEASE2;
7463 expected_lease1 = &lease1;
7464 expected_leasekey2 = LEASE1;
7465 expected_lease2 = &dirlease1;
7466 }
7467
7468 /* Break 1 */
7469
7470 CHECK_BREAK_INFO_V2_NOWAIT(tree->session->transport,
7471 "RH", "", expected_leasekey1,
7472 ++(expected_lease1->lease_epoch));
7473
7474 torture_reset_lease_break_info(tctx, &lease_break_info);
7475 lease_break_info.lease_skip_ack = true;
7476
7477 status = smb2_lease_break_ack(tree, &ack);
7478 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7479 "smb2_lease_break_ack failed\n");
7480 CHECK_LEASE_BREAK_ACK(&ack, "", expected_leasekey1);
7481
7482 /* Break 2 */
7483
7484 CHECK_BREAK_INFO_V2(tree->session->transport,
7485 "RH", "", expected_leasekey2,
7486 ++(expected_lease2->lease_epoch));
7487 ack.in.lease.lease_key = lease_break_info.lease_break.current_lease.lease_key;
7488 ack.in.lease.lease_state = lease_break_info.lease_break.new_lease_state;
7489
7490 torture_reset_lease_break_info(tctx, &lease_break_info);
7491 lease_break_info.lease_skip_ack = true;
7492
7493 status = smb2_lease_break_ack(tree, &ack);
7494 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7495 "smb2_lease_break_ack failed\n");
7496 CHECK_LEASE_BREAK_ACK(&ack, "", expected_leasekey2);
7497
7498 status = smb2_create_recv(req, tctx, &c);
7499 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7500 "smb2_create_recv failed\n");
7501 h2 = c.out.file.handle;
7502
7503 done:
7504 if (!smb2_util_handle_empty(h1)) {
7505 smb2_util_close(tree, h1);
7506 }
7507 if (!smb2_util_handle_empty(h2)) {
7508 smb2_util_close(tree2, h2);
7509 }
7510 if (!smb2_util_handle_empty(dirh1)) {
7511 smb2_util_close(tree, dirh1);
7512 }
7513
7514 n = smb2_deltree(tree, dname);
7515 torture_assert(tctx, n != -1, "smb2_deltree failed\n");
7516 return ret;
7517 }
7518
7519 static struct dlt_hardlink {
7520 const char *testname;
7521 bool expect_srcdir_break;
7522 bool expect_dstdir_break;
7523 const char *srcdir;
7524 const char *dstdir;
7525 uint64_t srcdir_leasekey;
7526 uint64_t dstdir_leasekey;
7527 uint64_t parent_leasekey;
7528 const char *srcfname;
7529 const char *dstfname;
7530 } dlt_hardlinks[] = {
7531 {
7532 .testname = "samedir-correct-parent-leaskey",
7533 .expect_srcdir_break = false,
7534 .expect_dstdir_break = false,
7535 .srcdir = "test_dirlease_rename_dir",
7536 .dstdir = "test_dirlease_rename_dir",
7537 .srcdir_leasekey = DLEASE1,
7538 .dstdir_leasekey = DLEASE2,
7539 .parent_leasekey = DLEASE1,
7540 .srcfname = "test_dirlease_rename_dir\\srcfile",
7541 .dstfname = "test_dirlease_rename_dir\\dstfile",
7542 }, {
7543 .testname = "samedir-wrong-parent-leaskey",
7544 .expect_srcdir_break = true,
7545 .expect_dstdir_break = false,
7546 .srcdir = "test_dirlease_rename_dir",
7547 .dstdir = "test_dirlease_rename_dir",
7548 .srcdir_leasekey = DLEASE1,
7549 .dstdir_leasekey = DLEASE2,
7550 .parent_leasekey = DLEASE3,
7551 .srcfname = "test_dirlease_rename_dir\\srcfile",
7552 .dstfname = "test_dirlease_rename_dir\\dstfile",
7553 }, {
7554 .testname = "samedir-no-parent-leaskey",
7555 .expect_srcdir_break = true,
7556 .expect_dstdir_break = false,
7557 .srcdir = "test_dirlease_rename_dir",
7558 .dstdir = "test_dirlease_rename_dir",
7559 .srcdir_leasekey = DLEASE1,
7560 .dstdir_leasekey = DLEASE2,
7561 .parent_leasekey = 0,
7562 .srcfname = "test_dirlease_rename_dir\\srcfile",
7563 .dstfname = "test_dirlease_rename_dir\\dstfile",
7564 }, {
7565 .testname = "otherdir-correct-srcparent-leaskey",
7566 .expect_srcdir_break = false,
7567 .expect_dstdir_break = true,
7568 .srcdir = "test_dirlease_rename_dir",
7569 .dstdir = "test_dirlease_rename_dir2",
7570 .srcdir_leasekey = DLEASE1,
7571 .dstdir_leasekey = DLEASE2,
7572 .parent_leasekey = DLEASE1,
7573 .srcfname = "test_dirlease_rename_dir\\srcfile",
7574 .dstfname = "test_dirlease_rename_dir2\\dstfile",
7575 }, {
7576 .testname = "otherdir-correct-dstparent-leaskey",
7577 .expect_srcdir_break = false,
7578 .expect_dstdir_break = false,
7579 .srcdir = "test_dirlease_rename_dir",
7580 .dstdir = "test_dirlease_rename_dir2",
7581 .srcdir_leasekey = DLEASE1,
7582 .dstdir_leasekey = DLEASE2,
7583 .parent_leasekey = DLEASE2,
7584 .srcfname = "test_dirlease_rename_dir\\srcfile",
7585 .dstfname = "test_dirlease_rename_dir2\\dstfile",
7586 }, {
7587 .testname = "otherdir-wrong-parent-leaskey",
7588 .expect_srcdir_break = false,
7589 .expect_dstdir_break = true,
7590 .srcdir = "test_dirlease_rename_dir",
7591 .dstdir = "test_dirlease_rename_dir2",
7592 .srcdir_leasekey = DLEASE1,
7593 .dstdir_leasekey = DLEASE2,
7594 .parent_leasekey = DLEASE3,
7595 .srcfname = "test_dirlease_rename_dir\\srcfile",
7596 .dstfname = "test_dirlease_rename_dir2\\dstfile",
7597 }, {
7598 .testname = "otherdir-no-parent-leaskey",
7599 .expect_srcdir_break = false,
7600 .expect_dstdir_break = true,
7601 .srcdir = "test_dirlease_rename_dir",
7602 .dstdir = "test_dirlease_rename_dir2",
7603 .srcdir_leasekey = DLEASE1,
7604 .dstdir_leasekey = DLEASE2,
7605 .parent_leasekey = 0,
7606 .srcfname = "test_dirlease_rename_dir\\srcfile",
7607 .dstfname = "test_dirlease_rename_dir2\\dstfile",
7608 }, {
7609 .testname = NULL,
7610 }
7611 };
7612
7613 static bool test_hardlink_one(struct torture_context *tctx,
7614 struct smb2_tree *tree,
7615 struct dlt_hardlink *t)
7616 {
7617 TALLOC_CTX *mem_ctx = talloc_new(tctx);
7618 struct smb2_create c;
7619 struct smb2_lease dirlease1;
7620 struct smb2_lease dirlease2;
7621 struct smb2_handle dirh1 = {};
7622 struct smb2_handle dirh2 = {};
7623 struct smb2_lease lease1;
7624 struct smb2_handle h1 = {};
7625 struct smb2_lease_break_ack ack = {};
7626 bool samedir = strequal(t->srcdir, t->dstdir);
7627 union smb_setfileinfo sfinfo = {};
7628 NTSTATUS status;
7629 bool ret = true;
7630
7631 torture_comment(tctx, "\nHardlink subtest: %s\n"
7632 "==================================\n",
7633 t->testname);
7634
7635 smb2_deltree(tree, t->srcdir);
7636 smb2_deltree(tree, t->dstdir);
7637 torture_reset_lease_break_info(tctx, &lease_break_info);
7638
7639
7640 /* Get an RH directory lease on the src directory */
7641 smb2_lease_v2_create_share(&c, &dirlease1, true, t->srcdir,
7642 smb2_util_share_access("RWD"),
7643 t->srcdir_leasekey, NULL,
7644 smb2_util_lease_state("RHW"), 0);
7645 c.in.desired_access &= ~DELETE_ACCESS;
7646 status = smb2_create(tree, mem_ctx, &c);
7647 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7648 "smb2_create failed\n");
7649 dirh1 = c.out.file.handle;
7650 CHECK_LEASE_V2(&c, "RH", true, t->srcdir_leasekey, 0, 0, ++dirlease1.lease_epoch);
7651
7652 if (!samedir) {
7653 /* Get an RH directory lease on the dst directory */
7654 smb2_lease_v2_create_share(&c, &dirlease2, true, t->dstdir,
7655 smb2_util_share_access("RWD"),
7656 t->dstdir_leasekey, NULL,
7657 smb2_util_lease_state("RHW"), 0);
7658 c.in.desired_access &= ~DELETE_ACCESS;
7659 status = smb2_create(tree, mem_ctx, &c);
7660 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7661 "smb2_create failed\n");
7662 dirh2 = c.out.file.handle;
7663 CHECK_LEASE_V2(&c, "RH", true, t->dstdir_leasekey, 0, 0, ++dirlease2.lease_epoch);
7664 }
7665
7666 /* Create the to be hardlinkd file */
7667 smb2_lease_v2_create_share(&c, &lease1, false, t->srcfname,
7668 smb2_util_share_access("RWD"),
7669 LEASE4, &t->srcdir_leasekey,
7670 smb2_util_lease_state("RHW"),
7671 0x33);
7672 status = smb2_create(tree, mem_ctx, &c);
7673 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7674 "smb2_create failed\n");
7675 h1 = c.out.file.handle;
7676 smb2_util_close(tree, h1);
7677 ZERO_STRUCT(h1);
7678
7679 /* Open the testfile, possibly with a bad parent leasekey */
7680 smb2_lease_v2_create_share(&c, &lease1, false, t->srcfname,
7681 smb2_util_share_access("RWD"),
7682 LEASE4,
7683 t->parent_leasekey != 0 ? &t->parent_leasekey : NULL,
7684 smb2_util_lease_state("RHW"),
7685 0x33);
7686 status = smb2_create(tree, mem_ctx, &c);
7687 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7688 "smb2_create failed\n");
7689 h1 = c.out.file.handle;
7690
7691 sfinfo.generic.level = RAW_SFILEINFO_LINK_INFORMATION;
7692 sfinfo.generic.in.file.handle = h1;
7693 sfinfo.link_information.in.new_name = t->dstfname;
7694
7695 status = smb2_setinfo_file(tree, &sfinfo);
7696 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7697 "smb2_setinfo_file failed\n");
7698 if (t->expect_srcdir_break) {
7699 /* Delay the ack in order to be able to possibly process two breaks */
7700 lease_break_info.lease_skip_ack = true;
7701 CHECK_BREAK_INFO_V2(tree->session->transport,
7702 "RH", "",
7703 t->srcdir_leasekey,
7704 ++dirlease1.lease_epoch);
7705 ack.in.lease.lease_key = lease_break_info.lease_break.current_lease.lease_key;
7706 ack.in.lease.lease_state = lease_break_info.lease_break.new_lease_state;
7707 torture_reset_lease_break_info(tctx, &lease_break_info);
7708 if (!t->expect_dstdir_break) {
7709 CHECK_NO_BREAK(tctx);
7710 }
7711 }
7712 if (t->expect_dstdir_break) {
7713 CHECK_BREAK_INFO_V2(tree->session->transport,
7714 "RH", "",
7715 t->dstdir_leasekey,
7716 ++dirlease2.lease_epoch);
7717 torture_reset_lease_break_info(tctx, &lease_break_info);
7718 if (!t->expect_srcdir_break) {
7719 CHECK_NO_BREAK(tctx);
7720 }
7721 }
7722 if (!t->expect_srcdir_break && !t->expect_dstdir_break) {
7723 CHECK_NO_BREAK(tctx);
7724 }
7725
7726 if (t->expect_srcdir_break) {
7727 /* ack the first lease break. */
7728 status = smb2_lease_break_ack(tree, &ack);
7729 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7730 "smb2_lease_break_ack failed\n");
7731 CHECK_LEASE_BREAK_ACK(&ack, "", t->srcdir_leasekey);
7732 }
7733
7734
7735 done:
7736 if (!smb2_util_handle_empty(h1)) {
7737 smb2_util_close(tree, h1);
7738 }
7739 if (!smb2_util_handle_empty(dirh1)) {
7740 smb2_util_close(tree, dirh1);
7741 }
7742 if (!smb2_util_handle_empty(dirh2)) {
7743 smb2_util_close(tree, dirh2);
7744 }
7745 smb2_deltree(tree, t->srcdir);
7746 smb2_deltree(tree, t->dstdir);
7747 return ret;
7748 }
7749
7750 static bool test_hardlink(struct torture_context *tctx,
7751 struct smb2_tree *tree)
7752 {
7753 struct dlt_hardlink *t = NULL;
7754 bool ret = true;
7755
7756 tree->session->transport->lease.handler = torture_lease_handler;
7757 tree->session->transport->lease.private_data = tree;
7758 torture_reset_lease_break_info(tctx, &lease_break_info);
7759
7760 for (t = dlt_hardlinks; t->testname != NULL; t++) {
7761 ret = test_hardlink_one(tctx, tree, t);
7762 torture_assert_goto(tctx, ret, ret, done,
7763 talloc_asprintf(tctx, "%s failed\n",
7764 t->testname));
7765 }
7766
7767 done:
7768 return ret;
7769 }
7770
7771 /*
7772 * If the parent key of handle on which delete-on-close was set is the same as
7773 * the parent key of last handle closed, don't break this parent lease but all
7774 * others.
7775 */
7776 static bool test_unlink_same_set_and_close(struct torture_context *tctx,
7777 struct smb2_tree *tree)
7778 {
7779 struct smb2_create c = {};
7780 struct smb2_handle d1 = {};
7781 struct smb2_handle d2 = {};
7782 struct smb2_handle h1 = {};
7783 struct smb2_handle h2 = {};
7784 struct smb2_lease dlease1 = {};
7785 struct smb2_lease dlease2 = {};
7786 const uint64_t dlk1 = DLEASE1;
7787 const uint64_t dlk2 = DLEASE2;
7788 struct smb2_lease flease1 = {};
7789 struct smb2_lease flease2 = {};
7790 const char *dname = "test_unlink";
7791 const char *fname = "test_unlink\\test_unlink.dat";
7792 union smb_setfileinfo sfinfo = {};
7793 NTSTATUS status;
7794 bool ret = true;
7795
7796 tree->session->transport->lease.handler = torture_lease_handler;
7797 tree->session->transport->lease.private_data = tree;
7798 torture_reset_lease_break_info(tctx, &lease_break_info);
7799
7800 smb2_deltree(tree, dname);
7801 smb2_util_mkdir(tree, dname);
7802 torture_setup_simple_file(tctx, tree, fname);
7803
7804 torture_comment(tctx, "First open test directory with RH-dirlease\n");
7805
7806 smb2_lease_v2_create(&c, &dlease1, true, dname,
7807 DLEASE1, NULL,
7808 smb2_util_lease_state("RH"), 0);
7809 status = smb2_create(tree, tree, &c);
7810 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7811 "smb2_create failed\n");
7812 d1 = c.out.file.handle;
7813 CHECK_LEASE_V2(&c, "RH", true, DLEASE1, 0, 0, ++dlease1.lease_epoch);
7814
7815 torture_comment(tctx, "Second open test directory with RH-dirlease\n");
7816
7817 smb2_lease_v2_create(&c, &dlease2, true, dname,
7818 DLEASE2, NULL,
7819 smb2_util_lease_state("RH"), 0);
7820 status = smb2_create(tree, tree, &c);
7821 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7822 "smb2_create failed\n");
7823 d2 = c.out.file.handle;
7824 CHECK_LEASE_V2(&c, "RH", true, DLEASE2, 0, 0, ++dlease2.lease_epoch);
7825
7826 torture_comment(tctx, "First open test file\n");
7827
7828 smb2_lease_v2_create(&c, &flease1, false, fname,
7829 LEASE1, &dlk1,
7830 smb2_util_lease_state("R"), 0);
7831
7832 status = smb2_create(tree, tree, &c);
7833 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7834 "smb2_create failed\n");
7835 h1 = c.out.file.handle;
7836
7837 torture_comment(tctx, "Second open test file\n");
7838
7839 smb2_lease_v2_create(&c, &flease2, false, fname,
7840 LEASE2, &dlk2,
7841 smb2_util_lease_state("R"), 0);
7842
7843 status = smb2_create(tree, tree, &c);
7844 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7845 "smb2_create failed\n");
7846 h2 = c.out.file.handle;
7847
7848 torture_comment(tctx, "Sets delete on close on open 2\n");
7849
7850 sfinfo.disposition_info.in.delete_on_close = 1;
7851 sfinfo.generic.level = RAW_SFILEINFO_DISPOSITION_INFORMATION;
7852 sfinfo.generic.in.file.handle = h2;
7853
7854 status = smb2_setinfo_file(tree, &sfinfo);
7855 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7856 "smb2_setinfo_file failed\n");
7857
7858 torture_comment(tctx, "Closing first handle that has not set delete-on-close, "
7859 "this should not trigger a break\n");
7860
7861 smb2_util_close(tree, h1);
7862 ZERO_STRUCT(h1);
7863 CHECK_NO_BREAK(tctx);
7864
7865 torture_comment(tctx, "Closing second and last handle will remove the file, "
7866 "trigger a break on first directory with different "
7867 "parent lease key\n");
7868
7869 smb2_util_close(tree, h2);
7870 ZERO_STRUCT(h2);
7871
7872 CHECK_BREAK_INFO_V2(tree->session->transport,
7873 "RH", "", DLEASE1,
7874 ++dlease1.lease_epoch);
7875
7876 done:
7877 if (!smb2_util_handle_empty(h1)) {
7878 smb2_util_close(tree, h1);
7879 }
7880 if (!smb2_util_handle_empty(h2)) {
7881 smb2_util_close(tree, h2);
7882 }
7883 if (!smb2_util_handle_empty(d1)) {
7884 smb2_util_close(tree, d1);
7885 }
7886 if (!smb2_util_handle_empty(d2)) {
7887 smb2_util_close(tree, d2);
7888 }
7889 return ret;
7890 }
7891
7892 /*
7893 * When the parent key of handle on which delete-on-close was set differs from
7894 * the parent key of last handle closed, which actually does delete the file,
7895 * all directory leases must be broken.
7896 */
7897 static bool test_unlink_different_set_and_close(struct torture_context *tctx,
7898 struct smb2_tree *tree)
7899 {
7900 struct smb2_create c = {};
7901 struct smb2_handle d1 = {};
7902 struct smb2_handle d2 = {};
7903 struct smb2_handle h1 = {};
7904 struct smb2_handle h2 = {};
7905 struct smb2_lease dlease1 = {};
7906 struct smb2_lease dlease2 = {};
7907 const uint64_t dlk1 = DLEASE1;
7908 const uint64_t dlk2 = DLEASE2;
7909 struct smb2_lease flease1 = {};
7910 struct smb2_lease flease2 = {};
7911 const char *dname = "test_unlink";
7912 const char *fname = "test_unlink\\test_unlink.dat";
7913 union smb_setfileinfo sfinfo = {};
7914 struct smb2_lease_break_ack ack = {};
7915 struct smb2_lease *expected_lease1 = NULL;
7916 struct smb2_lease *expected_lease2 = NULL;
7917 uint64_t expected_leasekey1;
7918 uint64_t expected_leasekey2;
7919 NTSTATUS status;
7920 bool ret = true;
7921
7922 tree->session->transport->lease.handler = torture_lease_handler;
7923 tree->session->transport->lease.private_data = tree;
7924 torture_reset_lease_break_info(tctx, &lease_break_info);
7925 lease_break_info.lease_skip_ack = true;
7926
7927 smb2_deltree(tree, dname);
7928 smb2_util_mkdir(tree, dname);
7929 torture_setup_simple_file(tctx, tree, fname);
7930
7931 torture_comment(tctx, "First open test directory with RH-dirlease\n");
7932
7933 smb2_lease_v2_create(&c, &dlease1, true, dname,
7934 DLEASE1, NULL,
7935 smb2_util_lease_state("RH"), 0);
7936 status = smb2_create(tree, tree, &c);
7937 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7938 "smb2_create failed\n");
7939 d1 = c.out.file.handle;
7940 CHECK_LEASE_V2(&c, "RH", true, DLEASE1, 0, 0, ++dlease1.lease_epoch);
7941
7942 torture_comment(tctx, "Second open test directory with RH-dirlease\n");
7943
7944 smb2_lease_v2_create(&c, &dlease2, true, dname,
7945 DLEASE2, NULL,
7946 smb2_util_lease_state("RH"), 0);
7947 status = smb2_create(tree, tree, &c);
7948 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7949 "smb2_create failed\n");
7950 d2 = c.out.file.handle;
7951 CHECK_LEASE_V2(&c, "RH", true, DLEASE2, 0, 0, ++dlease2.lease_epoch);
7952
7953 torture_comment(tctx, "First open test file\n");
7954
7955 smb2_lease_v2_create(&c, &flease1, false, fname,
7956 LEASE1, &dlk1,
7957 smb2_util_lease_state("R"), 0);
7958
7959 status = smb2_create(tree, tree, &c);
7960 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7961 "smb2_create failed\n");
7962 h1 = c.out.file.handle;
7963
7964 torture_comment(tctx, "Second open test file\n");
7965
7966 smb2_lease_v2_create(&c, &flease2, false, fname,
7967 LEASE2, &dlk2,
7968 smb2_util_lease_state("R"), 0);
7969
7970 status = smb2_create(tree, tree, &c);
7971 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7972 "smb2_create failed\n");
7973 h2 = c.out.file.handle;
7974
7975 torture_comment(tctx, "Client 1 sets delete on close\n");
7976
7977 sfinfo.disposition_info.in.delete_on_close = 1;
7978 sfinfo.generic.level = RAW_SFILEINFO_DISPOSITION_INFORMATION;
7979 sfinfo.generic.in.file.handle = h1;
7980
7981 status = smb2_setinfo_file(tree, &sfinfo);
7982 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
7983 "smb2_setinfo_file failed\n");
7984
7985 torture_comment(tctx, "Closing first handle that has set delete-on-close, "
7986 "will not delete the file and not trigger a break\n");
7987
7988 smb2_util_close(tree, h1);
7989 ZERO_STRUCT(h1);
7990 CHECK_NO_BREAK(tctx);
7991
7992 torture_comment(tctx, "Closing second and last handle will remove the file, "
7993 "and trigger a break as the parent lease keys don't match\n");
7994
7995 smb2_util_close(tree, h2);
7996 ZERO_STRUCT(h2);
7997
7998 torture_wait_for_lease_break(tctx);
7999 ack.in.lease.lease_key = lease_break_info.lease_break.current_lease.lease_key;
8000 ack.in.lease.lease_state = lease_break_info.lease_break.new_lease_state;
8001
8002 if (ack.in.lease.lease_key.data[0] == DLEASE1) {
8003 expected_leasekey1 = DLEASE1;
8004 expected_lease1 = &dlease1;
8005 expected_leasekey2 = DLEASE2;
8006 expected_lease2 = &dlease2;
8007 } else {
8008 expected_leasekey1 = DLEASE2;
8009 expected_lease1 = &dlease2;
8010 expected_leasekey2 = DLEASE1;
8011 expected_lease2 = &dlease1;
8012 }
8013
8014 CHECK_BREAK_INFO_V2_NOWAIT(tree->session->transport,
8015 "RH", "", expected_leasekey1,
8016 ++(expected_lease1->lease_epoch));
8017
8018 torture_reset_lease_break_info(tctx, &lease_break_info);
8019 lease_break_info.lease_skip_ack = true;
8020
8021 status = smb2_lease_break_ack(tree, &ack);
8022 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8023 "smb2_lease_break_ack failed\n");
8024 CHECK_LEASE_BREAK_ACK(&ack, "", expected_leasekey1);
8025
8026 CHECK_BREAK_INFO_V2_NOWAIT(tree->session->transport,
8027 "RH", "", expected_leasekey2,
8028 ++(expected_lease2->lease_epoch));
8029
8030 done:
8031 if (!smb2_util_handle_empty(h1)) {
8032 smb2_util_close(tree, h1);
8033 }
8034 if (!smb2_util_handle_empty(h2)) {
8035 smb2_util_close(tree, h2);
8036 }
8037 if (!smb2_util_handle_empty(d1)) {
8038 smb2_util_close(tree, d1);
8039 }
8040 if (!smb2_util_handle_empty(d2)) {
8041 smb2_util_close(tree, d2);
8042 }
8043 return ret;
8044 }
8045
8046 /*
8047 * If the parent key of handle on which initial delete-on-close was requested is
8048 * the same as the parent key of last handle closed, don't break that parent
8049 * lease but all others.
8050 */
8051 static bool test_unlink_same_initial_and_close(struct torture_context *tctx,
8052 struct smb2_tree *tree)
8053 {
8054 struct smb2_create c = {};
8055 struct smb2_handle d1 = {};
8056 struct smb2_handle d2 = {};
8057 struct smb2_handle h1 = {};
8058 struct smb2_handle h2 = {};
8059 struct smb2_lease dlease1 = {};
8060 struct smb2_lease dlease2 = {};
8061 const uint64_t dlk1 = DLEASE1;
8062 const uint64_t dlk2 = DLEASE2;
8063 struct smb2_lease flease1 = {};
8064 struct smb2_lease flease2 = {};
8065 const char *dname = "test_unlink";
8066 const char *fname = "test_unlink\\test_unlink.dat";
8067 NTSTATUS status;
8068 bool ret = true;
8069
8070 tree->session->transport->lease.handler = torture_lease_handler;
8071 tree->session->transport->lease.private_data = tree;
8072 torture_reset_lease_break_info(tctx, &lease_break_info);
8073 lease_break_info.lease_skip_ack = true;
8074
8075 smb2_deltree(tree, dname);
8076 smb2_util_mkdir(tree, dname);
8077 torture_setup_simple_file(tctx, tree, fname);
8078
8079 torture_comment(tctx, "First open test directory with RH-dirlease\n");
8080
8081 smb2_lease_v2_create(&c, &dlease1, true, dname,
8082 DLEASE1, NULL,
8083 smb2_util_lease_state("RH"), 0);
8084 status = smb2_create(tree, tree, &c);
8085 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8086 "smb2_create failed\n");
8087 d1 = c.out.file.handle;
8088 CHECK_LEASE_V2(&c, "RH", true, DLEASE1, 0, 0, ++dlease1.lease_epoch);
8089
8090 torture_comment(tctx, "Second open test directory with RH-dirlease\n");
8091
8092 smb2_lease_v2_create(&c, &dlease2, true, dname,
8093 DLEASE2, NULL,
8094 smb2_util_lease_state("RH"), 0);
8095 status = smb2_create(tree, tree, &c);
8096 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8097 "smb2_create failed\n");
8098 d2 = c.out.file.handle;
8099 CHECK_LEASE_V2(&c, "RH", true, DLEASE2, 0, 0, ++dlease2.lease_epoch);
8100
8101 torture_comment(tctx, "First open test file with initial delete-on-close\n");
8102
8103 smb2_lease_v2_create(&c, &flease1, false, fname,
8104 LEASE1, &dlk1,
8105 smb2_util_lease_state("R"), 0);
8106 c.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
8107
8108 status = smb2_create(tree, tree, &c);
8109 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8110 "smb2_create failed\n");
8111 h1 = c.out.file.handle;
8112
8113 torture_comment(tctx, "Second open test file\n");
8114
8115 smb2_lease_v2_create(&c, &flease2, false, fname,
8116 LEASE2, &dlk2,
8117 smb2_util_lease_state("R"), 0);
8118
8119 status = smb2_create(tree, tree, &c);
8120 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8121 "smb2_create failed\n");
8122 h2 = c.out.file.handle;
8123
8124 torture_comment(tctx, "Closing second handle should not trigger a lease break\n");
8125
8126 smb2_util_close(tree, h2);
8127 ZERO_STRUCT(h2);
8128
8129 torture_comment(tctx, "Closing first handle that had initial delete-on-close, "
8130 "must trigger single break on directory handle 2\n");
8131
8132 smb2_util_close(tree, h1);
8133 ZERO_STRUCT(h1);
8134
8135 CHECK_BREAK_INFO_V2(tree->session->transport,
8136 "RH", "", DLEASE2,
8137 ++dlease2.lease_epoch);
8138
8139 done:
8140 if (!smb2_util_handle_empty(h1)) {
8141 smb2_util_close(tree, h1);
8142 }
8143 if (!smb2_util_handle_empty(h2)) {
8144 smb2_util_close(tree, h2);
8145 }
8146 if (!smb2_util_handle_empty(d1)) {
8147 smb2_util_close(tree, d1);
8148 }
8149 if (!smb2_util_handle_empty(d2)) {
8150 smb2_util_close(tree, d2);
8151 }
8152 return ret;
8153 }
8154
8155 /*
8156 * When the parent key of handle on which initial delete-on-close was set
8157 * differs from the parent key of last handle closed, which actually does delete
8158 * the file, all directory leases must be broken.
8159 */
8160 static bool test_unlink_different_initial_and_close(struct torture_context *tctx,
8161 struct smb2_tree *tree)
8162 {
8163 struct smb2_create c = {};
8164 struct smb2_handle d1 = {};
8165 struct smb2_handle d2 = {};
8166 struct smb2_handle h1 = {};
8167 struct smb2_handle h2 = {};
8168 struct smb2_lease dlease1 = {};
8169 struct smb2_lease dlease2 = {};
8170 const uint64_t dlk1 = DLEASE1;
8171 const uint64_t dlk2 = DLEASE2;
8172 struct smb2_lease flease1 = {};
8173 struct smb2_lease flease2 = {};
8174 const char *dname = "test_unlink";
8175 const char *fname = "test_unlink\\test_unlink.dat";
8176 struct smb2_lease_break_ack ack = {};
8177 struct smb2_lease *expected_lease1 = NULL;
8178 struct smb2_lease *expected_lease2 = NULL;
8179 uint64_t expected_leasekey1;
8180 uint64_t expected_leasekey2;
8181 NTSTATUS status;
8182 bool ret = true;
8183
8184 tree->session->transport->lease.handler = torture_lease_handler;
8185 tree->session->transport->lease.private_data = tree;
8186 torture_reset_lease_break_info(tctx, &lease_break_info);
8187 lease_break_info.lease_skip_ack = true;
8188
8189 smb2_deltree(tree, dname);
8190 smb2_util_mkdir(tree, dname);
8191 torture_setup_simple_file(tctx, tree, fname);
8192
8193 torture_comment(tctx, "First open test directory with RH-dirlease\n");
8194
8195 smb2_lease_v2_create(&c, &dlease1, true, dname,
8196 DLEASE1, NULL,
8197 smb2_util_lease_state("RH"), 0);
8198 status = smb2_create(tree, tree, &c);
8199 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8200 "smb2_create failed\n");
8201 d1 = c.out.file.handle;
8202 CHECK_LEASE_V2(&c, "RH", true, DLEASE1, 0, 0, ++dlease1.lease_epoch);
8203
8204 torture_comment(tctx, "Second open test directory with RH-dirlease\n");
8205
8206 smb2_lease_v2_create(&c, &dlease2, true, dname,
8207 DLEASE2, NULL,
8208 smb2_util_lease_state("RH"), 0);
8209 status = smb2_create(tree, tree, &c);
8210 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8211 "smb2_create failed\n");
8212 d2 = c.out.file.handle;
8213 CHECK_LEASE_V2(&c, "RH", true, DLEASE2, 0, 0, ++dlease2.lease_epoch);
8214
8215 torture_comment(tctx, "First open test file\n");
8216
8217 smb2_lease_v2_create(&c, &flease1, false, fname,
8218 LEASE1, &dlk1,
8219 smb2_util_lease_state("R"), 0);
8220 c.in.create_options = NTCREATEX_OPTIONS_DELETE_ON_CLOSE;
8221
8222 status = smb2_create(tree, tree, &c);
8223 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8224 "smb2_create failed\n");
8225 h1 = c.out.file.handle;
8226
8227 torture_comment(tctx, "Second open test file\n");
8228
8229 smb2_lease_v2_create(&c, &flease2, false, fname,
8230 LEASE2, &dlk2,
8231 smb2_util_lease_state("R"), 0);
8232
8233 status = smb2_create(tree, tree, &c);
8234 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8235 "smb2_create failed\n");
8236 h2 = c.out.file.handle;
8237
8238 torture_comment(tctx, "Closing first handle that requested initial delete-on-close, "
8239 "will not delete the file and not trigger a break\n");
8240
8241 smb2_util_close(tree, h1);
8242 ZERO_STRUCT(h1);
8243 CHECK_NO_BREAK(tctx);
8244
8245 torture_comment(tctx, "Closing second and last handle will remove the file, "
8246 "and trigger a break as the parent lease keys don't match\n");
8247
8248 smb2_util_close(tree, h2);
8249 ZERO_STRUCT(h2);
8250
8251 torture_wait_for_lease_break(tctx);
8252 ack.in.lease.lease_key = lease_break_info.lease_break.current_lease.lease_key;
8253 ack.in.lease.lease_state = lease_break_info.lease_break.new_lease_state;
8254
8255 if (ack.in.lease.lease_key.data[0] == DLEASE1) {
8256 expected_leasekey1 = DLEASE1;
8257 expected_lease1 = &dlease1;
8258 expected_leasekey2 = DLEASE2;
8259 expected_lease2 = &dlease2;
8260 } else {
8261 expected_leasekey1 = DLEASE2;
8262 expected_lease1 = &dlease2;
8263 expected_leasekey2 = DLEASE1;
8264 expected_lease2 = &dlease1;
8265 }
8266
8267 CHECK_BREAK_INFO_V2_NOWAIT(tree->session->transport,
8268 "RH", "", expected_leasekey1,
8269 ++(expected_lease1->lease_epoch));
8270
8271 torture_reset_lease_break_info(tctx, &lease_break_info);
8272 lease_break_info.lease_skip_ack = true;
8273
8274 status = smb2_lease_break_ack(tree, &ack);
8275 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
8276 "smb2_lease_break_ack failed\n");
8277 CHECK_LEASE_BREAK_ACK(&ack, "", expected_leasekey1);
8278
8279 CHECK_BREAK_INFO_V2_NOWAIT(tree->session->transport,
8280 "RH", "", expected_leasekey2,
8281 ++(expected_lease2->lease_epoch));
8282
8283 done:
8284 if (!smb2_util_handle_empty(h1)) {
8285 smb2_util_close(tree, h1);
8286 }
8287 if (!smb2_util_handle_empty(h2)) {
8288 smb2_util_close(tree, h2);
8289 }
8290 if (!smb2_util_handle_empty(d1)) {
8291 smb2_util_close(tree, d1);
8292 }
8293 if (!smb2_util_handle_empty(d2)) {
8294 smb2_util_close(tree, d2);
8295 }
8296 return ret;
8297 }
8298
8299 struct torture_suite *torture_smb2_dirlease_init(TALLOC_CTX *ctx)
8300 {
8301 struct torture_suite *suite =
8302 torture_suite_create(ctx, "dirlease");
8303
8304 suite->description = talloc_strdup(suite, "SMB3 Directory Lease tests");
8305
8306 torture_suite_add_1smb2_test(suite, "v2_request_parent", test_lease_v2_request_parent);
8307 torture_suite_add_2smb2_test(suite, "v2_request", test_lease_v2_request);
8308 torture_suite_add_1smb2_test(suite, "oplocks", test_dirlease_oplocks);
8309 torture_suite_add_1smb2_test(suite, "leases", test_dirlease_leases);
8310 torture_suite_add_2smb2_test(suite, "seteof", test_dirlease_seteof);
8311 torture_suite_add_2smb2_test(suite, "setdos", test_dirlease_setdos);
8312 torture_suite_add_2smb2_test(suite, "setbtime", test_dirlease_setbtime);
8313 torture_suite_add_2smb2_test(suite, "setmtime", test_dirlease_setmtime);
8314 torture_suite_add_2smb2_test(suite, "setctime", test_dirlease_setctime);
8315 torture_suite_add_2smb2_test(suite, "setatime", test_dirlease_setatime);
8316 torture_suite_add_1smb2_test(suite, "rename", test_rename);
8317 torture_suite_add_1smb2_test(suite, "rename_dst_parent", test_rename_dst_parent);
8318 torture_suite_add_2smb2_test(suite, "overwrite", test_overwrite);
8319 torture_suite_add_1smb2_test(suite, "hardlink", test_hardlink);
8320 torture_suite_add_1smb2_test(suite, "unlink_same_set_and_close", test_unlink_same_set_and_close);
8321 torture_suite_add_1smb2_test(suite, "unlink_different_set_and_close", test_unlink_different_set_and_close);
8322 torture_suite_add_1smb2_test(suite, "unlink_same_initial_and_close", test_unlink_same_initial_and_close);
8323 torture_suite_add_1smb2_test(suite, "unlink_different_initial_and_close", test_unlink_different_initial_and_close);
8324 return suite;
8325 }