?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
torture4: Add a test to break a handle twice
[Samba.git] / source4 / torture / smb2 / lease.c
blob038cc58ad01acdc5cbcef3994f5d137a7cb80b7f
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 "libcli/smb/smbXcli_base.h"
29
30 #define CHECK_VAL(v, correct) do { \
31 if ((v) != (correct)) { \
32 torture_result(tctx, TORTURE_FAIL, "(%s): wrong value for %s got 0x%x - should be 0x%x\n", \
33 __location__, #v, (int)(v), (int)(correct)); \
34 ret = false; \
35 }} while (0)
36
37 #define CHECK_STATUS(status, correct) do { \
38 if (!NT_STATUS_EQUAL(status, correct)) { \
39 torture_result(tctx, TORTURE_FAIL, __location__": Incorrect status %s - should be %s", \
40 nt_errstr(status), nt_errstr(correct)); \
41 ret = false; \
42 goto done; \
43 }} while (0)
44
45 #define CHECK_CREATED(__io, __created, __attribute) \
46 do { \
47 CHECK_VAL((__io)->out.create_action, NTCREATEX_ACTION_ ## __created); \
48 CHECK_VAL((__io)->out.alloc_size, 0); \
49 CHECK_VAL((__io)->out.size, 0); \
50 CHECK_VAL((__io)->out.file_attr, (__attribute)); \
51 CHECK_VAL((__io)->out.reserved2, 0); \
52 } while(0)
53
54 #define CHECK_LEASE(__io, __state, __oplevel, __key) \
55 do { \
56 if (__oplevel) { \
57 CHECK_VAL((__io)->out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE); \
58 CHECK_VAL((__io)->out.lease_response.lease_key.data[0], (__key)); \
59 CHECK_VAL((__io)->out.lease_response.lease_key.data[1], ~(__key)); \
60 CHECK_VAL((__io)->out.lease_response.lease_state, smb2_util_lease_state(__state)); \
61 } else { \
62 CHECK_VAL((__io)->out.oplock_level, SMB2_OPLOCK_LEVEL_NONE); \
63 CHECK_VAL((__io)->out.lease_response.lease_key.data[0], 0); \
64 CHECK_VAL((__io)->out.lease_response.lease_key.data[1], 0); \
65 CHECK_VAL((__io)->out.lease_response.lease_state, 0); \
66 } \
67 \
68 CHECK_VAL((__io)->out.lease_response.lease_flags, 0); \
69 CHECK_VAL((__io)->out.lease_response.lease_duration, 0); \
70 } while(0)
71
72 #define CHECK_LEASE_V2(__io, __state, __oplevel, __key, __flags, __parent) \
73 do { \
74 if (__oplevel) { \
75 CHECK_VAL((__io)->out.oplock_level, SMB2_OPLOCK_LEVEL_LEASE); \
76 CHECK_VAL((__io)->out.lease_response_v2.lease_key.data[0], (__key)); \
77 CHECK_VAL((__io)->out.lease_response_v2.lease_key.data[1], ~(__key)); \
78 CHECK_VAL((__io)->out.lease_response_v2.lease_state, smb2_util_lease_state(__state)); \
79 } else { \
80 CHECK_VAL((__io)->out.oplock_level, SMB2_OPLOCK_LEVEL_NONE); \
81 CHECK_VAL((__io)->out.lease_response_v2.lease_key.data[0], 0); \
82 CHECK_VAL((__io)->out.lease_response_v2.lease_key.data[1], 0); \
83 CHECK_VAL((__io)->out.lease_response_v2.lease_state, 0); \
84 } \
85 \
86 CHECK_VAL((__io)->out.lease_response_v2.lease_flags, __flags); \
87 if (__flags & SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET) { \
88 CHECK_VAL((__io)->out.lease_response_v2.parent_lease_key.data[0], (__parent)); \
89 CHECK_VAL((__io)->out.lease_response_v2.parent_lease_key.data[1], ~(__parent)); \
90 } \
91 CHECK_VAL((__io)->out.lease_response_v2.lease_duration, 0); \
92 } while(0)
93
94 static const uint64_t LEASE1 = 0xBADC0FFEE0DDF00Dull;
95 static const uint64_t LEASE2 = 0xDEADBEEFFEEDBEADull;
96 static const uint64_t LEASE3 = 0xDAD0FFEDD00DF00Dull;
97 static const uint64_t LEASE4 = 0xBAD0FFEDD00DF00Dull;
98
99 #define NREQUEST_RESULTS 8
100 static const char *request_results[NREQUEST_RESULTS][2] = {
101 { "", "" },
102 { "R", "R" },
103 { "H", "" },
104 { "W", "" },
105 { "RH", "RH" },
106 { "RW", "RW" },
107 { "HW", "" },
108 { "RHW", "RHW" },
109 };
110
111 static bool test_lease_request(struct torture_context *tctx,
112 struct smb2_tree *tree)
113 {
114 TALLOC_CTX *mem_ctx = talloc_new(tctx);
115 struct smb2_create io;
116 struct smb2_lease ls;
117 struct smb2_handle h1, h2;
118 NTSTATUS status;
119 const char *fname = "lease.dat";
120 const char *fname2 = "lease2.dat";
121 const char *sname = "lease.dat:stream";
122 const char *dname = "lease.dir";
123 bool ret = true;
124 int i;
125 uint32_t caps;
126
127 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
128 if (!(caps & SMB2_CAP_LEASING)) {
129 torture_skip(tctx, "leases are not supported");
130 }
131
132 smb2_util_unlink(tree, fname);
133 smb2_util_unlink(tree, fname2);
134 smb2_util_rmdir(tree, dname);
135
136 /* Win7 is happy to grant RHW leases on files. */
137 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
138 status = smb2_create(tree, mem_ctx, &io);
139 CHECK_STATUS(status, NT_STATUS_OK);
140 h1 = io.out.file.handle;
141 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
142 CHECK_LEASE(&io, "RHW", true, LEASE1);
143
144 /* But will reject leases on directories. */
145 smb2_lease_create(&io, &ls, true, dname, LEASE2, smb2_util_lease_state("RHW"));
146 status = smb2_create(tree, mem_ctx, &io);
147 CHECK_STATUS(status, NT_STATUS_OK);
148 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_DIRECTORY);
149 CHECK_LEASE(&io, "", false, 0);
150 smb2_util_close(tree, io.out.file.handle);
151
152 /* Also rejects multiple files leased under the same key. */
153 smb2_lease_create(&io, &ls, true, fname2, LEASE1, smb2_util_lease_state("RHW"));
154 status = smb2_create(tree, mem_ctx, &io);
155 CHECK_STATUS(status, NT_STATUS_INVALID_PARAMETER);
156
157 /* And grants leases on streams (with separate leasekey). */
158 smb2_lease_create(&io, &ls, false, sname, LEASE2, smb2_util_lease_state("RHW"));
159 status = smb2_create(tree, mem_ctx, &io);
160 h2 = io.out.file.handle;
161 CHECK_STATUS(status, NT_STATUS_OK);
162 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
163 CHECK_LEASE(&io, "RHW", true, LEASE2);
164 smb2_util_close(tree, h2);
165
166 smb2_util_close(tree, h1);
167
168 /* Now see what combos are actually granted. */
169 for (i = 0; i < NREQUEST_RESULTS; i++) {
170 torture_comment(tctx, "Requesting lease type %s(%x),"
171 " expecting %s(%x)\n",
172 request_results[i][0], smb2_util_lease_state(request_results[i][0]),
173 request_results[i][1], smb2_util_lease_state(request_results[i][1]));
174 smb2_lease_create(&io, &ls, false, fname, LEASE1,
175 smb2_util_lease_state(request_results[i][0]));
176 status = smb2_create(tree, mem_ctx, &io);
177 h2 = io.out.file.handle;
178 CHECK_STATUS(status, NT_STATUS_OK);
179 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
180 CHECK_LEASE(&io, request_results[i][1], true, LEASE1);
181 smb2_util_close(tree, io.out.file.handle);
182 }
183
184 done:
185 smb2_util_close(tree, h1);
186 smb2_util_close(tree, h2);
187
188 smb2_util_unlink(tree, fname);
189 smb2_util_unlink(tree, fname2);
190 smb2_util_rmdir(tree, dname);
191
192 talloc_free(mem_ctx);
193
194 return ret;
195 }
196
197 static bool test_lease_upgrade(struct torture_context *tctx,
198 struct smb2_tree *tree)
199 {
200 TALLOC_CTX *mem_ctx = talloc_new(tctx);
201 struct smb2_create io;
202 struct smb2_lease ls;
203 struct smb2_handle h, hnew;
204 NTSTATUS status;
205 const char *fname = "lease.dat";
206 bool ret = true;
207 uint32_t caps;
208
209 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
210 if (!(caps & SMB2_CAP_LEASING)) {
211 torture_skip(tctx, "leases are not supported");
212 }
213
214 smb2_util_unlink(tree, fname);
215
216 /* Grab a RH lease. */
217 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
218 status = smb2_create(tree, mem_ctx, &io);
219 CHECK_STATUS(status, NT_STATUS_OK);
220 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
221 CHECK_LEASE(&io, "RH", true, LEASE1);
222 h = io.out.file.handle;
223
224 /* Upgrades (sidegrades?) to RW leave us with an RH. */
225 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RW"));
226 status = smb2_create(tree, mem_ctx, &io);
227 CHECK_STATUS(status, NT_STATUS_OK);
228 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
229 CHECK_LEASE(&io, "RH", true, LEASE1);
230 hnew = io.out.file.handle;
231
232 smb2_util_close(tree, hnew);
233
234 /* Upgrade to RHW lease. */
235 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
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, "RHW", true, LEASE1);
240 hnew = io.out.file.handle;
241
242 smb2_util_close(tree, h);
243 h = hnew;
244
245 /* Attempt to downgrade - original lease state is maintained. */
246 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
247 status = smb2_create(tree, mem_ctx, &io);
248 CHECK_STATUS(status, NT_STATUS_OK);
249 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
250 CHECK_LEASE(&io, "RHW", true, LEASE1);
251 hnew = io.out.file.handle;
252
253 smb2_util_close(tree, hnew);
254
255 done:
256 smb2_util_close(tree, h);
257 smb2_util_close(tree, hnew);
258
259 smb2_util_unlink(tree, fname);
260
261 talloc_free(mem_ctx);
262
263 return ret;
264 }
265
266 /**
267 * upgrade2 test.
268 * full matrix of lease upgrade combinations
269 * (non-contended case)
270 *
271 * The summary of the behaviour is this:
272 * -------------------------------------
273 * An uncontended lease upgrade results in a change
274 * if and only if the requested lease state is
275 * - valid, and
276 * - strictly a superset of the lease state already held.
277 *
278 * In that case the resulting lease state is the one
279 * requested in the upgrade.
280 */
281 struct lease_upgrade2_test {
282 const char *initial;
283 const char *upgrade_to;
284 const char *expected;
285 };
286
287 #define NUM_LEASE_TYPES 5
288 #define NUM_UPGRADE_TESTS ( NUM_LEASE_TYPES * NUM_LEASE_TYPES )
289 struct lease_upgrade2_test lease_upgrade2_tests[NUM_UPGRADE_TESTS] = {
290 { "", "", "" },
291 { "", "R", "R" },
292 { "", "RH", "RH" },
293 { "", "RW", "RW" },
294 { "", "RWH", "RWH" },
295
296 { "R", "", "R" },
297 { "R", "R", "R" },
298 { "R", "RH", "RH" },
299 { "R", "RW", "RW" },
300 { "R", "RWH", "RWH" },
301
302 { "RH", "", "RH" },
303 { "RH", "R", "RH" },
304 { "RH", "RH", "RH" },
305 { "RH", "RW", "RH" },
306 { "RH", "RWH", "RWH" },
307
308 { "RW", "", "RW" },
309 { "RW", "R", "RW" },
310 { "RW", "RH", "RW" },
311 { "RW", "RW", "RW" },
312 { "RW", "RWH", "RWH" },
313
314 { "RWH", "", "RWH" },
315 { "RWH", "R", "RWH" },
316 { "RWH", "RH", "RWH" },
317 { "RWH", "RW", "RWH" },
318 { "RWH", "RWH", "RWH" },
319 };
320
321 static bool test_lease_upgrade2(struct torture_context *tctx,
322 struct smb2_tree *tree)
323 {
324 TALLOC_CTX *mem_ctx = talloc_new(tctx);
325 struct smb2_handle h, hnew;
326 NTSTATUS status;
327 struct smb2_create io;
328 struct smb2_lease ls;
329 const char *fname = "lease.dat";
330 bool ret = true;
331 int i;
332 uint32_t caps;
333
334 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
335 if (!(caps & SMB2_CAP_LEASING)) {
336 torture_skip(tctx, "leases are not supported");
337 }
338
339 for (i = 0; i < NUM_UPGRADE_TESTS; i++) {
340 struct lease_upgrade2_test t = lease_upgrade2_tests[i];
341
342 smb2_util_unlink(tree, fname);
343
344 /* Grab a lease. */
345 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.initial));
346 status = smb2_create(tree, mem_ctx, &io);
347 CHECK_STATUS(status, NT_STATUS_OK);
348 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
349 CHECK_LEASE(&io, t.initial, true, LEASE1);
350 h = io.out.file.handle;
351
352 /* Upgrade. */
353 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.upgrade_to));
354 status = smb2_create(tree, mem_ctx, &io);
355 CHECK_STATUS(status, NT_STATUS_OK);
356 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
357 CHECK_LEASE(&io, t.expected, true, LEASE1);
358 hnew = io.out.file.handle;
359
360 smb2_util_close(tree, hnew);
361 smb2_util_close(tree, h);
362 }
363
364 done:
365 smb2_util_close(tree, h);
366 smb2_util_close(tree, hnew);
367
368 smb2_util_unlink(tree, fname);
369
370 talloc_free(mem_ctx);
371
372 return ret;
373 }
374
375
376 #define CHECK_LEASE_BREAK(__lb, __oldstate, __state, __key) \
377 do { \
378 CHECK_VAL((__lb)->new_lease_state, smb2_util_lease_state(__state)); \
379 CHECK_VAL((__lb)->current_lease.lease_state, smb2_util_lease_state(__oldstate)); \
380 CHECK_VAL((__lb)->current_lease.lease_key.data[0], (__key)); \
381 CHECK_VAL((__lb)->current_lease.lease_key.data[1], ~(__key)); \
382 } while(0)
383
384 #define CHECK_LEASE_BREAK_ACK(__lba, __state, __key) \
385 do { \
386 CHECK_VAL((__lba)->out.reserved, 0); \
387 CHECK_VAL((__lba)->out.lease.lease_key.data[0], (__key)); \
388 CHECK_VAL((__lba)->out.lease.lease_key.data[1], ~(__key)); \
389 CHECK_VAL((__lba)->out.lease.lease_state, smb2_util_lease_state(__state)); \
390 CHECK_VAL((__lba)->out.lease.lease_flags, 0); \
391 CHECK_VAL((__lba)->out.lease.lease_duration, 0); \
392 } while(0)
393
394 static struct {
395 struct smb2_lease_break lease_break;
396 struct smb2_lease_break_ack lease_break_ack;
397 int count;
398 int failures;
399
400 struct smb2_handle oplock_handle;
401 uint8_t held_oplock_level;
402 uint8_t oplock_level;
403 int oplock_count;
404 int oplock_failures;
405 } break_info;
406
407 #define CHECK_BREAK_INFO(__oldstate, __state, __key) \
408 do { \
409 CHECK_VAL(break_info.failures, 0); \
410 CHECK_VAL(break_info.count, 1); \
411 CHECK_LEASE_BREAK(&break_info.lease_break, (__oldstate), \
412 (__state), (__key)); \
413 if (break_info.lease_break.break_flags & \
414 SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED) { \
415 CHECK_LEASE_BREAK_ACK(&break_info.lease_break_ack, \
416 (__state), (__key)); \
417 } \
418 } while(0)
419
420 static void torture_lease_break_callback(struct smb2_request *req)
421 {
422 NTSTATUS status;
423
424 status = smb2_lease_break_ack_recv(req, &break_info.lease_break_ack);
425 if (!NT_STATUS_IS_OK(status))
426 break_info.failures++;
427
428 return;
429 }
430
431 /* a lease break request handler */
432 static bool torture_lease_handler(struct smb2_transport *transport,
433 const struct smb2_lease_break *lb,
434 void *private_data)
435 {
436 struct smb2_tree *tree = private_data;
437 struct smb2_lease_break_ack io;
438 struct smb2_request *req;
439
440 break_info.lease_break = *lb;
441 break_info.count++;
442
443 if (lb->break_flags & SMB2_NOTIFY_BREAK_LEASE_FLAG_ACK_REQUIRED) {
444 ZERO_STRUCT(io);
445 io.in.lease.lease_key = lb->current_lease.lease_key;
446 io.in.lease.lease_state = lb->new_lease_state;
447
448 req = smb2_lease_break_ack_send(tree, &io);
449 req->async.fn = torture_lease_break_callback;
450 req->async.private_data = NULL;
451 }
452
453 return true;
454 }
455
456 /**
457 * upgrade3:
458 * full matrix of lease upgrade combinations
459 * (contended case)
460 *
461 * We start with 2 leases, and check how one can
462 * be upgraded
463 *
464 * The summary of the behaviour is this:
465 * -------------------------------------
466 *
467 * If we have two leases (lease1 and lease2) on the same file,
468 * then attempt to upgrade lease1 results in a change if and only
469 * if the requested lease state:
470 * - is valid,
471 * - is strictly a superset of lease1, and
472 * - can held together with lease2.
473 *
474 * In that case, the resuling lease state of the upgraded lease1
475 * is the state requested in the upgrade. lease2 is not broken
476 * and remains unchanged.
477 *
478 * Note that this contrasts the case of directly opening with
479 * an initial requested lease state, in which case you get that
480 * portion of the requested state that can be shared with the
481 * already existing leases (or the states that they get broken to).
482 */
483 struct lease_upgrade3_test {
484 const char *held1;
485 const char *held2;
486 const char *upgrade_to;
487 const char *upgraded_to;
488 };
489
490 #define NUM_UPGRADE3_TESTS ( 20 )
491 struct lease_upgrade3_test lease_upgrade3_tests[NUM_UPGRADE3_TESTS] = {
492 {"R", "R", "", "R" },
493 {"R", "R", "R", "R" },
494 {"R", "R", "RW", "R" },
495 {"R", "R", "RH", "RH" },
496 {"R", "R", "RHW", "R" },
497
498 {"R", "RH", "", "R" },
499 {"R", "RH", "R", "R" },
500 {"R", "RH", "RW", "R" },
501 {"R", "RH", "RH", "RH" },
502 {"R", "RH", "RHW", "R" },
503
504 {"RH", "R", "", "RH" },
505 {"RH", "R", "R", "RH" },
506 {"RH", "R", "RW", "RH" },
507 {"RH", "R", "RH", "RH" },
508 {"RH", "R", "RHW", "RH" },
509
510 {"RH", "RH", "", "RH" },
511 {"RH", "RH", "R", "RH" },
512 {"RH", "RH", "RW", "RH" },
513 {"RH", "RH", "RH", "RH" },
514 {"RH", "RH", "RHW", "RH" },
515 };
516
517 static bool test_lease_upgrade3(struct torture_context *tctx,
518 struct smb2_tree *tree)
519 {
520 TALLOC_CTX *mem_ctx = talloc_new(tctx);
521 struct smb2_handle h, h2, hnew;
522 NTSTATUS status;
523 struct smb2_create io;
524 struct smb2_lease ls;
525 const char *fname = "upgrade3.dat";
526 bool ret = true;
527 int i;
528 uint32_t caps;
529
530 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
531 if (!(caps & SMB2_CAP_LEASING)) {
532 torture_skip(tctx, "leases are not supported");
533 }
534
535 tree->session->transport->lease.handler = torture_lease_handler;
536 tree->session->transport->lease.private_data = tree;
537
538 smb2_util_unlink(tree, fname);
539
540 for (i = 0; i < NUM_UPGRADE3_TESTS; i++) {
541 struct lease_upgrade3_test t = lease_upgrade3_tests[i];
542
543 smb2_util_unlink(tree, fname);
544
545 ZERO_STRUCT(break_info);
546
547 /* grab first lease */
548 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.held1));
549 status = smb2_create(tree, mem_ctx, &io);
550 CHECK_STATUS(status, NT_STATUS_OK);
551 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
552 CHECK_LEASE(&io, t.held1, true, LEASE1);
553 h = io.out.file.handle;
554
555 /* grab second lease */
556 smb2_lease_create(&io, &ls, false, fname, LEASE2, smb2_util_lease_state(t.held2));
557 status = smb2_create(tree, mem_ctx, &io);
558 CHECK_STATUS(status, NT_STATUS_OK);
559 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
560 CHECK_LEASE(&io, t.held2, true, LEASE2);
561 h2 = io.out.file.handle;
562
563 /* no break has happened */
564 CHECK_VAL(break_info.count, 0);
565 CHECK_VAL(break_info.failures, 0);
566
567 /* try to upgrade lease1 */
568 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(t.upgrade_to));
569 status = smb2_create(tree, mem_ctx, &io);
570 CHECK_STATUS(status, NT_STATUS_OK);
571 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
572 CHECK_LEASE(&io, t.upgraded_to, true, LEASE1);
573 hnew = io.out.file.handle;
574
575 /* no break has happened */
576 CHECK_VAL(break_info.count, 0);
577 CHECK_VAL(break_info.failures, 0);
578
579 smb2_util_close(tree, hnew);
580 smb2_util_close(tree, h);
581 smb2_util_close(tree, h2);
582 }
583
584 done:
585 smb2_util_close(tree, h);
586 smb2_util_close(tree, hnew);
587 smb2_util_close(tree, h2);
588
589 smb2_util_unlink(tree, fname);
590
591 talloc_free(mem_ctx);
592
593 return ret;
594 }
595
596
597
598 /*
599 Timer handler function notifies the registering function that time is up
600 */
601 static void timeout_cb(struct tevent_context *ev,
602 struct tevent_timer *te,
603 struct timeval current_time,
604 void *private_data)
605 {
606 bool *timesup = (bool *)private_data;
607 *timesup = true;
608 return;
609 }
610
611 /*
612 Wait a short period of time to receive a single oplock break request
613 */
614 static void torture_wait_for_lease_break(struct torture_context *tctx)
615 {
616 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
617 struct tevent_timer *te = NULL;
618 struct timeval ne;
619 bool timesup = false;
620 int old_count = break_info.count;
621
622 /* Wait .1 seconds for an lease break */
623 ne = tevent_timeval_current_ofs(0, 100000);
624
625 te = tevent_add_timer(tctx->ev, tmp_ctx, ne, timeout_cb, &timesup);
626 if (te == NULL) {
627 torture_comment(tctx, "Failed to wait for an oplock break. "
628 "test results may not be accurate.");
629 goto done;
630 }
631
632 while (!timesup && break_info.count < old_count + 1) {
633 if (tevent_loop_once(tctx->ev) != 0) {
634 torture_comment(tctx, "Failed to wait for an oplock "
635 "break. test results may not be "
636 "accurate.");
637 goto done;
638 }
639 }
640
641 done:
642 /* We don't know if the timed event fired and was freed, we received
643 * our oplock break, or some other event triggered the loop. Thus,
644 * we create a tmp_ctx to be able to safely free/remove the timed
645 * event in all 3 cases. */
646 talloc_free(tmp_ctx);
647
648 return;
649 }
650
651 /*
652 break_results should be read as "held lease, new lease, hold broken to, new
653 grant", i.e. { "RH", "RW", "RH", "R" } means that if key1 holds RH and key2
654 tries for RW, key1 will be broken to RH (in this case, not broken at all)
655 and key2 will be granted R.
656
657 Note: break_results only includes things that Win7 will actually grant (see
658 request_results above).
659 */
660 #define NBREAK_RESULTS 16
661 static const char *break_results[NBREAK_RESULTS][4] = {
662 {"R", "R", "R", "R"},
663 {"R", "RH", "R", "RH"},
664 {"R", "RW", "R", "R"},
665 {"R", "RHW", "R", "RH"},
666
667 {"RH", "R", "RH", "R"},
668 {"RH", "RH", "RH", "RH"},
669 {"RH", "RW", "RH", "R"},
670 {"RH", "RHW", "RH", "RH"},
671
672 {"RW", "R", "R", "R"},
673 {"RW", "RH", "R", "RH"},
674 {"RW", "RW", "R", "R"},
675 {"RW", "RHW", "R", "RH"},
676
677 {"RHW", "R", "RH", "R"},
678 {"RHW", "RH", "RH", "RH"},
679 {"RHW", "RW", "RH", "R"},
680 {"RHW", "RHW", "RH", "RH"},
681 };
682
683 static bool test_lease_break(struct torture_context *tctx,
684 struct smb2_tree *tree)
685 {
686 TALLOC_CTX *mem_ctx = talloc_new(tctx);
687 struct smb2_create io;
688 struct smb2_lease ls;
689 struct smb2_handle h, h2, h3;
690 NTSTATUS status;
691 const char *fname = "lease.dat";
692 bool ret = true;
693 int i;
694 uint32_t caps;
695
696 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
697 if (!(caps & SMB2_CAP_LEASING)) {
698 torture_skip(tctx, "leases are not supported");
699 }
700
701 tree->session->transport->lease.handler = torture_lease_handler;
702 tree->session->transport->lease.private_data = tree;
703
704 smb2_util_unlink(tree, fname);
705
706 for (i = 0; i < NBREAK_RESULTS; i++) {
707 const char *held = break_results[i][0];
708 const char *contend = break_results[i][1];
709 const char *brokento = break_results[i][2];
710 const char *granted = break_results[i][3];
711 torture_comment(tctx, "Hold %s(%x), requesting %s(%x), "
712 "expecting break to %s(%x) and grant of %s(%x)\n",
713 held, smb2_util_lease_state(held), contend, smb2_util_lease_state(contend),
714 brokento, smb2_util_lease_state(brokento), granted, smb2_util_lease_state(granted));
715
716 ZERO_STRUCT(break_info);
717
718 /* Grab lease. */
719 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(held));
720 status = smb2_create(tree, mem_ctx, &io);
721 CHECK_STATUS(status, NT_STATUS_OK);
722 h = io.out.file.handle;
723 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
724 CHECK_LEASE(&io, held, true, LEASE1);
725
726 /* Possibly contend lease. */
727 smb2_lease_create(&io, &ls, false, fname, LEASE2, smb2_util_lease_state(contend));
728 status = smb2_create(tree, mem_ctx, &io);
729 CHECK_STATUS(status, NT_STATUS_OK);
730 h2 = io.out.file.handle;
731 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
732 CHECK_LEASE(&io, granted, true, LEASE2);
733
734 if (smb2_util_lease_state(held) != smb2_util_lease_state(brokento)) {
735 CHECK_BREAK_INFO(held, brokento, LEASE1);
736 } else {
737 CHECK_VAL(break_info.count, 0);
738 CHECK_VAL(break_info.failures, 0);
739 }
740
741 ZERO_STRUCT(break_info);
742
743 /*
744 Now verify that an attempt to upgrade LEASE1 results in no
745 break and no change in LEASE1.
746 */
747 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
748 status = smb2_create(tree, mem_ctx, &io);
749 CHECK_STATUS(status, NT_STATUS_OK);
750 h3 = io.out.file.handle;
751 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
752 CHECK_LEASE(&io, brokento, true, LEASE1);
753 CHECK_VAL(break_info.count, 0);
754 CHECK_VAL(break_info.failures, 0);
755
756 smb2_util_close(tree, h);
757 smb2_util_close(tree, h2);
758 smb2_util_close(tree, h3);
759
760 status = smb2_util_unlink(tree, fname);
761 CHECK_STATUS(status, NT_STATUS_OK);
762 }
763
764 done:
765 smb2_util_close(tree, h);
766 smb2_util_close(tree, h2);
767
768 smb2_util_unlink(tree, fname);
769
770 talloc_free(mem_ctx);
771
772 return ret;
773 }
774
775 static void torture_oplock_break_callback(struct smb2_request *req)
776 {
777 NTSTATUS status;
778 struct smb2_break br;
779
780 ZERO_STRUCT(br);
781 status = smb2_break_recv(req, &br);
782 if (!NT_STATUS_IS_OK(status))
783 break_info.oplock_failures++;
784
785 return;
786 }
787
788 /* a oplock break request handler */
789 static bool torture_oplock_handler(struct smb2_transport *transport,
790 const struct smb2_handle *handle,
791 uint8_t level, void *private_data)
792 {
793 struct smb2_tree *tree = private_data;
794 struct smb2_request *req;
795 struct smb2_break br;
796
797 break_info.oplock_handle = *handle;
798 break_info.oplock_level = level;
799 break_info.oplock_count++;
800
801 ZERO_STRUCT(br);
802 br.in.file.handle = *handle;
803 br.in.oplock_level = level;
804
805 if (break_info.held_oplock_level > SMB2_OPLOCK_LEVEL_II) {
806 req = smb2_break_send(tree, &br);
807 req->async.fn = torture_oplock_break_callback;
808 req->async.private_data = NULL;
809 }
810 break_info.held_oplock_level = level;
811
812 return true;
813 }
814
815 #define NOPLOCK_RESULTS 12
816 static const char *oplock_results[NOPLOCK_RESULTS][4] = {
817 {"R", "s", "R", "s"},
818 {"R", "x", "R", "s"},
819 {"R", "b", "R", "s"},
820
821 {"RH", "s", "RH", ""},
822 {"RH", "x", "RH", ""},
823 {"RH", "b", "RH", ""},
824
825 {"RW", "s", "R", "s"},
826 {"RW", "x", "R", "s"},
827 {"RW", "b", "R", "s"},
828
829 {"RHW", "s", "RH", ""},
830 {"RHW", "x", "RH", ""},
831 {"RHW", "b", "RH", ""},
832 };
833
834 static const char *oplock_results_2[NOPLOCK_RESULTS][4] = {
835 {"s", "R", "s", "R"},
836 {"s", "RH", "s", "R"},
837 {"s", "RW", "s", "R"},
838 {"s", "RHW", "s", "R"},
839
840 {"x", "R", "s", "R"},
841 {"x", "RH", "s", "R"},
842 {"x", "RW", "s", "R"},
843 {"x", "RHW", "s", "R"},
844
845 {"b", "R", "s", "R"},
846 {"b", "RH", "s", "R"},
847 {"b", "RW", "s", "R"},
848 {"b", "RHW", "s", "R"},
849 };
850
851 static bool test_lease_oplock(struct torture_context *tctx,
852 struct smb2_tree *tree)
853 {
854 TALLOC_CTX *mem_ctx = talloc_new(tctx);
855 struct smb2_create io;
856 struct smb2_lease ls;
857 struct smb2_handle h, h2;
858 NTSTATUS status;
859 const char *fname = "lease.dat";
860 bool ret = true;
861 int i;
862 uint32_t caps;
863
864 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
865 if (!(caps & SMB2_CAP_LEASING)) {
866 torture_skip(tctx, "leases are not supported");
867 }
868
869 tree->session->transport->lease.handler = torture_lease_handler;
870 tree->session->transport->lease.private_data = tree;
871 tree->session->transport->oplock.handler = torture_oplock_handler;
872 tree->session->transport->oplock.private_data = tree;
873
874 smb2_util_unlink(tree, fname);
875
876 for (i = 0; i < NOPLOCK_RESULTS; i++) {
877 const char *held = oplock_results[i][0];
878 const char *contend = oplock_results[i][1];
879 const char *brokento = oplock_results[i][2];
880 const char *granted = oplock_results[i][3];
881 torture_comment(tctx, "Hold %s(%x), requesting %s(%x), "
882 "expecting break to %s(%x) and grant of %s(%x)\n",
883 held, smb2_util_lease_state(held), contend, smb2_util_oplock_level(contend),
884 brokento, smb2_util_lease_state(brokento), granted, smb2_util_oplock_level(granted));
885
886 ZERO_STRUCT(break_info);
887
888 /* Grab lease. */
889 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(held));
890 status = smb2_create(tree, mem_ctx, &io);
891 CHECK_STATUS(status, NT_STATUS_OK);
892 h = io.out.file.handle;
893 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
894 CHECK_LEASE(&io, held, true, LEASE1);
895
896 /* Does an oplock contend the lease? */
897 smb2_oplock_create(&io, fname, smb2_util_oplock_level(contend));
898 status = smb2_create(tree, mem_ctx, &io);
899 CHECK_STATUS(status, NT_STATUS_OK);
900 h2 = io.out.file.handle;
901 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
902 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(granted));
903 break_info.held_oplock_level = io.out.oplock_level;
904
905 if (smb2_util_lease_state(held) != smb2_util_lease_state(brokento)) {
906 CHECK_BREAK_INFO(held, brokento, LEASE1);
907 } else {
908 CHECK_VAL(break_info.count, 0);
909 CHECK_VAL(break_info.failures, 0);
910 }
911
912 smb2_util_close(tree, h);
913 smb2_util_close(tree, h2);
914
915 status = smb2_util_unlink(tree, fname);
916 CHECK_STATUS(status, NT_STATUS_OK);
917 }
918
919 for (i = 0; i < NOPLOCK_RESULTS; i++) {
920 const char *held = oplock_results_2[i][0];
921 const char *contend = oplock_results_2[i][1];
922 const char *brokento = oplock_results_2[i][2];
923 const char *granted = oplock_results_2[i][3];
924 torture_comment(tctx, "Hold %s(%x), requesting %s(%x), "
925 "expecting break to %s(%x) and grant of %s(%x)\n",
926 held, smb2_util_oplock_level(held), contend, smb2_util_lease_state(contend),
927 brokento, smb2_util_oplock_level(brokento), granted, smb2_util_lease_state(granted));
928
929 ZERO_STRUCT(break_info);
930
931 /* Grab an oplock. */
932 smb2_oplock_create(&io, fname, smb2_util_oplock_level(held));
933 status = smb2_create(tree, mem_ctx, &io);
934 CHECK_STATUS(status, NT_STATUS_OK);
935 h = io.out.file.handle;
936 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
937 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(held));
938 break_info.held_oplock_level = io.out.oplock_level;
939
940 /* Grab lease. */
941 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state(contend));
942 status = smb2_create(tree, mem_ctx, &io);
943 CHECK_STATUS(status, NT_STATUS_OK);
944 h2 = io.out.file.handle;
945 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
946 CHECK_LEASE(&io, granted, true, LEASE1);
947
948 if (smb2_util_oplock_level(held) != smb2_util_oplock_level(brokento)) {
949 CHECK_VAL(break_info.oplock_count, 1);
950 CHECK_VAL(break_info.oplock_failures, 0);
951 CHECK_VAL(break_info.oplock_level, smb2_util_oplock_level(brokento));
952 break_info.held_oplock_level = break_info.oplock_level;
953 } else {
954 CHECK_VAL(break_info.oplock_count, 0);
955 CHECK_VAL(break_info.oplock_failures, 0);
956 }
957
958 smb2_util_close(tree, h);
959 smb2_util_close(tree, h2);
960
961 status = smb2_util_unlink(tree, fname);
962 CHECK_STATUS(status, NT_STATUS_OK);
963 }
964
965 done:
966 smb2_util_close(tree, h);
967 smb2_util_close(tree, h2);
968
969 smb2_util_unlink(tree, fname);
970
971 talloc_free(mem_ctx);
972
973 return ret;
974 }
975
976 static bool test_lease_multibreak(struct torture_context *tctx,
977 struct smb2_tree *tree)
978 {
979 TALLOC_CTX *mem_ctx = talloc_new(tctx);
980 struct smb2_create io;
981 struct smb2_lease ls;
982 struct smb2_handle h, h2, h3;
983 struct smb2_write w;
984 NTSTATUS status;
985 const char *fname = "lease.dat";
986 bool ret = true;
987 uint32_t caps;
988
989 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
990 if (!(caps & SMB2_CAP_LEASING)) {
991 torture_skip(tctx, "leases are not supported");
992 }
993
994 tree->session->transport->lease.handler = torture_lease_handler;
995 tree->session->transport->lease.private_data = tree;
996 tree->session->transport->oplock.handler = torture_oplock_handler;
997 tree->session->transport->oplock.private_data = tree;
998
999 smb2_util_unlink(tree, fname);
1000
1001 ZERO_STRUCT(break_info);
1002
1003 /* Grab lease, upgrade to RHW .. */
1004 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RH"));
1005 status = smb2_create(tree, mem_ctx, &io);
1006 CHECK_STATUS(status, NT_STATUS_OK);
1007 h = io.out.file.handle;
1008 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1009 CHECK_LEASE(&io, "RH", true, LEASE1);
1010
1011 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("RHW"));
1012 status = smb2_create(tree, mem_ctx, &io);
1013 CHECK_STATUS(status, NT_STATUS_OK);
1014 h2 = io.out.file.handle;
1015 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1016 CHECK_LEASE(&io, "RHW", true, LEASE1);
1017
1018 /* Contend with LEASE2. */
1019 smb2_lease_create(&io, &ls, false, fname, LEASE2, smb2_util_lease_state("RHW"));
1020 status = smb2_create(tree, mem_ctx, &io);
1021 CHECK_STATUS(status, NT_STATUS_OK);
1022 h3 = io.out.file.handle;
1023 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1024 CHECK_LEASE(&io, "RH", true, LEASE2);
1025
1026 /* Verify that we were only sent one break. */
1027 CHECK_BREAK_INFO("RHW", "RH", LEASE1);
1028
1029 /* Drop LEASE1 / LEASE2 */
1030 status = smb2_util_close(tree, h);
1031 CHECK_STATUS(status, NT_STATUS_OK);
1032 status = smb2_util_close(tree, h2);
1033 CHECK_STATUS(status, NT_STATUS_OK);
1034 status = smb2_util_close(tree, h3);
1035 CHECK_STATUS(status, NT_STATUS_OK);
1036
1037 ZERO_STRUCT(break_info);
1038
1039 /* Grab an R lease. */
1040 smb2_lease_create(&io, &ls, false, fname, LEASE1, smb2_util_lease_state("R"));
1041 status = smb2_create(tree, mem_ctx, &io);
1042 CHECK_STATUS(status, NT_STATUS_OK);
1043 h = io.out.file.handle;
1044 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1045 CHECK_LEASE(&io, "R", true, LEASE1);
1046
1047 /* Grab a level-II oplock. */
1048 smb2_oplock_create(&io, fname, smb2_util_oplock_level("s"));
1049 status = smb2_create(tree, mem_ctx, &io);
1050 CHECK_STATUS(status, NT_STATUS_OK);
1051 h2 = io.out.file.handle;
1052 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_ARCHIVE);
1053 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level("s"));
1054 break_info.held_oplock_level = io.out.oplock_level;
1055
1056 /* Verify no breaks. */
1057 CHECK_VAL(break_info.count, 0);
1058 CHECK_VAL(break_info.failures, 0);
1059
1060 /* Open for truncate, force a break. */
1061 smb2_generic_create(&io, NULL, false, fname,
1062 NTCREATEX_DISP_OVERWRITE_IF, smb2_util_oplock_level(""), 0, 0);
1063 status = smb2_create(tree, mem_ctx, &io);
1064 CHECK_STATUS(status, NT_STATUS_OK);
1065 h3 = io.out.file.handle;
1066 CHECK_CREATED(&io, TRUNCATED, FILE_ATTRIBUTE_ARCHIVE);
1067 CHECK_VAL(io.out.oplock_level, smb2_util_oplock_level(""));
1068 break_info.held_oplock_level = io.out.oplock_level;
1069
1070 /* Sleep, use a write to clear the recv queue. */
1071 smb_msleep(250);
1072 ZERO_STRUCT(w);
1073 w.in.file.handle = h3;
1074 w.in.offset = 0;
1075 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
1076 memset(w.in.data.data, 'o', w.in.data.length);
1077 status = smb2_write(tree, &w);
1078 CHECK_STATUS(status, NT_STATUS_OK);
1079
1080 /* Verify one oplock break, one lease break. */
1081 CHECK_VAL(break_info.oplock_count, 1);
1082 CHECK_VAL(break_info.oplock_failures, 0);
1083 CHECK_VAL(break_info.oplock_level, smb2_util_oplock_level(""));
1084 CHECK_BREAK_INFO("R", "", LEASE1);
1085
1086 done:
1087 smb2_util_close(tree, h);
1088 smb2_util_close(tree, h2);
1089 smb2_util_close(tree, h3);
1090
1091 smb2_util_unlink(tree, fname);
1092
1093 talloc_free(mem_ctx);
1094
1095 return ret;
1096 }
1097
1098 static bool test_lease_v2_request_parent(struct torture_context *tctx,
1099 struct smb2_tree *tree)
1100 {
1101 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1102 struct smb2_create io;
1103 struct smb2_lease ls;
1104 struct smb2_handle h1;
1105 uint64_t parent = LEASE2;
1106 NTSTATUS status;
1107 const char *fname = "lease.dat";
1108 bool ret = true;
1109
1110 smb2_util_unlink(tree, fname);
1111
1112 ZERO_STRUCT(break_info);
1113
1114 ZERO_STRUCT(io);
1115 smb2_lease_v2_create_share(&io, &ls, false, fname,
1116 smb2_util_share_access("RWD"),
1117 LEASE1, &parent,
1118 smb2_util_lease_state("RHW"),
1119 0);
1120
1121 status = smb2_create(tree, mem_ctx, &io);
1122 CHECK_STATUS(status, NT_STATUS_OK);
1123 h1 = io.out.file.handle;
1124 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1125 CHECK_LEASE_V2(&io, "RHW", true, LEASE1,
1126 SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET, LEASE2);
1127
1128 done:
1129 smb2_util_close(tree, h1);
1130 smb2_util_unlink(tree, fname);
1131
1132 talloc_free(mem_ctx);
1133
1134 return ret;
1135 }
1136
1137 static bool test_lease_break_twice(struct torture_context *tctx,
1138 struct smb2_tree *tree)
1139 {
1140 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1141 struct smb2_create io;
1142 struct smb2_lease ls;
1143 struct smb2_handle h1;
1144 NTSTATUS status;
1145 const char *fname = "lease.dat";
1146 bool ret = true;
1147 uint32_t caps;
1148
1149 caps = smb2cli_conn_server_capabilities(
1150 tree->session->transport->conn);
1151 if (!(caps & SMB2_CAP_LEASING)) {
1152 torture_skip(tctx, "leases are not supported");
1153 }
1154
1155 smb2_util_unlink(tree, fname);
1156
1157 ZERO_STRUCT(break_info);
1158 ZERO_STRUCT(io);
1159 ZERO_STRUCT(ls);
1160
1161 smb2_lease_v2_create_share(
1162 &io, &ls, false, fname, smb2_util_share_access("RWD"),
1163 LEASE1, NULL, smb2_util_lease_state("RWH"), 0);
1164
1165 status = smb2_create(tree, mem_ctx, &io);
1166 CHECK_STATUS(status, NT_STATUS_OK);
1167 h1 = io.out.file.handle;
1168 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1169 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0);
1170
1171 tree->session->transport->lease.handler = torture_lease_handler;
1172 tree->session->transport->lease.private_data = tree;
1173
1174 ZERO_STRUCT(break_info);
1175
1176 smb2_lease_v2_create_share(
1177 &io, &ls, false, fname, smb2_util_share_access("R"),
1178 LEASE2, NULL, smb2_util_lease_state("RWH"), 0);
1179
1180 status = smb2_create(tree, mem_ctx, &io);
1181 CHECK_STATUS(status, NT_STATUS_SHARING_VIOLATION);
1182 CHECK_BREAK_INFO("RWH", "RW", LEASE1);
1183
1184 smb2_lease_v2_create_share(
1185 &io, &ls, false, fname, smb2_util_share_access("RWD"),
1186 LEASE2, NULL, smb2_util_lease_state("RWH"), 0);
1187
1188 ZERO_STRUCT(break_info);
1189
1190 status = smb2_create(tree, mem_ctx, &io);
1191 CHECK_STATUS(status, NT_STATUS_OK);
1192 CHECK_BREAK_INFO("RW", "R", LEASE1);
1193
1194 done:
1195 smb2_util_close(tree, h1);
1196 smb2_util_unlink(tree, fname);
1197 talloc_free(mem_ctx);
1198 return ret;
1199 }
1200
1201 static bool test_lease_v2_request(struct torture_context *tctx,
1202 struct smb2_tree *tree)
1203 {
1204 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1205 struct smb2_create io;
1206 struct smb2_lease ls;
1207 struct smb2_handle h1, h2, h3, h4, h5;
1208 struct smb2_write w;
1209 NTSTATUS status;
1210 const char *fname = "lease.dat";
1211 const char *dname = "lease.dir";
1212 const char *dnamefname = "lease.dir\\lease.dat";
1213 const char *dnamefname2 = "lease.dir\\lease2.dat";
1214 bool ret = true;
1215
1216 smb2_util_unlink(tree, fname);
1217 smb2_deltree(tree, dname);
1218
1219 tree->session->transport->lease.handler = torture_lease_handler;
1220 tree->session->transport->lease.private_data = tree;
1221 tree->session->transport->oplock.handler = torture_oplock_handler;
1222 tree->session->transport->oplock.private_data = tree;
1223
1224 ZERO_STRUCT(break_info);
1225
1226 ZERO_STRUCT(io);
1227 smb2_lease_v2_create_share(&io, &ls, false, fname,
1228 smb2_util_share_access("RWD"),
1229 LEASE1, NULL,
1230 smb2_util_lease_state("RHW"),
1231 0);
1232
1233 status = smb2_create(tree, mem_ctx, &io);
1234 CHECK_STATUS(status, NT_STATUS_OK);
1235 h1 = io.out.file.handle;
1236 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1237 CHECK_LEASE_V2(&io, "RHW", true, LEASE1, 0, 0);
1238
1239 ZERO_STRUCT(io);
1240 smb2_lease_v2_create_share(&io, &ls, true, dname,
1241 smb2_util_share_access("RWD"),
1242 LEASE2, NULL,
1243 smb2_util_lease_state("RHW"),
1244 0);
1245 status = smb2_create(tree, mem_ctx, &io);
1246 CHECK_STATUS(status, NT_STATUS_OK);
1247 h2 = io.out.file.handle;
1248 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_DIRECTORY);
1249 CHECK_LEASE_V2(&io, "RH", true, LEASE2, 0, 0);
1250
1251 ZERO_STRUCT(io);
1252 smb2_lease_v2_create_share(&io, &ls, false, dnamefname,
1253 smb2_util_share_access("RWD"),
1254 LEASE3, &LEASE2,
1255 smb2_util_lease_state("RHW"),
1256 0);
1257 status = smb2_create(tree, mem_ctx, &io);
1258 CHECK_STATUS(status, NT_STATUS_OK);
1259 h3 = io.out.file.handle;
1260 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1261 CHECK_LEASE_V2(&io, "RHW", true, LEASE3,
1262 SMB2_LEASE_FLAG_PARENT_LEASE_KEY_SET, LEASE2);
1263
1264 torture_wait_for_lease_break(tctx);
1265 CHECK_VAL(break_info.count, 0);
1266 CHECK_VAL(break_info.failures, 0);
1267
1268 ZERO_STRUCT(io);
1269 smb2_lease_v2_create_share(&io, &ls, false, dnamefname2,
1270 smb2_util_share_access("RWD"),
1271 LEASE4, NULL,
1272 smb2_util_lease_state("RHW"),
1273 0);
1274 status = smb2_create(tree, mem_ctx, &io);
1275 CHECK_STATUS(status, NT_STATUS_OK);
1276 h4 = io.out.file.handle;
1277 CHECK_CREATED(&io, CREATED, FILE_ATTRIBUTE_ARCHIVE);
1278 CHECK_LEASE_V2(&io, "RHW", true, LEASE4, 0, 0);
1279
1280 torture_wait_for_lease_break(tctx);
1281 torture_wait_for_lease_break(tctx);
1282 CHECK_BREAK_INFO("RH", "", LEASE2);
1283 torture_wait_for_lease_break(tctx);
1284
1285 ZERO_STRUCT(break_info);
1286
1287 ZERO_STRUCT(io);
1288 smb2_lease_v2_create_share(&io, &ls, true, dname,
1289 smb2_util_share_access("RWD"),
1290 LEASE2, NULL,
1291 smb2_util_lease_state("RHW"),
1292 0);
1293 io.in.create_disposition = NTCREATEX_DISP_OPEN;
1294 status = smb2_create(tree, mem_ctx, &io);
1295 CHECK_STATUS(status, NT_STATUS_OK);
1296 h5 = io.out.file.handle;
1297 CHECK_CREATED(&io, EXISTED, FILE_ATTRIBUTE_DIRECTORY);
1298 CHECK_LEASE_V2(&io, "RH", true, LEASE2, 0, 0);
1299 smb2_util_close(tree, h5);
1300
1301 ZERO_STRUCT(w);
1302 w.in.file.handle = h4;
1303 w.in.offset = 0;
1304 w.in.data = data_blob_talloc(mem_ctx, NULL, 4096);
1305 memset(w.in.data.data, 'o', w.in.data.length);
1306 status = smb2_write(tree, &w);
1307 CHECK_STATUS(status, NT_STATUS_OK);
1308
1309 smb_msleep(2000);
1310 torture_wait_for_lease_break(tctx);
1311 CHECK_VAL(break_info.count, 0);
1312 CHECK_VAL(break_info.failures, 0);
1313
1314 smb2_util_close(tree, h4);
1315 torture_wait_for_lease_break(tctx);
1316 torture_wait_for_lease_break(tctx);
1317 CHECK_BREAK_INFO("RH", "", LEASE2);
1318 torture_wait_for_lease_break(tctx);
1319
1320 done:
1321 smb2_util_close(tree, h1);
1322 smb2_util_close(tree, h2);
1323 smb2_util_close(tree, h3);
1324 smb2_util_close(tree, h4);
1325 smb2_util_close(tree, h5);
1326
1327 smb2_util_unlink(tree, fname);
1328 smb2_deltree(tree, dname);
1329
1330 talloc_free(mem_ctx);
1331
1332 return ret;
1333 }
1334
1335 struct torture_suite *torture_smb2_lease_init(void)
1336 {
1337 struct torture_suite *suite =
1338 torture_suite_create(talloc_autofree_context(), "lease");
1339
1340 torture_suite_add_1smb2_test(suite, "request", test_lease_request);
1341 torture_suite_add_1smb2_test(suite, "break_twice",
1342 test_lease_break_twice);
1343 torture_suite_add_1smb2_test(suite, "upgrade", test_lease_upgrade);
1344 torture_suite_add_1smb2_test(suite, "upgrade2", test_lease_upgrade2);
1345 torture_suite_add_1smb2_test(suite, "upgrade3", test_lease_upgrade3);
1346 torture_suite_add_1smb2_test(suite, "break", test_lease_break);
1347 torture_suite_add_1smb2_test(suite, "oplock", test_lease_oplock);
1348 torture_suite_add_1smb2_test(suite, "multibreak", test_lease_multibreak);
1349 torture_suite_add_1smb2_test(suite, "v2_request_parent",
1350 test_lease_v2_request_parent);
1351 torture_suite_add_1smb2_test(suite, "v2_request", test_lease_v2_request);
1352
1353 suite->description = talloc_strdup(suite, "SMB2-LEASE tests");
1354
1355 return suite;
1356 }
Samba GIT mirror