?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
lib: tevent: Use system <tevent.h>, not internal header path (except in self-test).
[Samba.git] / source4 / torture / smb2 / ioctl.c
blob90171e98ac2bb4db98e920be6e1f05a79769ced4
1 /*
2 Unix SMB/CIFS implementation.
3
4 test suite for SMB2 ioctl operations
5
6 Copyright (C) David Disseldorp 2011-2016
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 "librpc/gen_ndr/security.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 #include "librpc/gen_ndr/ndr_ioctl.h"
30
31 #define FNAME "testfsctl.dat"
32 #define FNAME2 "testfsctl2.dat"
33 #define DNAME "testfsctl_dir"
34
35 /*
36 basic testing of SMB2 shadow copy calls
37 */
38 static bool test_ioctl_get_shadow_copy(struct torture_context *torture,
39 struct smb2_tree *tree)
40 {
41 struct smb2_handle h;
42 uint8_t buf[100];
43 NTSTATUS status;
44 union smb_ioctl ioctl;
45 TALLOC_CTX *tmp_ctx = talloc_new(tree);
46
47 smb2_util_unlink(tree, FNAME);
48
49 status = torture_smb2_testfile(tree, FNAME, &h);
50 torture_assert_ntstatus_ok(torture, status, "create write");
51
52 ZERO_ARRAY(buf);
53 status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
54 torture_assert_ntstatus_ok(torture, status, "write");
55
56 ZERO_STRUCT(ioctl);
57 ioctl.smb2.level = RAW_IOCTL_SMB2;
58 ioctl.smb2.in.file.handle = h;
59 ioctl.smb2.in.function = FSCTL_SRV_ENUM_SNAPS;
60 ioctl.smb2.in.max_response_size = 16;
61 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
62
63 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
64 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_SUPPORTED)
65 || NT_STATUS_EQUAL(status, NT_STATUS_INVALID_DEVICE_REQUEST)) {
66 torture_skip(torture, "FSCTL_SRV_ENUM_SNAPS not supported\n");
67 }
68 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_ENUM_SNAPS");
69
70 return true;
71 }
72
73 /*
74 basic testing of the SMB2 server side copy ioctls
75 */
76 static bool test_ioctl_req_resume_key(struct torture_context *torture,
77 struct smb2_tree *tree)
78 {
79 struct smb2_handle h;
80 uint8_t buf[100];
81 NTSTATUS status;
82 union smb_ioctl ioctl;
83 TALLOC_CTX *tmp_ctx = talloc_new(tree);
84 struct req_resume_key_rsp res_key;
85 enum ndr_err_code ndr_ret;
86
87 smb2_util_unlink(tree, FNAME);
88
89 status = torture_smb2_testfile(tree, FNAME, &h);
90 torture_assert_ntstatus_ok(torture, status, "create write");
91
92 ZERO_ARRAY(buf);
93 status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
94 torture_assert_ntstatus_ok(torture, status, "write");
95
96 ZERO_STRUCT(ioctl);
97 ioctl.smb2.level = RAW_IOCTL_SMB2;
98 ioctl.smb2.in.file.handle = h;
99 ioctl.smb2.in.function = FSCTL_SRV_REQUEST_RESUME_KEY;
100 ioctl.smb2.in.max_response_size = 32;
101 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
102
103 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
104 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_REQUEST_RESUME_KEY");
105
106 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx, &res_key,
107 (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
108 torture_assert_ndr_success(torture, ndr_ret,
109 "ndr_pull_req_resume_key_rsp");
110
111 ndr_print_debug((ndr_print_fn_t)ndr_print_req_resume_key_rsp, "yo", &res_key);
112
113 talloc_free(tmp_ctx);
114 return true;
115 }
116
117 /*
118 testing fetching a resume key twice for one file handle
119 */
120 static bool test_ioctl_req_two_resume_keys(struct torture_context *torture,
121 struct smb2_tree *tree)
122 {
123 struct smb2_handle h;
124 uint8_t buf[100];
125 NTSTATUS status;
126 union smb_ioctl ioctl;
127 TALLOC_CTX *tmp_ctx = talloc_new(tree);
128 struct req_resume_key_rsp res_key;
129 enum ndr_err_code ndr_ret;
130
131 smb2_util_unlink(tree, FNAME);
132
133 status = torture_smb2_testfile(tree, FNAME, &h);
134 torture_assert_ntstatus_ok(torture, status, "create write");
135
136 ZERO_ARRAY(buf);
137 status = smb2_util_write(tree, h, buf, 0, ARRAY_SIZE(buf));
138 torture_assert_ntstatus_ok(torture, status, "write");
139
140 ZERO_STRUCT(ioctl);
141 ioctl.smb2.level = RAW_IOCTL_SMB2;
142 ioctl.smb2.in.file.handle = h;
143 ioctl.smb2.in.function = FSCTL_SRV_REQUEST_RESUME_KEY;
144 ioctl.smb2.in.max_response_size = 32;
145 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
146
147 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
148 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_REQUEST_RESUME_KEY");
149
150 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx, &res_key,
151 (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
152 torture_assert_ndr_success(torture, ndr_ret,
153 "ndr_pull_req_resume_key_rsp");
154
155 ndr_print_debug((ndr_print_fn_t)ndr_print_req_resume_key_rsp, "yo", &res_key);
156
157 ZERO_STRUCT(ioctl);
158 ioctl.smb2.level = RAW_IOCTL_SMB2;
159 ioctl.smb2.in.file.handle = h;
160 ioctl.smb2.in.function = FSCTL_SRV_REQUEST_RESUME_KEY;
161 ioctl.smb2.in.max_response_size = 32;
162 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
163
164 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
165 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_REQUEST_RESUME_KEY");
166
167 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx, &res_key,
168 (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
169 torture_assert_ndr_success(torture, ndr_ret,
170 "ndr_pull_req_resume_key_rsp");
171
172 ndr_print_debug((ndr_print_fn_t)ndr_print_req_resume_key_rsp, "yo", &res_key);
173
174 talloc_free(tmp_ctx);
175 return true;
176 }
177
178 static uint64_t patt_hash(uint64_t off)
179 {
180 return off;
181 }
182
183 static bool write_pattern(struct torture_context *torture,
184 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
185 struct smb2_handle h, uint64_t off, uint64_t len,
186 uint64_t patt_off)
187 {
188 NTSTATUS status;
189 uint64_t i;
190 uint8_t *buf;
191 uint64_t io_sz = MIN(1024 * 64, len);
192
193 if (len == 0) {
194 return true;
195 }
196
197 torture_assert(torture, (len % 8) == 0, "invalid write len");
198
199 buf = talloc_zero_size(mem_ctx, io_sz);
200 torture_assert(torture, (buf != NULL), "no memory for file data buf");
201
202 while (len > 0) {
203 for (i = 0; i <= io_sz - 8; i += 8) {
204 SBVAL(buf, i, patt_hash(patt_off));
205 patt_off += 8;
206 }
207
208 status = smb2_util_write(tree, h,
209 buf, off, io_sz);
210 torture_assert_ntstatus_ok(torture, status, "file write");
211
212 len -= io_sz;
213 off += io_sz;
214 }
215
216 talloc_free(buf);
217
218 return true;
219 }
220
221 static bool check_pattern(struct torture_context *torture,
222 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
223 struct smb2_handle h, uint64_t off, uint64_t len,
224 uint64_t patt_off)
225 {
226 if (len == 0) {
227 return true;
228 }
229
230 torture_assert(torture, (len % 8) == 0, "invalid read len");
231
232 while (len > 0) {
233 uint64_t i;
234 struct smb2_read r;
235 NTSTATUS status;
236 uint64_t io_sz = MIN(1024 * 64, len);
237
238 ZERO_STRUCT(r);
239 r.in.file.handle = h;
240 r.in.length = io_sz;
241 r.in.offset = off;
242 status = smb2_read(tree, mem_ctx, &r);
243 torture_assert_ntstatus_ok(torture, status, "read");
244
245 torture_assert_u64_equal(torture, r.out.data.length, io_sz,
246 "read data len mismatch");
247
248 for (i = 0; i <= io_sz - 8; i += 8, patt_off += 8) {
249 uint64_t data = BVAL(r.out.data.data, i);
250 torture_assert_u64_equal(torture, data, patt_hash(patt_off),
251 talloc_asprintf(torture, "read data "
252 "pattern bad at %llu\n",
253 (unsigned long long)off + i));
254 }
255 talloc_free(r.out.data.data);
256 len -= io_sz;
257 off += io_sz;
258 }
259
260 return true;
261 }
262
263 static bool check_zero(struct torture_context *torture,
264 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
265 struct smb2_handle h, uint64_t off, uint64_t len)
266 {
267 uint64_t i;
268 struct smb2_read r;
269 NTSTATUS status;
270
271 if (len == 0) {
272 return true;
273 }
274
275 ZERO_STRUCT(r);
276 r.in.file.handle = h;
277 r.in.length = len;
278 r.in.offset = off;
279 status = smb2_read(tree, mem_ctx, &r);
280 torture_assert_ntstatus_ok(torture, status, "read");
281
282 torture_assert_u64_equal(torture, r.out.data.length, len,
283 "read data len mismatch");
284
285 for (i = 0; i <= len - 8; i += 8) {
286 uint64_t data = BVAL(r.out.data.data, i);
287 torture_assert_u64_equal(torture, data, 0,
288 talloc_asprintf(mem_ctx, "read zero "
289 "bad at %llu\n",
290 (unsigned long long)i));
291 }
292
293 talloc_free(r.out.data.data);
294 return true;
295 }
296
297 static bool test_setup_open(struct torture_context *torture,
298 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
299 const char *fname,
300 struct smb2_handle *fh,
301 uint32_t desired_access,
302 uint32_t file_attributes)
303 {
304 struct smb2_create io;
305 NTSTATUS status;
306
307 ZERO_STRUCT(io);
308 io.in.desired_access = desired_access;
309 io.in.file_attributes = file_attributes;
310 io.in.create_disposition = NTCREATEX_DISP_OPEN_IF;
311 io.in.share_access =
312 NTCREATEX_SHARE_ACCESS_DELETE|
313 NTCREATEX_SHARE_ACCESS_READ|
314 NTCREATEX_SHARE_ACCESS_WRITE;
315 if (file_attributes & FILE_ATTRIBUTE_DIRECTORY) {
316 io.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
317 }
318 io.in.fname = fname;
319
320 status = smb2_create(tree, mem_ctx, &io);
321 torture_assert_ntstatus_ok(torture, status, "file create");
322
323 *fh = io.out.file.handle;
324
325 return true;
326 }
327
328 static bool test_setup_create_fill(struct torture_context *torture,
329 struct smb2_tree *tree, TALLOC_CTX *mem_ctx,
330 const char *fname,
331 struct smb2_handle *fh,
332 uint64_t size,
333 uint32_t desired_access,
334 uint32_t file_attributes)
335 {
336 bool ok;
337 uint32_t initial_access = desired_access;
338
339 if (size > 0) {
340 initial_access |= SEC_FILE_APPEND_DATA;
341 }
342
343 smb2_util_unlink(tree, fname);
344
345 ok = test_setup_open(torture, tree, mem_ctx,
346 fname,
347 fh,
348 initial_access,
349 file_attributes);
350 torture_assert(torture, ok, "file create");
351
352 if (size > 0) {
353 ok = write_pattern(torture, tree, mem_ctx, *fh, 0, size, 0);
354 torture_assert(torture, ok, "write pattern");
355 }
356
357 if (initial_access != desired_access) {
358 smb2_util_close(tree, *fh);
359 ok = test_setup_open(torture, tree, mem_ctx,
360 fname,
361 fh,
362 desired_access,
363 file_attributes);
364 torture_assert(torture, ok, "file open");
365 }
366
367 return true;
368 }
369
370 static bool test_setup_copy_chunk(struct torture_context *torture,
371 struct smb2_tree *src_tree,
372 struct smb2_tree *dst_tree,
373 TALLOC_CTX *mem_ctx,
374 uint32_t nchunks,
375 const char *src_name,
376 struct smb2_handle *src_h,
377 uint64_t src_size,
378 uint32_t src_desired_access,
379 const char *dst_name,
380 struct smb2_handle *dest_h,
381 uint64_t dest_size,
382 uint32_t dest_desired_access,
383 struct srv_copychunk_copy *cc_copy,
384 union smb_ioctl *ioctl)
385 {
386 struct req_resume_key_rsp res_key;
387 bool ok;
388 NTSTATUS status;
389 enum ndr_err_code ndr_ret;
390
391 ok = test_setup_create_fill(torture, src_tree, mem_ctx, src_name,
392 src_h, src_size, src_desired_access,
393 FILE_ATTRIBUTE_NORMAL);
394 torture_assert(torture, ok, "src file create fill");
395
396 ok = test_setup_create_fill(torture, dst_tree, mem_ctx, dst_name,
397 dest_h, dest_size, dest_desired_access,
398 FILE_ATTRIBUTE_NORMAL);
399 torture_assert(torture, ok, "dest file create fill");
400
401 ZERO_STRUCTPN(ioctl);
402 ioctl->smb2.level = RAW_IOCTL_SMB2;
403 ioctl->smb2.in.file.handle = *src_h;
404 ioctl->smb2.in.function = FSCTL_SRV_REQUEST_RESUME_KEY;
405 /* Allow for Key + ContextLength + Context */
406 ioctl->smb2.in.max_response_size = 32;
407 ioctl->smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
408
409 status = smb2_ioctl(src_tree, mem_ctx, &ioctl->smb2);
410 torture_assert_ntstatus_ok(torture, status,
411 "FSCTL_SRV_REQUEST_RESUME_KEY");
412
413 ndr_ret = ndr_pull_struct_blob(&ioctl->smb2.out.out, mem_ctx, &res_key,
414 (ndr_pull_flags_fn_t)ndr_pull_req_resume_key_rsp);
415
416 torture_assert_ndr_success(torture, ndr_ret,
417 "ndr_pull_req_resume_key_rsp");
418
419 ZERO_STRUCTPN(ioctl);
420 ioctl->smb2.level = RAW_IOCTL_SMB2;
421 ioctl->smb2.in.file.handle = *dest_h;
422 ioctl->smb2.in.function = FSCTL_SRV_COPYCHUNK;
423 ioctl->smb2.in.max_response_size = sizeof(struct srv_copychunk_rsp);
424 ioctl->smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
425
426 ZERO_STRUCTPN(cc_copy);
427 memcpy(cc_copy->source_key, res_key.resume_key, ARRAY_SIZE(cc_copy->source_key));
428 cc_copy->chunk_count = nchunks;
429 cc_copy->chunks = talloc_zero_array(mem_ctx, struct srv_copychunk, nchunks);
430 torture_assert(torture, (cc_copy->chunks != NULL), "no memory for chunks");
431
432 return true;
433 }
434
435
436 static bool check_copy_chunk_rsp(struct torture_context *torture,
437 struct srv_copychunk_rsp *cc_rsp,
438 uint32_t ex_chunks_written,
439 uint32_t ex_chunk_bytes_written,
440 uint32_t ex_total_bytes_written)
441 {
442 torture_assert_int_equal(torture, cc_rsp->chunks_written,
443 ex_chunks_written, "num chunks");
444 torture_assert_int_equal(torture, cc_rsp->chunk_bytes_written,
445 ex_chunk_bytes_written, "chunk bytes written");
446 torture_assert_int_equal(torture, cc_rsp->total_bytes_written,
447 ex_total_bytes_written, "chunk total bytes");
448 return true;
449 }
450
451 static bool test_ioctl_copy_chunk_simple(struct torture_context *torture,
452 struct smb2_tree *tree)
453 {
454 struct smb2_handle src_h;
455 struct smb2_handle dest_h;
456 NTSTATUS status;
457 union smb_ioctl ioctl;
458 TALLOC_CTX *tmp_ctx = talloc_new(tree);
459 struct srv_copychunk_copy cc_copy;
460 struct srv_copychunk_rsp cc_rsp;
461 enum ndr_err_code ndr_ret;
462 bool ok;
463
464 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
465 1, /* 1 chunk */
466 FNAME,
467 &src_h, 4096, /* fill 4096 byte src file */
468 SEC_RIGHTS_FILE_ALL,
469 FNAME2,
470 &dest_h, 0, /* 0 byte dest file */
471 SEC_RIGHTS_FILE_ALL,
472 &cc_copy,
473 &ioctl);
474 if (!ok) {
475 torture_fail(torture, "setup copy chunk error");
476 }
477
478 /* copy all src file data (via a single chunk desc) */
479 cc_copy.chunks[0].source_off = 0;
480 cc_copy.chunks[0].target_off = 0;
481 cc_copy.chunks[0].length = 4096;
482
483 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
484 &cc_copy,
485 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
486 torture_assert_ndr_success(torture, ndr_ret,
487 "ndr_push_srv_copychunk_copy");
488
489 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
490 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_COPYCHUNK");
491
492 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
493 &cc_rsp,
494 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
495 torture_assert_ndr_success(torture, ndr_ret,
496 "ndr_pull_srv_copychunk_rsp");
497
498 ok = check_copy_chunk_rsp(torture, &cc_rsp,
499 1, /* chunks written */
500 0, /* chunk bytes unsuccessfully written */
501 4096); /* total bytes written */
502 if (!ok) {
503 torture_fail(torture, "bad copy chunk response data");
504 }
505
506 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 4096, 0);
507 if (!ok) {
508 torture_fail(torture, "inconsistent file data");
509 }
510
511 smb2_util_close(tree, src_h);
512 smb2_util_close(tree, dest_h);
513 talloc_free(tmp_ctx);
514 return true;
515 }
516
517 static bool test_ioctl_copy_chunk_multi(struct torture_context *torture,
518 struct smb2_tree *tree)
519 {
520 struct smb2_handle src_h;
521 struct smb2_handle dest_h;
522 NTSTATUS status;
523 union smb_ioctl ioctl;
524 TALLOC_CTX *tmp_ctx = talloc_new(tree);
525 struct srv_copychunk_copy cc_copy;
526 struct srv_copychunk_rsp cc_rsp;
527 enum ndr_err_code ndr_ret;
528 bool ok;
529
530 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
531 2, /* chunks */
532 FNAME,
533 &src_h, 8192, /* src file */
534 SEC_RIGHTS_FILE_ALL,
535 FNAME2,
536 &dest_h, 0, /* dest file */
537 SEC_RIGHTS_FILE_ALL,
538 &cc_copy,
539 &ioctl);
540 if (!ok) {
541 torture_fail(torture, "setup copy chunk error");
542 }
543
544 /* copy all src file data via two chunks */
545 cc_copy.chunks[0].source_off = 0;
546 cc_copy.chunks[0].target_off = 0;
547 cc_copy.chunks[0].length = 4096;
548
549 cc_copy.chunks[1].source_off = 4096;
550 cc_copy.chunks[1].target_off = 4096;
551 cc_copy.chunks[1].length = 4096;
552
553 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
554 &cc_copy,
555 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
556 torture_assert_ndr_success(torture, ndr_ret,
557 "ndr_push_srv_copychunk_copy");
558
559 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
560 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_COPYCHUNK");
561
562 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
563 &cc_rsp,
564 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
565 torture_assert_ndr_success(torture, ndr_ret,
566 "ndr_pull_srv_copychunk_rsp");
567
568 ok = check_copy_chunk_rsp(torture, &cc_rsp,
569 2, /* chunks written */
570 0, /* chunk bytes unsuccessfully written */
571 8192); /* total bytes written */
572 if (!ok) {
573 torture_fail(torture, "bad copy chunk response data");
574 }
575
576 smb2_util_close(tree, src_h);
577 smb2_util_close(tree, dest_h);
578 talloc_free(tmp_ctx);
579 return true;
580 }
581
582 static bool test_ioctl_copy_chunk_tiny(struct torture_context *torture,
583 struct smb2_tree *tree)
584 {
585 struct smb2_handle src_h;
586 struct smb2_handle dest_h;
587 NTSTATUS status;
588 union smb_ioctl ioctl;
589 TALLOC_CTX *tmp_ctx = talloc_new(tree);
590 struct srv_copychunk_copy cc_copy;
591 struct srv_copychunk_rsp cc_rsp;
592 enum ndr_err_code ndr_ret;
593 bool ok;
594
595 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
596 2, /* chunks */
597 FNAME,
598 &src_h, 96, /* src file */
599 SEC_RIGHTS_FILE_ALL,
600 FNAME2,
601 &dest_h, 0, /* dest file */
602 SEC_RIGHTS_FILE_ALL,
603 &cc_copy,
604 &ioctl);
605 if (!ok) {
606 torture_fail(torture, "setup copy chunk error");
607 }
608
609 /* copy all src file data via two chunks, sub block size chunks */
610 cc_copy.chunks[0].source_off = 0;
611 cc_copy.chunks[0].target_off = 0;
612 cc_copy.chunks[0].length = 48;
613
614 cc_copy.chunks[1].source_off = 48;
615 cc_copy.chunks[1].target_off = 48;
616 cc_copy.chunks[1].length = 48;
617
618 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
619 &cc_copy,
620 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
621 torture_assert_ndr_success(torture, ndr_ret,
622 "ndr_push_srv_copychunk_copy");
623
624 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
625 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_COPYCHUNK");
626
627 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
628 &cc_rsp,
629 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
630 torture_assert_ndr_success(torture, ndr_ret,
631 "ndr_pull_srv_copychunk_rsp");
632
633 ok = check_copy_chunk_rsp(torture, &cc_rsp,
634 2, /* chunks written */
635 0, /* chunk bytes unsuccessfully written */
636 96); /* total bytes written */
637 if (!ok) {
638 torture_fail(torture, "bad copy chunk response data");
639 }
640
641 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 96, 0);
642 if (!ok) {
643 torture_fail(torture, "inconsistent file data");
644 }
645
646 smb2_util_close(tree, src_h);
647 smb2_util_close(tree, dest_h);
648 talloc_free(tmp_ctx);
649 return true;
650 }
651
652 static bool test_ioctl_copy_chunk_over(struct torture_context *torture,
653 struct smb2_tree *tree)
654 {
655 struct smb2_handle src_h;
656 struct smb2_handle dest_h;
657 NTSTATUS status;
658 union smb_ioctl ioctl;
659 TALLOC_CTX *tmp_ctx = talloc_new(tree);
660 struct srv_copychunk_copy cc_copy;
661 struct srv_copychunk_rsp cc_rsp;
662 enum ndr_err_code ndr_ret;
663 bool ok;
664
665 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
666 2, /* chunks */
667 FNAME,
668 &src_h, 8192, /* src file */
669 SEC_RIGHTS_FILE_ALL,
670 FNAME2,
671 &dest_h, 4096, /* dest file */
672 SEC_RIGHTS_FILE_ALL,
673 &cc_copy,
674 &ioctl);
675 if (!ok) {
676 torture_fail(torture, "setup copy chunk error");
677 }
678
679 /* first chunk overwrites existing dest data */
680 cc_copy.chunks[0].source_off = 0;
681 cc_copy.chunks[0].target_off = 0;
682 cc_copy.chunks[0].length = 4096;
683
684 /* second chunk overwrites the first */
685 cc_copy.chunks[1].source_off = 4096;
686 cc_copy.chunks[1].target_off = 0;
687 cc_copy.chunks[1].length = 4096;
688
689 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
690 &cc_copy,
691 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
692 torture_assert_ndr_success(torture, ndr_ret,
693 "ndr_push_srv_copychunk_copy");
694
695 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
696 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_COPYCHUNK");
697
698 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
699 &cc_rsp,
700 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
701 torture_assert_ndr_success(torture, ndr_ret,
702 "ndr_pull_srv_copychunk_rsp");
703
704 ok = check_copy_chunk_rsp(torture, &cc_rsp,
705 2, /* chunks written */
706 0, /* chunk bytes unsuccessfully written */
707 8192); /* total bytes written */
708 if (!ok) {
709 torture_fail(torture, "bad copy chunk response data");
710 }
711
712 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 4096, 4096);
713 if (!ok) {
714 torture_fail(torture, "inconsistent file data");
715 }
716
717 smb2_util_close(tree, src_h);
718 smb2_util_close(tree, dest_h);
719 talloc_free(tmp_ctx);
720 return true;
721 }
722
723 static bool test_ioctl_copy_chunk_append(struct torture_context *torture,
724 struct smb2_tree *tree)
725 {
726 struct smb2_handle src_h;
727 struct smb2_handle dest_h;
728 NTSTATUS status;
729 union smb_ioctl ioctl;
730 TALLOC_CTX *tmp_ctx = talloc_new(tree);
731 struct srv_copychunk_copy cc_copy;
732 struct srv_copychunk_rsp cc_rsp;
733 enum ndr_err_code ndr_ret;
734 bool ok;
735
736 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
737 2, /* chunks */
738 FNAME,
739 &src_h, 4096, /* src file */
740 SEC_RIGHTS_FILE_ALL,
741 FNAME2,
742 &dest_h, 0, /* dest file */
743 SEC_RIGHTS_FILE_ALL,
744 &cc_copy,
745 &ioctl);
746 if (!ok) {
747 torture_fail(torture, "setup copy chunk error");
748 }
749
750 cc_copy.chunks[0].source_off = 0;
751 cc_copy.chunks[0].target_off = 0;
752 cc_copy.chunks[0].length = 4096;
753
754 /* second chunk appends the same data to the first */
755 cc_copy.chunks[1].source_off = 0;
756 cc_copy.chunks[1].target_off = 4096;
757 cc_copy.chunks[1].length = 4096;
758
759 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
760 &cc_copy,
761 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
762 torture_assert_ndr_success(torture, ndr_ret,
763 "ndr_push_srv_copychunk_copy");
764
765 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
766 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_COPYCHUNK");
767
768 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
769 &cc_rsp,
770 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
771 torture_assert_ndr_success(torture, ndr_ret,
772 "ndr_pull_srv_copychunk_rsp");
773
774 ok = check_copy_chunk_rsp(torture, &cc_rsp,
775 2, /* chunks written */
776 0, /* chunk bytes unsuccessfully written */
777 8192); /* total bytes written */
778 if (!ok) {
779 torture_fail(torture, "bad copy chunk response data");
780 }
781
782 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 4096, 0);
783 if (!ok) {
784 torture_fail(torture, "inconsistent file data");
785 }
786
787 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 4096, 4096, 0);
788 if (!ok) {
789 torture_fail(torture, "inconsistent file data");
790 }
791
792 smb2_util_close(tree, src_h);
793 smb2_util_close(tree, dest_h);
794 talloc_free(tmp_ctx);
795 return true;
796 }
797
798 static bool test_ioctl_copy_chunk_limits(struct torture_context *torture,
799 struct smb2_tree *tree)
800 {
801 struct smb2_handle src_h;
802 struct smb2_handle dest_h;
803 NTSTATUS status;
804 union smb_ioctl ioctl;
805 TALLOC_CTX *tmp_ctx = talloc_new(tree);
806 struct srv_copychunk_copy cc_copy;
807 struct srv_copychunk_rsp cc_rsp;
808 enum ndr_err_code ndr_ret;
809 bool ok;
810
811 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
812 1, /* chunks */
813 FNAME,
814 &src_h, 4096, /* src file */
815 SEC_RIGHTS_FILE_ALL,
816 FNAME2,
817 &dest_h, 0, /* dest file */
818 SEC_RIGHTS_FILE_ALL,
819 &cc_copy,
820 &ioctl);
821 if (!ok) {
822 torture_fail(torture, "setup copy chunk error");
823 }
824
825 /* send huge chunk length request */
826 cc_copy.chunks[0].source_off = 0;
827 cc_copy.chunks[0].target_off = 0;
828 cc_copy.chunks[0].length = UINT_MAX;
829
830 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
831 &cc_copy,
832 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
833 torture_assert_ndr_success(torture, ndr_ret, "marshalling request");
834
835 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
836 torture_assert_ntstatus_equal(torture, status,
837 NT_STATUS_INVALID_PARAMETER,
838 "bad oversize chunk response");
839
840 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
841 &cc_rsp,
842 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
843 torture_assert_ndr_success(torture, ndr_ret, "unmarshalling response");
844
845 torture_comment(torture, "limit max chunks, got %u\n",
846 cc_rsp.chunks_written);
847 torture_comment(torture, "limit max chunk len, got %u\n",
848 cc_rsp.chunk_bytes_written);
849 torture_comment(torture, "limit max total bytes, got %u\n",
850 cc_rsp.total_bytes_written);
851
852 smb2_util_close(tree, src_h);
853 smb2_util_close(tree, dest_h);
854 talloc_free(tmp_ctx);
855 return true;
856 }
857
858 static bool test_ioctl_copy_chunk_src_lck(struct torture_context *torture,
859 struct smb2_tree *tree)
860 {
861 struct smb2_handle src_h;
862 struct smb2_handle src_h2;
863 struct smb2_handle dest_h;
864 NTSTATUS status;
865 union smb_ioctl ioctl;
866 TALLOC_CTX *tmp_ctx = talloc_new(tree);
867 struct srv_copychunk_copy cc_copy;
868 struct srv_copychunk_rsp cc_rsp;
869 enum ndr_err_code ndr_ret;
870 bool ok;
871 struct smb2_lock lck;
872 struct smb2_lock_element el[1];
873
874 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
875 1, /* chunks */
876 FNAME,
877 &src_h, 4096, /* src file */
878 SEC_RIGHTS_FILE_ALL,
879 FNAME2,
880 &dest_h, 0, /* dest file */
881 SEC_RIGHTS_FILE_ALL,
882 &cc_copy,
883 &ioctl);
884 if (!ok) {
885 torture_fail(torture, "setup copy chunk error");
886 }
887
888 cc_copy.chunks[0].source_off = 0;
889 cc_copy.chunks[0].target_off = 0;
890 cc_copy.chunks[0].length = 4096;
891
892 /* open and lock the copychunk src file */
893 status = torture_smb2_testfile(tree, FNAME, &src_h2);
894 torture_assert_ntstatus_ok(torture, status, "2nd src open");
895
896 lck.in.lock_count = 0x0001;
897 lck.in.lock_sequence = 0x00000000;
898 lck.in.file.handle = src_h2;
899 lck.in.locks = el;
900 el[0].offset = cc_copy.chunks[0].source_off;
901 el[0].length = cc_copy.chunks[0].length;
902 el[0].reserved = 0;
903 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
904
905 status = smb2_lock(tree, &lck);
906 torture_assert_ntstatus_ok(torture, status, "lock");
907
908 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
909 &cc_copy,
910 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
911 torture_assert_ndr_success(torture, ndr_ret,
912 "ndr_push_srv_copychunk_copy");
913
914 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
915 /*
916 * 2k12 & Samba return lock_conflict, Windows 7 & 2k8 return success...
917 *
918 * Edgar Olougouna @ MS wrote:
919 * Regarding the FSCTL_SRV_COPYCHUNK and STATUS_FILE_LOCK_CONFLICT
920 * discrepancy observed between Windows versions, we confirm that the
921 * behavior change is expected.
922 *
923 * CopyChunk in Windows Server 2012 use regular Readfile/Writefile APIs
924 * to move the chunks from the source to the destination.
925 * These ReadFile/WriteFile APIs go through the byte-range lock checks,
926 * and this explains the observed STATUS_FILE_LOCK_CONFLICT error.
927 *
928 * Prior to Windows Server 2012, CopyChunk used mapped sections to move
929 * the data. And byte range locks are not enforced on mapped I/O, and
930 * this explains the STATUS_SUCCESS observed on Windows Server 2008 R2.
931 */
932 torture_assert_ntstatus_equal(torture, status,
933 NT_STATUS_FILE_LOCK_CONFLICT,
934 "FSCTL_SRV_COPYCHUNK locked");
935
936 /* should get cc response data with the lock conflict status */
937 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
938 &cc_rsp,
939 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
940 torture_assert_ndr_success(torture, ndr_ret,
941 "ndr_pull_srv_copychunk_rsp");
942 ok = check_copy_chunk_rsp(torture, &cc_rsp,
943 0, /* chunks written */
944 0, /* chunk bytes unsuccessfully written */
945 0); /* total bytes written */
946
947 lck.in.lock_count = 0x0001;
948 lck.in.lock_sequence = 0x00000001;
949 lck.in.file.handle = src_h2;
950 lck.in.locks = el;
951 el[0].offset = cc_copy.chunks[0].source_off;
952 el[0].length = cc_copy.chunks[0].length;
953 el[0].reserved = 0;
954 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
955 status = smb2_lock(tree, &lck);
956 torture_assert_ntstatus_ok(torture, status, "unlock");
957
958 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
959 torture_assert_ntstatus_ok(torture, status,
960 "FSCTL_SRV_COPYCHUNK unlocked");
961
962 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
963 &cc_rsp,
964 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
965 torture_assert_ndr_success(torture, ndr_ret,
966 "ndr_pull_srv_copychunk_rsp");
967
968 ok = check_copy_chunk_rsp(torture, &cc_rsp,
969 1, /* chunks written */
970 0, /* chunk bytes unsuccessfully written */
971 4096); /* total bytes written */
972 if (!ok) {
973 torture_fail(torture, "bad copy chunk response data");
974 }
975
976 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 4096, 0);
977 if (!ok) {
978 torture_fail(torture, "inconsistent file data");
979 }
980
981 smb2_util_close(tree, src_h2);
982 smb2_util_close(tree, src_h);
983 smb2_util_close(tree, dest_h);
984 talloc_free(tmp_ctx);
985 return true;
986 }
987
988 static bool test_ioctl_copy_chunk_dest_lck(struct torture_context *torture,
989 struct smb2_tree *tree)
990 {
991 struct smb2_handle src_h;
992 struct smb2_handle dest_h;
993 struct smb2_handle dest_h2;
994 NTSTATUS status;
995 union smb_ioctl ioctl;
996 TALLOC_CTX *tmp_ctx = talloc_new(tree);
997 struct srv_copychunk_copy cc_copy;
998 struct srv_copychunk_rsp cc_rsp;
999 enum ndr_err_code ndr_ret;
1000 bool ok;
1001 struct smb2_lock lck;
1002 struct smb2_lock_element el[1];
1003
1004 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1005 1, /* chunks */
1006 FNAME,
1007 &src_h, 4096, /* src file */
1008 SEC_RIGHTS_FILE_ALL,
1009 FNAME2,
1010 &dest_h, 4096, /* dest file */
1011 SEC_RIGHTS_FILE_ALL,
1012 &cc_copy,
1013 &ioctl);
1014 if (!ok) {
1015 torture_fail(torture, "setup copy chunk error");
1016 }
1017
1018 cc_copy.chunks[0].source_off = 0;
1019 cc_copy.chunks[0].target_off = 0;
1020 cc_copy.chunks[0].length = 4096;
1021
1022 /* open and lock the copychunk dest file */
1023 status = torture_smb2_testfile(tree, FNAME2, &dest_h2);
1024 torture_assert_ntstatus_ok(torture, status, "2nd src open");
1025
1026 lck.in.lock_count = 0x0001;
1027 lck.in.lock_sequence = 0x00000000;
1028 lck.in.file.handle = dest_h2;
1029 lck.in.locks = el;
1030 el[0].offset = cc_copy.chunks[0].target_off;
1031 el[0].length = cc_copy.chunks[0].length;
1032 el[0].reserved = 0;
1033 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
1034
1035 status = smb2_lock(tree, &lck);
1036 torture_assert_ntstatus_ok(torture, status, "lock");
1037
1038 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1039 &cc_copy,
1040 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1041 torture_assert_ndr_success(torture, ndr_ret,
1042 "ndr_push_srv_copychunk_copy");
1043
1044 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1045 torture_assert_ntstatus_equal(torture, status,
1046 NT_STATUS_FILE_LOCK_CONFLICT,
1047 "FSCTL_SRV_COPYCHUNK locked");
1048
1049 lck.in.lock_count = 0x0001;
1050 lck.in.lock_sequence = 0x00000001;
1051 lck.in.file.handle = dest_h2;
1052 lck.in.locks = el;
1053 el[0].offset = cc_copy.chunks[0].target_off;
1054 el[0].length = cc_copy.chunks[0].length;
1055 el[0].reserved = 0;
1056 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
1057 status = smb2_lock(tree, &lck);
1058 torture_assert_ntstatus_ok(torture, status, "unlock");
1059
1060 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1061 torture_assert_ntstatus_ok(torture, status,
1062 "FSCTL_SRV_COPYCHUNK unlocked");
1063
1064 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
1065 &cc_rsp,
1066 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
1067 torture_assert_ndr_success(torture, ndr_ret,
1068 "ndr_pull_srv_copychunk_rsp");
1069
1070 ok = check_copy_chunk_rsp(torture, &cc_rsp,
1071 1, /* chunks written */
1072 0, /* chunk bytes unsuccessfully written */
1073 4096); /* total bytes written */
1074 if (!ok) {
1075 torture_fail(torture, "bad copy chunk response data");
1076 }
1077
1078 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 4096, 0);
1079 if (!ok) {
1080 torture_fail(torture, "inconsistent file data");
1081 }
1082
1083 smb2_util_close(tree, dest_h2);
1084 smb2_util_close(tree, src_h);
1085 smb2_util_close(tree, dest_h);
1086 talloc_free(tmp_ctx);
1087 return true;
1088 }
1089
1090 static bool test_ioctl_copy_chunk_bad_key(struct torture_context *torture,
1091 struct smb2_tree *tree)
1092 {
1093 struct smb2_handle src_h;
1094 struct smb2_handle dest_h;
1095 NTSTATUS status;
1096 union smb_ioctl ioctl;
1097 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1098 struct srv_copychunk_copy cc_copy;
1099 enum ndr_err_code ndr_ret;
1100 bool ok;
1101
1102 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1103 1,
1104 FNAME,
1105 &src_h, 4096,
1106 SEC_RIGHTS_FILE_ALL,
1107 FNAME2,
1108 &dest_h, 0,
1109 SEC_RIGHTS_FILE_ALL,
1110 &cc_copy,
1111 &ioctl);
1112 if (!ok) {
1113 torture_fail(torture, "setup copy chunk error");
1114 }
1115
1116 /* overwrite the resume key with a bogus value */
1117 memcpy(cc_copy.source_key, "deadbeefdeadbeefdeadbeef", 24);
1118
1119 cc_copy.chunks[0].source_off = 0;
1120 cc_copy.chunks[0].target_off = 0;
1121 cc_copy.chunks[0].length = 4096;
1122
1123 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1124 &cc_copy,
1125 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1126 torture_assert_ndr_success(torture, ndr_ret,
1127 "ndr_push_srv_copychunk_copy");
1128
1129 /* Server 2k12 returns NT_STATUS_OBJECT_NAME_NOT_FOUND */
1130 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1131 torture_assert_ntstatus_equal(torture, status,
1132 NT_STATUS_OBJECT_NAME_NOT_FOUND,
1133 "FSCTL_SRV_COPYCHUNK");
1134
1135 smb2_util_close(tree, src_h);
1136 smb2_util_close(tree, dest_h);
1137 talloc_free(tmp_ctx);
1138 return true;
1139 }
1140
1141 static bool test_ioctl_copy_chunk_src_is_dest(struct torture_context *torture,
1142 struct smb2_tree *tree)
1143 {
1144 struct smb2_handle src_h;
1145 struct smb2_handle dest_h;
1146 NTSTATUS status;
1147 union smb_ioctl ioctl;
1148 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1149 struct srv_copychunk_copy cc_copy;
1150 struct srv_copychunk_rsp cc_rsp;
1151 enum ndr_err_code ndr_ret;
1152 bool ok;
1153
1154 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1155 1,
1156 FNAME,
1157 &src_h, 8192,
1158 SEC_RIGHTS_FILE_ALL,
1159 FNAME2,
1160 &dest_h, 0,
1161 SEC_RIGHTS_FILE_ALL,
1162 &cc_copy,
1163 &ioctl);
1164 if (!ok) {
1165 torture_fail(torture, "setup copy chunk error");
1166 }
1167
1168 /* the source is also the destination */
1169 ioctl.smb2.in.file.handle = src_h;
1170
1171 /* non-overlapping */
1172 cc_copy.chunks[0].source_off = 0;
1173 cc_copy.chunks[0].target_off = 4096;
1174 cc_copy.chunks[0].length = 4096;
1175
1176 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1177 &cc_copy,
1178 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1179 torture_assert_ndr_success(torture, ndr_ret,
1180 "ndr_push_srv_copychunk_copy");
1181
1182 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1183 torture_assert_ntstatus_ok(torture, status,
1184 "FSCTL_SRV_COPYCHUNK");
1185
1186 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
1187 &cc_rsp,
1188 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
1189 torture_assert_ndr_success(torture, ndr_ret,
1190 "ndr_pull_srv_copychunk_rsp");
1191
1192 ok = check_copy_chunk_rsp(torture, &cc_rsp,
1193 1, /* chunks written */
1194 0, /* chunk bytes unsuccessfully written */
1195 4096); /* total bytes written */
1196 if (!ok) {
1197 torture_fail(torture, "bad copy chunk response data");
1198 }
1199
1200 ok = check_pattern(torture, tree, tmp_ctx, src_h, 0, 4096, 0);
1201 if (!ok) {
1202 torture_fail(torture, "inconsistent file data");
1203 }
1204 ok = check_pattern(torture, tree, tmp_ctx, src_h, 4096, 4096, 0);
1205 if (!ok) {
1206 torture_fail(torture, "inconsistent file data");
1207 }
1208
1209 smb2_util_close(tree, src_h);
1210 smb2_util_close(tree, dest_h);
1211 talloc_free(tmp_ctx);
1212 return true;
1213 }
1214
1215 /*
1216 * Test a single-chunk copychunk request, where the source and target ranges
1217 * overlap, and the SourceKey refers to the same target file. E.g:
1218 *
1219 * Initial State
1220 * -------------
1221 * File: src_and_dest
1222 * Offset: 0123456789
1223 * Data: abcdefghij
1224 *
1225 * Request
1226 * -------
1227 * FSCTL_SRV_COPYCHUNK(src_and_dest)
1228 * SourceKey = SRV_REQUEST_RESUME_KEY(src_and_dest)
1229 * ChunkCount = 1
1230 * Chunks[0].SourceOffset = 0
1231 * Chunks[0].TargetOffset = 4
1232 * Chunks[0].Length = 6
1233 *
1234 * Resultant State
1235 * ---------------
1236 * File: src_and_dest
1237 * Offset: 0123456789
1238 * Data: abcdabcdef
1239 *
1240 * The resultant contents of src_and_dest is dependent on the server's
1241 * copy algorithm. In the above example, the server uses an IO buffer
1242 * large enough to hold the entire six-byte source data before writing
1243 * to TargetOffset. If the server were to use a four-byte IO buffer and
1244 * started reads/writes from the lowest offset, then the two overlapping
1245 * bytes in the above example would be overwritten before being read. The
1246 * resultant file contents would be abcdabcdab.
1247 *
1248 * Windows 2008r2 appears to use a 2048 byte copy buffer, overlapping bytes
1249 * after this offset are written before being read. Windows 2012 on the
1250 * other hand appears to use a buffer large enough to hold its maximum
1251 * supported chunk size (1M). Samba currently uses a 64k copy buffer by
1252 * default (vfs_cc_state.buf).
1253 *
1254 * This test uses an 8-byte overlap at 2040-2048, so that it passes against
1255 * Windows 2008r2, 2012 and Samba servers. Note, 2008GM fails, as it appears
1256 * to use a different copy algorithm to 2008r2.
1257 */
1258 static bool
1259 test_ioctl_copy_chunk_src_is_dest_overlap(struct torture_context *torture,
1260 struct smb2_tree *tree)
1261 {
1262 struct smb2_handle src_h;
1263 struct smb2_handle dest_h;
1264 NTSTATUS status;
1265 union smb_ioctl ioctl;
1266 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1267 struct srv_copychunk_copy cc_copy;
1268 struct srv_copychunk_rsp cc_rsp;
1269 enum ndr_err_code ndr_ret;
1270 bool ok;
1271
1272 /* exceed the vfs_default copy buffer */
1273 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1274 1,
1275 FNAME,
1276 &src_h, 2048 * 2,
1277 SEC_RIGHTS_FILE_ALL,
1278 FNAME2,
1279 &dest_h, 0,
1280 SEC_RIGHTS_FILE_ALL,
1281 &cc_copy,
1282 &ioctl);
1283 if (!ok) {
1284 torture_fail(torture, "setup copy chunk error");
1285 }
1286
1287 /* the source is also the destination */
1288 ioctl.smb2.in.file.handle = src_h;
1289
1290 /* 8 bytes overlap between source and target ranges */
1291 cc_copy.chunks[0].source_off = 0;
1292 cc_copy.chunks[0].target_off = 2048 - 8;
1293 cc_copy.chunks[0].length = 2048;
1294
1295 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1296 &cc_copy,
1297 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1298 torture_assert_ndr_success(torture, ndr_ret,
1299 "ndr_push_srv_copychunk_copy");
1300
1301 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1302 torture_assert_ntstatus_ok(torture, status,
1303 "FSCTL_SRV_COPYCHUNK");
1304
1305 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
1306 &cc_rsp,
1307 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
1308 torture_assert_ndr_success(torture, ndr_ret,
1309 "ndr_pull_srv_copychunk_rsp");
1310
1311 ok = check_copy_chunk_rsp(torture, &cc_rsp,
1312 1, /* chunks written */
1313 0, /* chunk bytes unsuccessfully written */
1314 2048); /* total bytes written */
1315 if (!ok) {
1316 torture_fail(torture, "bad copy chunk response data");
1317 }
1318
1319 ok = check_pattern(torture, tree, tmp_ctx, src_h, 0, 2048 - 8, 0);
1320 if (!ok) {
1321 torture_fail(torture, "inconsistent file data");
1322 }
1323 ok = check_pattern(torture, tree, tmp_ctx, src_h, 2048 - 8, 2048, 0);
1324 if (!ok) {
1325 torture_fail(torture, "inconsistent file data");
1326 }
1327
1328 smb2_util_close(tree, src_h);
1329 smb2_util_close(tree, dest_h);
1330 talloc_free(tmp_ctx);
1331 return true;
1332 }
1333
1334 static bool test_ioctl_copy_chunk_bad_access(struct torture_context *torture,
1335 struct smb2_tree *tree)
1336 {
1337 struct smb2_handle src_h;
1338 struct smb2_handle dest_h;
1339 NTSTATUS status;
1340 union smb_ioctl ioctl;
1341 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1342 struct srv_copychunk_copy cc_copy;
1343 enum ndr_err_code ndr_ret;
1344 bool ok;
1345 /* read permission on src */
1346 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx, 1, /* 1 chunk */
1347 FNAME, &src_h, 4096, /* fill 4096 byte src file */
1348 SEC_FILE_READ_DATA | SEC_FILE_READ_ATTRIBUTE,
1349 FNAME2, &dest_h, 0, /* 0 byte dest file */
1350 SEC_RIGHTS_FILE_ALL, &cc_copy, &ioctl);
1351 if (!ok) {
1352 torture_fail(torture, "setup copy chunk error");
1353 }
1354
1355 cc_copy.chunks[0].source_off = 0;
1356 cc_copy.chunks[0].target_off = 0;
1357 cc_copy.chunks[0].length = 4096;
1358
1359 ndr_ret = ndr_push_struct_blob(
1360 &ioctl.smb2.in.out, tmp_ctx, &cc_copy,
1361 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1362 torture_assert_ndr_success(torture, ndr_ret,
1363 "ndr_push_srv_copychunk_copy");
1364
1365 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1366 torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
1367 "FSCTL_SRV_COPYCHUNK");
1368
1369 smb2_util_close(tree, src_h);
1370 smb2_util_close(tree, dest_h);
1371
1372 /* execute permission on src */
1373 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx, 1, /* 1 chunk */
1374 FNAME, &src_h, 4096, /* fill 4096 byte src file */
1375 SEC_FILE_EXECUTE | SEC_FILE_READ_ATTRIBUTE,
1376 FNAME2, &dest_h, 0, /* 0 byte dest file */
1377 SEC_RIGHTS_FILE_ALL, &cc_copy, &ioctl);
1378 if (!ok) {
1379 torture_fail(torture, "setup copy chunk error");
1380 }
1381
1382 cc_copy.chunks[0].source_off = 0;
1383 cc_copy.chunks[0].target_off = 0;
1384 cc_copy.chunks[0].length = 4096;
1385
1386 ndr_ret = ndr_push_struct_blob(
1387 &ioctl.smb2.in.out, tmp_ctx, &cc_copy,
1388 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1389 torture_assert_ndr_success(torture, ndr_ret,
1390 "ndr_push_srv_copychunk_copy");
1391
1392 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1393 torture_assert_ntstatus_equal(torture, status, NT_STATUS_OK,
1394 "FSCTL_SRV_COPYCHUNK");
1395
1396 smb2_util_close(tree, src_h);
1397 smb2_util_close(tree, dest_h);
1398
1399 /* neither read nor execute permission on src */
1400 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx, 1, /* 1 chunk */
1401 FNAME, &src_h, 4096, /* fill 4096 byte src file */
1402 SEC_FILE_READ_ATTRIBUTE, FNAME2, &dest_h,
1403 0, /* 0 byte dest file */
1404 SEC_RIGHTS_FILE_ALL, &cc_copy, &ioctl);
1405 if (!ok) {
1406 torture_fail(torture, "setup copy chunk error");
1407 }
1408
1409 cc_copy.chunks[0].source_off = 0;
1410 cc_copy.chunks[0].target_off = 0;
1411 cc_copy.chunks[0].length = 4096;
1412
1413 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1414 &cc_copy,
1415 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1416 torture_assert_ndr_success(torture, ndr_ret,
1417 "ndr_push_srv_copychunk_copy");
1418
1419 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1420 torture_assert_ntstatus_equal(torture, status,
1421 NT_STATUS_ACCESS_DENIED,
1422 "FSCTL_SRV_COPYCHUNK");
1423
1424 smb2_util_close(tree, src_h);
1425 smb2_util_close(tree, dest_h);
1426
1427 /* no write permission on dest */
1428 ok = test_setup_copy_chunk(
1429 torture, tree, tree, tmp_ctx, 1, /* 1 chunk */
1430 FNAME, &src_h, 4096, /* fill 4096 byte src file */
1431 SEC_FILE_READ_DATA | SEC_FILE_READ_ATTRIBUTE, FNAME2, &dest_h,
1432 0, /* 0 byte dest file */
1433 (SEC_RIGHTS_FILE_ALL &
1434 ~(SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA)),
1435 &cc_copy, &ioctl);
1436 if (!ok) {
1437 torture_fail(torture, "setup copy chunk error");
1438 }
1439
1440 cc_copy.chunks[0].source_off = 0;
1441 cc_copy.chunks[0].target_off = 0;
1442 cc_copy.chunks[0].length = 4096;
1443
1444 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1445 &cc_copy,
1446 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1447 torture_assert_ndr_success(torture, ndr_ret,
1448 "ndr_push_srv_copychunk_copy");
1449
1450 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1451 torture_assert_ntstatus_equal(torture, status,
1452 NT_STATUS_ACCESS_DENIED,
1453 "FSCTL_SRV_COPYCHUNK");
1454
1455 smb2_util_close(tree, src_h);
1456 smb2_util_close(tree, dest_h);
1457
1458 /* no read permission on dest */
1459 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx, 1, /* 1 chunk */
1460 FNAME, &src_h, 4096, /* fill 4096 byte src file */
1461 SEC_FILE_READ_DATA | SEC_FILE_READ_ATTRIBUTE,
1462 FNAME2, &dest_h, 0, /* 0 byte dest file */
1463 (SEC_RIGHTS_FILE_ALL & ~SEC_FILE_READ_DATA),
1464 &cc_copy, &ioctl);
1465 if (!ok) {
1466 torture_fail(torture, "setup copy chunk error");
1467 }
1468
1469 cc_copy.chunks[0].source_off = 0;
1470 cc_copy.chunks[0].target_off = 0;
1471 cc_copy.chunks[0].length = 4096;
1472
1473 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1474 &cc_copy,
1475 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1476 torture_assert_ndr_success(torture, ndr_ret,
1477 "ndr_push_srv_copychunk_copy");
1478
1479 /*
1480 * FSCTL_SRV_COPYCHUNK requires read permission on dest,
1481 * FSCTL_SRV_COPYCHUNK_WRITE on the other hand does not.
1482 */
1483 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1484 torture_assert_ntstatus_equal(torture, status,
1485 NT_STATUS_ACCESS_DENIED,
1486 "FSCTL_SRV_COPYCHUNK");
1487
1488 smb2_util_close(tree, src_h);
1489 smb2_util_close(tree, dest_h);
1490 talloc_free(tmp_ctx);
1491
1492 return true;
1493 }
1494
1495 static bool test_ioctl_copy_chunk_write_access(struct torture_context *torture,
1496 struct smb2_tree *tree)
1497 {
1498 struct smb2_handle src_h;
1499 struct smb2_handle dest_h;
1500 NTSTATUS status;
1501 union smb_ioctl ioctl;
1502 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1503 struct srv_copychunk_copy cc_copy;
1504 enum ndr_err_code ndr_ret;
1505 bool ok;
1506
1507 /* no read permission on dest with FSCTL_SRV_COPYCHUNK_WRITE */
1508 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1509 1, /* 1 chunk */
1510 FNAME,
1511 &src_h, 4096, /* fill 4096 byte src file */
1512 SEC_RIGHTS_FILE_ALL,
1513 FNAME2,
1514 &dest_h, 0, /* 0 byte dest file */
1515 (SEC_RIGHTS_FILE_WRITE
1516 | SEC_RIGHTS_FILE_EXECUTE),
1517 &cc_copy,
1518 &ioctl);
1519 if (!ok) {
1520 torture_fail(torture, "setup copy chunk error");
1521 }
1522
1523 ioctl.smb2.in.function = FSCTL_SRV_COPYCHUNK_WRITE;
1524 cc_copy.chunks[0].source_off = 0;
1525 cc_copy.chunks[0].target_off = 0;
1526 cc_copy.chunks[0].length = 4096;
1527
1528 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1529 &cc_copy,
1530 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1531 torture_assert_ndr_success(torture, ndr_ret,
1532 "ndr_push_srv_copychunk_copy");
1533
1534 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1535 torture_assert_ntstatus_ok(torture, status,
1536 "FSCTL_SRV_COPYCHUNK_WRITE");
1537
1538 smb2_util_close(tree, src_h);
1539 smb2_util_close(tree, dest_h);
1540 talloc_free(tmp_ctx);
1541
1542 return true;
1543 }
1544
1545 static bool test_ioctl_copy_chunk_src_exceed(struct torture_context *torture,
1546 struct smb2_tree *tree)
1547 {
1548 struct smb2_handle src_h;
1549 struct smb2_handle dest_h;
1550 NTSTATUS status;
1551 union smb_ioctl ioctl;
1552 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1553 struct srv_copychunk_copy cc_copy;
1554 struct srv_copychunk_rsp cc_rsp;
1555 enum ndr_err_code ndr_ret;
1556 bool ok;
1557
1558 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1559 1, /* 1 chunk */
1560 FNAME,
1561 &src_h, 4096, /* fill 4096 byte src file */
1562 SEC_RIGHTS_FILE_ALL,
1563 FNAME2,
1564 &dest_h, 0, /* 0 byte dest file */
1565 SEC_RIGHTS_FILE_ALL,
1566 &cc_copy,
1567 &ioctl);
1568 if (!ok) {
1569 torture_fail(torture, "setup copy chunk error");
1570 }
1571
1572 /* Request copy where off + length exceeds size of src */
1573 cc_copy.chunks[0].source_off = 1024;
1574 cc_copy.chunks[0].target_off = 0;
1575 cc_copy.chunks[0].length = 4096;
1576
1577 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1578 &cc_copy,
1579 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1580 torture_assert_ndr_success(torture, ndr_ret,
1581 "ndr_push_srv_copychunk_copy");
1582
1583 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1584 torture_assert_ntstatus_equal(torture, status,
1585 NT_STATUS_INVALID_VIEW_SIZE,
1586 "FSCTL_SRV_COPYCHUNK oversize");
1587
1588 /* Request copy where length exceeds size of src */
1589 cc_copy.chunks[0].source_off = 1024;
1590 cc_copy.chunks[0].target_off = 0;
1591 cc_copy.chunks[0].length = 3072;
1592
1593 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1594 &cc_copy,
1595 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1596 torture_assert_ndr_success(torture, ndr_ret,
1597 "ndr_push_srv_copychunk_copy");
1598
1599 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1600 torture_assert_ntstatus_ok(torture, status,
1601 "FSCTL_SRV_COPYCHUNK just right");
1602
1603 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
1604 &cc_rsp,
1605 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
1606 torture_assert_ndr_success(torture, ndr_ret,
1607 "ndr_pull_srv_copychunk_rsp");
1608
1609 ok = check_copy_chunk_rsp(torture, &cc_rsp,
1610 1, /* chunks written */
1611 0, /* chunk bytes unsuccessfully written */
1612 3072); /* total bytes written */
1613 if (!ok) {
1614 torture_fail(torture, "bad copy chunk response data");
1615 }
1616
1617 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 3072, 1024);
1618 if (!ok) {
1619 torture_fail(torture, "inconsistent file data");
1620 }
1621
1622 smb2_util_close(tree, src_h);
1623 smb2_util_close(tree, dest_h);
1624 talloc_free(tmp_ctx);
1625 return true;
1626 }
1627
1628 static bool
1629 test_ioctl_copy_chunk_src_exceed_multi(struct torture_context *torture,
1630 struct smb2_tree *tree)
1631 {
1632 struct smb2_handle src_h;
1633 struct smb2_handle dest_h;
1634 NTSTATUS status;
1635 union smb_ioctl ioctl;
1636 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1637 struct srv_copychunk_copy cc_copy;
1638 struct srv_copychunk_rsp cc_rsp;
1639 enum ndr_err_code ndr_ret;
1640 bool ok;
1641
1642 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1643 2, /* 2 chunks */
1644 FNAME,
1645 &src_h, 8192, /* fill 8192 byte src file */
1646 SEC_RIGHTS_FILE_ALL,
1647 FNAME2,
1648 &dest_h, 0, /* 0 byte dest file */
1649 SEC_RIGHTS_FILE_ALL,
1650 &cc_copy,
1651 &ioctl);
1652 if (!ok) {
1653 torture_fail(torture, "setup copy chunk error");
1654 }
1655
1656 /* Request copy where off + length exceeds size of src */
1657 cc_copy.chunks[0].source_off = 0;
1658 cc_copy.chunks[0].target_off = 0;
1659 cc_copy.chunks[0].length = 4096;
1660
1661 cc_copy.chunks[1].source_off = 4096;
1662 cc_copy.chunks[1].target_off = 4096;
1663 cc_copy.chunks[1].length = 8192;
1664
1665 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1666 &cc_copy,
1667 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1668 torture_assert_ndr_success(torture, ndr_ret,
1669 "ndr_push_srv_copychunk_copy");
1670
1671 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1672 torture_assert_ntstatus_equal(torture, status,
1673 NT_STATUS_INVALID_VIEW_SIZE,
1674 "FSCTL_SRV_COPYCHUNK oversize");
1675 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
1676 &cc_rsp,
1677 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
1678 torture_assert_ndr_success(torture, ndr_ret, "unmarshalling response");
1679
1680 /* first chunk should still be written */
1681 ok = check_copy_chunk_rsp(torture, &cc_rsp,
1682 1, /* chunks written */
1683 0, /* chunk bytes unsuccessfully written */
1684 4096); /* total bytes written */
1685 if (!ok) {
1686 torture_fail(torture, "bad copy chunk response data");
1687 }
1688 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 4096, 0);
1689 if (!ok) {
1690 torture_fail(torture, "inconsistent file data");
1691 }
1692
1693 smb2_util_close(tree, src_h);
1694 smb2_util_close(tree, dest_h);
1695 talloc_free(tmp_ctx);
1696 return true;
1697 }
1698
1699 static bool test_ioctl_copy_chunk_sparse_dest(struct torture_context *torture,
1700 struct smb2_tree *tree)
1701 {
1702 struct smb2_handle src_h;
1703 struct smb2_handle dest_h;
1704 NTSTATUS status;
1705 union smb_ioctl ioctl;
1706 struct smb2_read r;
1707 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1708 struct srv_copychunk_copy cc_copy;
1709 struct srv_copychunk_rsp cc_rsp;
1710 enum ndr_err_code ndr_ret;
1711 bool ok;
1712 int i;
1713
1714 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1715 1, /* 1 chunk */
1716 FNAME,
1717 &src_h, 4096, /* fill 4096 byte src file */
1718 SEC_RIGHTS_FILE_ALL,
1719 FNAME2,
1720 &dest_h, 0, /* 0 byte dest file */
1721 SEC_RIGHTS_FILE_ALL,
1722 &cc_copy,
1723 &ioctl);
1724 if (!ok) {
1725 torture_fail(torture, "setup copy chunk error");
1726 }
1727
1728 /* copy all src file data (via a single chunk desc) */
1729 cc_copy.chunks[0].source_off = 0;
1730 cc_copy.chunks[0].target_off = 4096;
1731 cc_copy.chunks[0].length = 4096;
1732
1733 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1734 &cc_copy,
1735 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1736 torture_assert_ndr_success(torture, ndr_ret,
1737 "ndr_push_srv_copychunk_copy");
1738
1739 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1740 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_COPYCHUNK");
1741
1742 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
1743 &cc_rsp,
1744 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
1745 torture_assert_ndr_success(torture, ndr_ret,
1746 "ndr_pull_srv_copychunk_rsp");
1747
1748 ok = check_copy_chunk_rsp(torture, &cc_rsp,
1749 1, /* chunks written */
1750 0, /* chunk bytes unsuccessfully written */
1751 4096); /* total bytes written */
1752 if (!ok) {
1753 torture_fail(torture, "bad copy chunk response data");
1754 }
1755
1756 /* check for zeros in first 4k */
1757 ZERO_STRUCT(r);
1758 r.in.file.handle = dest_h;
1759 r.in.length = 4096;
1760 r.in.offset = 0;
1761 status = smb2_read(tree, tmp_ctx, &r);
1762 torture_assert_ntstatus_ok(torture, status, "read");
1763
1764 torture_assert_u64_equal(torture, r.out.data.length, 4096,
1765 "read data len mismatch");
1766
1767 for (i = 0; i < 4096; i++) {
1768 torture_assert(torture, (r.out.data.data[i] == 0),
1769 "sparse did not pass class");
1770 }
1771
1772 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 4096, 4096, 0);
1773 if (!ok) {
1774 torture_fail(torture, "inconsistent file data");
1775 }
1776
1777 smb2_util_close(tree, src_h);
1778 smb2_util_close(tree, dest_h);
1779 talloc_free(tmp_ctx);
1780 return true;
1781 }
1782
1783 /*
1784 * set the ioctl MaxOutputResponse size to less than
1785 * sizeof(struct srv_copychunk_rsp)
1786 */
1787 static bool test_ioctl_copy_chunk_max_output_sz(struct torture_context *torture,
1788 struct smb2_tree *tree)
1789 {
1790 struct smb2_handle src_h;
1791 struct smb2_handle dest_h;
1792 NTSTATUS status;
1793 union smb_ioctl ioctl;
1794 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1795 struct srv_copychunk_copy cc_copy;
1796 enum ndr_err_code ndr_ret;
1797 bool ok;
1798
1799 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1800 1, /* 1 chunk */
1801 FNAME,
1802 &src_h, 4096, /* fill 4096 byte src file */
1803 SEC_RIGHTS_FILE_ALL,
1804 FNAME2,
1805 &dest_h, 0, /* 0 byte dest file */
1806 SEC_RIGHTS_FILE_ALL,
1807 &cc_copy,
1808 &ioctl);
1809 if (!ok) {
1810 torture_fail(torture, "setup copy chunk error");
1811 }
1812
1813 cc_copy.chunks[0].source_off = 0;
1814 cc_copy.chunks[0].target_off = 0;
1815 cc_copy.chunks[0].length = 4096;
1816 /* req is valid, but use undersize max_response_size */
1817 ioctl.smb2.in.max_response_size = sizeof(struct srv_copychunk_rsp) - 1;
1818
1819 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1820 &cc_copy,
1821 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1822 torture_assert_ndr_success(torture, ndr_ret,
1823 "ndr_push_srv_copychunk_copy");
1824
1825 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1826 torture_assert_ntstatus_equal(torture, status,
1827 NT_STATUS_INVALID_PARAMETER,
1828 "FSCTL_SRV_COPYCHUNK");
1829
1830 smb2_util_close(tree, src_h);
1831 smb2_util_close(tree, dest_h);
1832 talloc_free(tmp_ctx);
1833 return true;
1834 }
1835
1836 static bool test_ioctl_copy_chunk_zero_length(struct torture_context *torture,
1837 struct smb2_tree *tree)
1838 {
1839 struct smb2_handle src_h;
1840 struct smb2_handle dest_h;
1841 NTSTATUS status;
1842 union smb_ioctl ioctl;
1843 union smb_fileinfo q;
1844 TALLOC_CTX *tmp_ctx = talloc_new(tree);
1845 struct srv_copychunk_copy cc_copy;
1846 struct srv_copychunk_rsp cc_rsp;
1847 enum ndr_err_code ndr_ret;
1848 bool ok;
1849
1850 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1851 1, /* 1 chunk */
1852 FNAME,
1853 &src_h, 4096, /* fill 4096 byte src file */
1854 SEC_RIGHTS_FILE_ALL,
1855 FNAME2,
1856 &dest_h, 0, /* 0 byte dest file */
1857 SEC_RIGHTS_FILE_ALL,
1858 &cc_copy,
1859 &ioctl);
1860 if (!ok) {
1861 torture_fail(torture, "setup copy chunk error");
1862 }
1863
1864 /* zero length server-side copy (via a single chunk desc) */
1865 cc_copy.chunks[0].source_off = 0;
1866 cc_copy.chunks[0].target_off = 0;
1867 cc_copy.chunks[0].length = 0;
1868
1869 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
1870 &cc_copy,
1871 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1872 torture_assert_ndr_success(torture, ndr_ret,
1873 "ndr_push_srv_copychunk_copy");
1874
1875 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
1876 torture_assert_ntstatus_equal(torture, status,
1877 NT_STATUS_INVALID_PARAMETER,
1878 "bad zero-length chunk response");
1879
1880 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
1881 &cc_rsp,
1882 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
1883 torture_assert_ndr_success(torture, ndr_ret, "unmarshalling response");
1884
1885 ZERO_STRUCT(q);
1886 q.all_info2.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
1887 q.all_info2.in.file.handle = dest_h;
1888 status = smb2_getinfo_file(tree, torture, &q);
1889 torture_assert_ntstatus_ok(torture, status, "getinfo");
1890
1891 torture_assert_int_equal(torture, q.all_info2.out.size, 0,
1892 "size after zero len clone");
1893
1894 smb2_util_close(tree, src_h);
1895 smb2_util_close(tree, dest_h);
1896 talloc_free(tmp_ctx);
1897 return true;
1898 }
1899
1900 static bool copy_one_stream(struct torture_context *torture,
1901 struct smb2_tree *tree,
1902 TALLOC_CTX *tmp_ctx,
1903 const char *src_sname,
1904 const char *dst_sname)
1905 {
1906 struct smb2_handle src_h = {{0}};
1907 struct smb2_handle dest_h = {{0}};
1908 NTSTATUS status;
1909 union smb_ioctl io;
1910 struct srv_copychunk_copy cc_copy;
1911 struct srv_copychunk_rsp cc_rsp;
1912 enum ndr_err_code ndr_ret;
1913 bool ok = false;
1914
1915 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
1916 1, /* 1 chunk */
1917 src_sname,
1918 &src_h, 256, /* fill 256 byte src file */
1919 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
1920 dst_sname,
1921 &dest_h, 0, /* 0 byte dest file */
1922 SEC_FILE_READ_DATA | SEC_FILE_WRITE_DATA,
1923 &cc_copy,
1924 &io);
1925 torture_assert_goto(torture, ok == true, ok, done,
1926 "setup copy chunk error\n");
1927
1928 /* copy all src file data (via a single chunk desc) */
1929 cc_copy.chunks[0].source_off = 0;
1930 cc_copy.chunks[0].target_off = 0;
1931 cc_copy.chunks[0].length = 256;
1932
1933 ndr_ret = ndr_push_struct_blob(
1934 &io.smb2.in.out, tmp_ctx, &cc_copy,
1935 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
1936
1937 torture_assert_ndr_success_goto(torture, ndr_ret, ok, done,
1938 "ndr_push_srv_copychunk_copy\n");
1939
1940 status = smb2_ioctl(tree, tmp_ctx, &io.smb2);
1941 torture_assert_ntstatus_ok_goto(torture, status, ok, done,
1942 "FSCTL_SRV_COPYCHUNK\n");
1943
1944 ndr_ret = ndr_pull_struct_blob(
1945 &io.smb2.out.out, tmp_ctx, &cc_rsp,
1946 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
1947
1948 torture_assert_ndr_success_goto(torture, ndr_ret, ok, done,
1949 "ndr_pull_srv_copychunk_rsp\n");
1950
1951 ok = check_copy_chunk_rsp(torture, &cc_rsp,
1952 1, /* chunks written */
1953 0, /* chunk bytes unsuccessfully written */
1954 256); /* total bytes written */
1955 torture_assert_goto(torture, ok == true, ok, done,
1956 "bad copy chunk response data\n");
1957
1958 ok = check_pattern(torture, tree, tmp_ctx, dest_h, 0, 256, 0);
1959 if (!ok) {
1960 torture_fail(torture, "inconsistent file data\n");
1961 }
1962
1963 done:
1964 if (!smb2_util_handle_empty(src_h)) {
1965 smb2_util_close(tree, src_h);
1966 }
1967 if (!smb2_util_handle_empty(dest_h)) {
1968 smb2_util_close(tree, dest_h);
1969 }
1970
1971 return ok;
1972 }
1973
1974 /**
1975 * Create a file
1976 **/
1977 static bool torture_setup_file(TALLOC_CTX *mem_ctx,
1978 struct smb2_tree *tree,
1979 const char *name)
1980 {
1981 struct smb2_create io;
1982 NTSTATUS status;
1983
1984 smb2_util_unlink(tree, name);
1985 ZERO_STRUCT(io);
1986 io.in.desired_access = SEC_FLAG_MAXIMUM_ALLOWED;
1987 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1988 io.in.create_disposition = NTCREATEX_DISP_OVERWRITE_IF;
1989 io.in.share_access =
1990 NTCREATEX_SHARE_ACCESS_DELETE|
1991 NTCREATEX_SHARE_ACCESS_READ|
1992 NTCREATEX_SHARE_ACCESS_WRITE;
1993 io.in.create_options = 0;
1994 io.in.fname = name;
1995
1996 status = smb2_create(tree, mem_ctx, &io);
1997 if (!NT_STATUS_IS_OK(status)) {
1998 return false;
1999 }
2000
2001 status = smb2_util_close(tree, io.out.file.handle);
2002 if (!NT_STATUS_IS_OK(status)) {
2003 return false;
2004 }
2005
2006 return true;
2007 }
2008
2009 static bool test_copy_chunk_streams(struct torture_context *torture,
2010 struct smb2_tree *tree)
2011 {
2012 const char *src_name = "src";
2013 const char *dst_name = "dst";
2014 struct names {
2015 const char *src_sname;
2016 const char *dst_sname;
2017 } names[] = {
2018 { "src:foo", "dst:foo" }
2019 };
2020 int i;
2021 TALLOC_CTX *tmp_ctx = NULL;
2022 bool ok = false;
2023
2024 tmp_ctx = talloc_new(tree);
2025 torture_assert_not_null_goto(torture, tmp_ctx, ok, done,
2026 "torture_setup_file\n");
2027
2028 ok = torture_setup_file(torture, tree, src_name);
2029 torture_assert_goto(torture, ok == true, ok, done, "torture_setup_file\n");
2030 ok = torture_setup_file(torture, tree, dst_name);
2031 torture_assert_goto(torture, ok == true, ok, done, "torture_setup_file\n");
2032
2033 for (i = 0; i < ARRAY_SIZE(names); i++) {
2034 ok = copy_one_stream(torture, tree, tmp_ctx,
2035 names[i].src_sname,
2036 names[i].dst_sname);
2037 torture_assert_goto(torture, ok == true, ok, done,
2038 "copy_one_stream failed\n");
2039 }
2040
2041 done:
2042 smb2_util_unlink(tree, src_name);
2043 smb2_util_unlink(tree, dst_name);
2044 talloc_free(tmp_ctx);
2045 return ok;
2046 }
2047
2048 static bool test_copy_chunk_across_shares(struct torture_context *tctx,
2049 struct smb2_tree *tree)
2050 {
2051 TALLOC_CTX *mem_ctx = NULL;
2052 struct smb2_tree *tree2 = NULL;
2053 struct smb2_handle src_h = {{0}};
2054 struct smb2_handle dest_h = {{0}};
2055 union smb_ioctl ioctl;
2056 struct srv_copychunk_copy cc_copy;
2057 struct srv_copychunk_rsp cc_rsp;
2058 enum ndr_err_code ndr_ret;
2059 NTSTATUS status;
2060 bool ok = false;
2061
2062 mem_ctx = talloc_new(tctx);
2063 torture_assert_not_null_goto(tctx, mem_ctx, ok, done,
2064 "talloc_new\n");
2065
2066 ok = torture_smb2_tree_connect(tctx, tree->session, tctx, &tree2);
2067 torture_assert_goto(tctx, ok == true, ok, done,
2068 "torture_smb2_tree_connect failed\n");
2069
2070 ok = test_setup_copy_chunk(tctx, tree, tree2, mem_ctx,
2071 1, /* 1 chunk */
2072 FNAME,
2073 &src_h, 4096, /* fill 4096 byte src file */
2074 SEC_RIGHTS_FILE_ALL,
2075 FNAME2,
2076 &dest_h, 0, /* 0 byte dest file */
2077 SEC_RIGHTS_FILE_ALL,
2078 &cc_copy,
2079 &ioctl);
2080 torture_assert_goto(tctx, ok == true, ok, done,
2081 "test_setup_copy_chunk failed\n");
2082
2083 cc_copy.chunks[0].source_off = 0;
2084 cc_copy.chunks[0].target_off = 0;
2085 cc_copy.chunks[0].length = 4096;
2086
2087 ndr_ret = ndr_push_struct_blob(
2088 &ioctl.smb2.in.out, mem_ctx, &cc_copy,
2089 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
2090 torture_assert_ndr_success_goto(tctx, ndr_ret, ok, done,
2091 "ndr_push_srv_copychunk_copy\n");
2092
2093 status = smb2_ioctl(tree2, mem_ctx, &ioctl.smb2);
2094 torture_assert_ntstatus_ok_goto(tctx, status, ok, done,
2095 "FSCTL_SRV_COPYCHUNK\n");
2096
2097 ndr_ret = ndr_pull_struct_blob(
2098 &ioctl.smb2.out.out, mem_ctx, &cc_rsp,
2099 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
2100
2101 torture_assert_ndr_success_goto(tctx, ndr_ret, ok, done,
2102 "ndr_pull_srv_copychunk_rsp\n");
2103
2104 ok = check_copy_chunk_rsp(tctx, &cc_rsp,
2105 1, /* chunks written */
2106 0, /* chunk bytes unsuccessfully written */
2107 4096); /* total bytes written */
2108 torture_assert_goto(tctx, ok == true, ok, done,
2109 "bad copy chunk response data\n");
2110
2111 ok = check_pattern(tctx, tree2, mem_ctx, dest_h, 0, 4096, 0);
2112 torture_assert_goto(tctx, ok == true, ok, done,
2113 "inconsistent file data\n");
2114
2115 done:
2116 TALLOC_FREE(mem_ctx);
2117 if (!smb2_util_handle_empty(src_h)) {
2118 smb2_util_close(tree, src_h);
2119 }
2120 if (!smb2_util_handle_empty(dest_h)) {
2121 smb2_util_close(tree2, dest_h);
2122 }
2123 smb2_util_unlink(tree, FNAME);
2124 smb2_util_unlink(tree2, FNAME2);
2125 if (tree2 != NULL) {
2126 smb2_tdis(tree2);
2127 }
2128 return ok;
2129 }
2130
2131 /* Test closing the src handle */
2132 static bool test_copy_chunk_across_shares2(struct torture_context *tctx,
2133 struct smb2_tree *tree)
2134 {
2135 TALLOC_CTX *mem_ctx = NULL;
2136 struct smb2_tree *tree2 = NULL;
2137 struct smb2_handle src_h = {{0}};
2138 struct smb2_handle dest_h = {{0}};
2139 union smb_ioctl ioctl;
2140 struct srv_copychunk_copy cc_copy;
2141 enum ndr_err_code ndr_ret;
2142 NTSTATUS status;
2143 bool ok = false;
2144
2145 mem_ctx = talloc_new(tctx);
2146 torture_assert_not_null_goto(tctx, mem_ctx, ok, done,
2147 "talloc_new\n");
2148
2149 ok = torture_smb2_tree_connect(tctx, tree->session, tctx, &tree2);
2150 torture_assert_goto(tctx, ok == true, ok, done,
2151 "torture_smb2_tree_connect failed\n");
2152
2153 ok = test_setup_copy_chunk(tctx, tree, tree2, mem_ctx,
2154 1, /* 1 chunk */
2155 FNAME,
2156 &src_h, 4096, /* fill 4096 byte src file */
2157 SEC_RIGHTS_FILE_ALL,
2158 FNAME2,
2159 &dest_h, 0, /* 0 byte dest file */
2160 SEC_RIGHTS_FILE_ALL,
2161 &cc_copy,
2162 &ioctl);
2163 torture_assert_goto(tctx, ok == true, ok, done,
2164 "test_setup_copy_chunk failed\n");
2165
2166 status = smb2_util_close(tree, src_h);
2167 torture_assert_ntstatus_ok_goto(tctx, status, ok, done,
2168 "smb2_util_close failed\n");
2169 ZERO_STRUCT(src_h);
2170
2171 cc_copy.chunks[0].source_off = 0;
2172 cc_copy.chunks[0].target_off = 0;
2173 cc_copy.chunks[0].length = 4096;
2174
2175 ndr_ret = ndr_push_struct_blob(
2176 &ioctl.smb2.in.out, mem_ctx, &cc_copy,
2177 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
2178 torture_assert_ndr_success_goto(tctx, ndr_ret, ok, done,
2179 "ndr_push_srv_copychunk_copy\n");
2180
2181 status = smb2_ioctl(tree2, mem_ctx, &ioctl.smb2);
2182 torture_assert_ntstatus_equal_goto(tctx, status, NT_STATUS_OBJECT_NAME_NOT_FOUND,
2183 ok, done, "smb2_ioctl failed\n");
2184
2185 done:
2186 TALLOC_FREE(mem_ctx);
2187 if (!smb2_util_handle_empty(src_h)) {
2188 smb2_util_close(tree, src_h);
2189 }
2190 if (!smb2_util_handle_empty(dest_h)) {
2191 smb2_util_close(tree2, dest_h);
2192 }
2193 smb2_util_unlink(tree, FNAME);
2194 smb2_util_unlink(tree2, FNAME2);
2195 if (tree2 != NULL) {
2196 smb2_tdis(tree2);
2197 }
2198 return ok;
2199 }
2200
2201 /* Test offset works */
2202 static bool test_copy_chunk_across_shares3(struct torture_context *tctx,
2203 struct smb2_tree *tree)
2204 {
2205 TALLOC_CTX *mem_ctx = NULL;
2206 struct smb2_tree *tree2 = NULL;
2207 struct smb2_handle src_h = {{0}};
2208 struct smb2_handle dest_h = {{0}};
2209 union smb_ioctl ioctl;
2210 struct srv_copychunk_copy cc_copy;
2211 struct srv_copychunk_rsp cc_rsp;
2212 enum ndr_err_code ndr_ret;
2213 NTSTATUS status;
2214 bool ok = false;
2215
2216 mem_ctx = talloc_new(tctx);
2217 torture_assert_not_null_goto(tctx, mem_ctx, ok, done,
2218 "talloc_new\n");
2219
2220 ok = torture_smb2_tree_connect(tctx, tree->session, tctx, &tree2);
2221 torture_assert_goto(tctx, ok == true, ok, done,
2222 "torture_smb2_tree_connect failed\n");
2223
2224 ok = test_setup_copy_chunk(tctx, tree, tree2, mem_ctx,
2225 2, /* 2 chunks */
2226 FNAME,
2227 &src_h, 4096, /* fill 4096 byte src file */
2228 SEC_RIGHTS_FILE_ALL,
2229 FNAME2,
2230 &dest_h, 0, /* 0 byte dest file */
2231 SEC_RIGHTS_FILE_ALL,
2232 &cc_copy,
2233 &ioctl);
2234 torture_assert_goto(tctx, ok == true, ok, done,
2235 "test_setup_copy_chunk failed\n");
2236
2237 cc_copy.chunks[0].source_off = 0;
2238 cc_copy.chunks[0].target_off = 0;
2239 cc_copy.chunks[0].length = 4096;
2240
2241 /* second chunk appends the same data to the first */
2242 cc_copy.chunks[1].source_off = 0;
2243 cc_copy.chunks[1].target_off = 4096;
2244 cc_copy.chunks[1].length = 4096;
2245
2246 ndr_ret = ndr_push_struct_blob(
2247 &ioctl.smb2.in.out, mem_ctx, &cc_copy,
2248 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
2249 torture_assert_ndr_success_goto(tctx, ndr_ret, ok, done,
2250 "ndr_push_srv_copychunk_copy\n");
2251
2252 status = smb2_ioctl(tree2, mem_ctx, &ioctl.smb2);
2253 torture_assert_ntstatus_ok_goto(tctx, status, ok, done, "smb2_ioctl failed\n");
2254
2255 ndr_ret = ndr_pull_struct_blob(
2256 &ioctl.smb2.out.out, mem_ctx, &cc_rsp,
2257 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
2258
2259 torture_assert_ndr_success_goto(tctx, ndr_ret, ok, done,
2260 "ndr_pull_srv_copychunk_rsp\n");
2261
2262 ok = check_copy_chunk_rsp(tctx, &cc_rsp,
2263 2, /* chunks written */
2264 0, /* chunk bytes unsuccessfully written */
2265 8192); /* total bytes written */
2266 torture_assert_goto(tctx, ok == true, ok, done,
2267 "check_copy_chunk_rsp failed\n");
2268
2269 ok = check_pattern(tctx, tree2, mem_ctx, dest_h, 0, 4096, 0);
2270 torture_assert_goto(tctx, ok == true, ok, done,
2271 "check_pattern failed\n");
2272
2273 ok = check_pattern(tctx, tree2, mem_ctx, dest_h, 4096, 4096, 0);
2274 torture_assert_goto(tctx, ok == true, ok, done,
2275 "check_pattern failed\n");
2276
2277 done:
2278 TALLOC_FREE(mem_ctx);
2279 if (!smb2_util_handle_empty(src_h)) {
2280 smb2_util_close(tree, src_h);
2281 }
2282 if (!smb2_util_handle_empty(dest_h)) {
2283 smb2_util_close(tree2, dest_h);
2284 }
2285 smb2_util_unlink(tree, FNAME);
2286 smb2_util_unlink(tree2, FNAME2);
2287 if (tree2 != NULL) {
2288 smb2_tdis(tree2);
2289 }
2290 return ok;
2291 }
2292
2293 static NTSTATUS test_ioctl_compress_fs_supported(struct torture_context *torture,
2294 struct smb2_tree *tree,
2295 TALLOC_CTX *mem_ctx,
2296 struct smb2_handle *fh,
2297 bool *compress_support)
2298 {
2299 NTSTATUS status;
2300 union smb_fsinfo info;
2301
2302 ZERO_STRUCT(info);
2303 info.generic.level = RAW_QFS_ATTRIBUTE_INFORMATION;
2304 info.generic.handle = *fh;
2305 status = smb2_getinfo_fs(tree, tree, &info);
2306 if (!NT_STATUS_IS_OK(status)) {
2307 return status;
2308 }
2309
2310 if (info.attribute_info.out.fs_attr & FILE_FILE_COMPRESSION) {
2311 *compress_support = true;
2312 } else {
2313 *compress_support = false;
2314 }
2315 return NT_STATUS_OK;
2316 }
2317
2318 static NTSTATUS test_ioctl_compress_get(struct torture_context *torture,
2319 TALLOC_CTX *mem_ctx,
2320 struct smb2_tree *tree,
2321 struct smb2_handle fh,
2322 uint16_t *_compression_fmt)
2323 {
2324 union smb_ioctl ioctl;
2325 struct compression_state cmpr_state;
2326 enum ndr_err_code ndr_ret;
2327 NTSTATUS status;
2328
2329 ZERO_STRUCT(ioctl);
2330 ioctl.smb2.level = RAW_IOCTL_SMB2;
2331 ioctl.smb2.in.file.handle = fh;
2332 ioctl.smb2.in.function = FSCTL_GET_COMPRESSION;
2333 ioctl.smb2.in.max_response_size = sizeof(struct compression_state);
2334 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
2335
2336 status = smb2_ioctl(tree, mem_ctx, &ioctl.smb2);
2337 if (!NT_STATUS_IS_OK(status)) {
2338 return status;
2339 }
2340
2341 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, mem_ctx,
2342 &cmpr_state,
2343 (ndr_pull_flags_fn_t)ndr_pull_compression_state);
2344
2345 if (ndr_ret != NDR_ERR_SUCCESS) {
2346 return NT_STATUS_INTERNAL_ERROR;
2347 }
2348
2349 *_compression_fmt = cmpr_state.format;
2350 return NT_STATUS_OK;
2351 }
2352
2353 static NTSTATUS test_ioctl_compress_set(struct torture_context *torture,
2354 TALLOC_CTX *mem_ctx,
2355 struct smb2_tree *tree,
2356 struct smb2_handle fh,
2357 uint16_t compression_fmt)
2358 {
2359 union smb_ioctl ioctl;
2360 struct compression_state cmpr_state;
2361 enum ndr_err_code ndr_ret;
2362 NTSTATUS status;
2363
2364 ZERO_STRUCT(ioctl);
2365 ioctl.smb2.level = RAW_IOCTL_SMB2;
2366 ioctl.smb2.in.file.handle = fh;
2367 ioctl.smb2.in.function = FSCTL_SET_COMPRESSION;
2368 ioctl.smb2.in.max_response_size = 0;
2369 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
2370
2371 cmpr_state.format = compression_fmt;
2372 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, mem_ctx,
2373 &cmpr_state,
2374 (ndr_push_flags_fn_t)ndr_push_compression_state);
2375 if (ndr_ret != NDR_ERR_SUCCESS) {
2376 return NT_STATUS_INTERNAL_ERROR;
2377 }
2378
2379 status = smb2_ioctl(tree, mem_ctx, &ioctl.smb2);
2380 return status;
2381 }
2382
2383 static bool test_ioctl_compress_file_flag(struct torture_context *torture,
2384 struct smb2_tree *tree)
2385 {
2386 struct smb2_handle fh;
2387 NTSTATUS status;
2388 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2389 bool ok;
2390 uint16_t compression_fmt;
2391
2392 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2393 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
2394 FILE_ATTRIBUTE_NORMAL);
2395 torture_assert(torture, ok, "setup compression file");
2396
2397 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
2398 &ok);
2399 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2400 if (!ok) {
2401 smb2_util_close(tree, fh);
2402 torture_skip(torture, "FS compression not supported\n");
2403 }
2404
2405 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2406 &compression_fmt);
2407 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2408
2409 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2410 "initial compression state not NONE");
2411
2412 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
2413 COMPRESSION_FORMAT_DEFAULT);
2414 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_COMPRESSION");
2415
2416 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2417 &compression_fmt);
2418 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2419
2420 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_LZNT1),
2421 "invalid compression state after set");
2422
2423 smb2_util_close(tree, fh);
2424 talloc_free(tmp_ctx);
2425 return true;
2426 }
2427
2428 static bool test_ioctl_compress_dir_inherit(struct torture_context *torture,
2429 struct smb2_tree *tree)
2430 {
2431 struct smb2_handle dirh;
2432 struct smb2_handle fh;
2433 NTSTATUS status;
2434 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2435 uint16_t compression_fmt;
2436 bool ok;
2437 char path_buf[PATH_MAX];
2438
2439 smb2_deltree(tree, DNAME);
2440 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2441 DNAME, &dirh, 0, SEC_RIGHTS_FILE_ALL,
2442 FILE_ATTRIBUTE_DIRECTORY);
2443 torture_assert(torture, ok, "setup compression directory");
2444
2445 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &dirh,
2446 &ok);
2447 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2448 if (!ok) {
2449 smb2_util_close(tree, dirh);
2450 smb2_deltree(tree, DNAME);
2451 torture_skip(torture, "FS compression not supported\n");
2452 }
2453
2454 /* set compression on parent dir, then check for inheritance */
2455 status = test_ioctl_compress_set(torture, tmp_ctx, tree, dirh,
2456 COMPRESSION_FORMAT_LZNT1);
2457 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_COMPRESSION");
2458
2459 status = test_ioctl_compress_get(torture, tmp_ctx, tree, dirh,
2460 &compression_fmt);
2461 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2462
2463 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_LZNT1),
2464 "invalid compression state after set");
2465
2466 snprintf(path_buf, PATH_MAX, "%s\\%s", DNAME, FNAME);
2467 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2468 path_buf, &fh, 4096, SEC_RIGHTS_FILE_ALL,
2469 FILE_ATTRIBUTE_NORMAL);
2470 torture_assert(torture, ok, "setup compression file");
2471
2472 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2473 &compression_fmt);
2474 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2475
2476 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_LZNT1),
2477 "compression attr not inherited by new file");
2478
2479 /* check compressed data is consistent */
2480 ok = check_pattern(torture, tree, tmp_ctx, fh, 0, 4096, 0);
2481
2482 /* disable dir compression attr, file should remain compressed */
2483 status = test_ioctl_compress_set(torture, tmp_ctx, tree, dirh,
2484 COMPRESSION_FORMAT_NONE);
2485 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_COMPRESSION");
2486
2487 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2488 &compression_fmt);
2489 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2490
2491 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_LZNT1),
2492 "file compression attr removed after dir change");
2493 smb2_util_close(tree, fh);
2494
2495 /* new files should no longer inherit compression attr */
2496 snprintf(path_buf, PATH_MAX, "%s\\%s", DNAME, FNAME2);
2497 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2498 path_buf, &fh, 0, SEC_RIGHTS_FILE_ALL,
2499 FILE_ATTRIBUTE_NORMAL);
2500 torture_assert(torture, ok, "setup file");
2501
2502 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2503 &compression_fmt);
2504 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2505
2506 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2507 "compression attr present on new file");
2508
2509 smb2_util_close(tree, fh);
2510 smb2_util_close(tree, dirh);
2511 smb2_deltree(tree, DNAME);
2512 talloc_free(tmp_ctx);
2513 return true;
2514 }
2515
2516 static bool test_ioctl_compress_invalid_format(struct torture_context *torture,
2517 struct smb2_tree *tree)
2518 {
2519 struct smb2_handle fh;
2520 NTSTATUS status;
2521 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2522 bool ok;
2523 uint16_t compression_fmt;
2524
2525 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2526 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
2527 FILE_ATTRIBUTE_NORMAL);
2528 torture_assert(torture, ok, "setup compression file");
2529
2530 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
2531 &ok);
2532 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2533 if (!ok) {
2534 smb2_util_close(tree, fh);
2535 torture_skip(torture, "FS compression not supported\n");
2536 }
2537
2538 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
2539 0x0042); /* bogus */
2540 torture_assert_ntstatus_equal(torture, status,
2541 NT_STATUS_INVALID_PARAMETER,
2542 "invalid FSCTL_SET_COMPRESSION");
2543
2544 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2545 &compression_fmt);
2546 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2547
2548 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2549 "initial compression state not NONE");
2550
2551 smb2_util_close(tree, fh);
2552 talloc_free(tmp_ctx);
2553 return true;
2554 }
2555
2556 static bool test_ioctl_compress_invalid_buf(struct torture_context *torture,
2557 struct smb2_tree *tree)
2558 {
2559 struct smb2_handle fh;
2560 NTSTATUS status;
2561 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2562 bool ok;
2563 union smb_ioctl ioctl;
2564
2565 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2566 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
2567 FILE_ATTRIBUTE_NORMAL);
2568 torture_assert(torture, ok, "setup compression file");
2569
2570 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
2571 &ok);
2572 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2573 if (!ok) {
2574 smb2_util_close(tree, fh);
2575 torture_skip(torture, "FS compression not supported\n");
2576 }
2577
2578 ZERO_STRUCT(ioctl);
2579 ioctl.smb2.level = RAW_IOCTL_SMB2;
2580 ioctl.smb2.in.file.handle = fh;
2581 ioctl.smb2.in.function = FSCTL_GET_COMPRESSION;
2582 ioctl.smb2.in.max_response_size = 0; /* no room for rsp data */
2583 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
2584
2585 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
2586 if (!NT_STATUS_EQUAL(status, NT_STATUS_INVALID_USER_BUFFER)
2587 && !NT_STATUS_EQUAL(status, NT_STATUS_INVALID_PARAMETER)) {
2588 /* neither Server 2k12 nor 2k8r2 response status */
2589 torture_assert(torture, true,
2590 "invalid FSCTL_SET_COMPRESSION");
2591 }
2592
2593 smb2_util_close(tree, fh);
2594 talloc_free(tmp_ctx);
2595 return true;
2596 }
2597
2598 static bool test_ioctl_compress_query_file_attr(struct torture_context *torture,
2599 struct smb2_tree *tree)
2600 {
2601 struct smb2_handle fh;
2602 union smb_fileinfo io;
2603 NTSTATUS status;
2604 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2605 bool ok;
2606
2607 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2608 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
2609 FILE_ATTRIBUTE_NORMAL);
2610 torture_assert(torture, ok, "setup compression file");
2611
2612 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
2613 &ok);
2614 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2615 if (!ok) {
2616 smb2_util_close(tree, fh);
2617 torture_skip(torture, "FS compression not supported\n");
2618 }
2619
2620 ZERO_STRUCT(io);
2621 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
2622 io.generic.in.file.handle = fh;
2623 status = smb2_getinfo_file(tree, tmp_ctx, &io);
2624 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FILE");
2625
2626 torture_assert(torture,
2627 ((io.all_info2.out.attrib & FILE_ATTRIBUTE_COMPRESSED) == 0),
2628 "compression attr before set");
2629
2630 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
2631 COMPRESSION_FORMAT_DEFAULT);
2632 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_COMPRESSION");
2633
2634 ZERO_STRUCT(io);
2635 io.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
2636 io.generic.in.file.handle = fh;
2637 status = smb2_getinfo_file(tree, tmp_ctx, &io);
2638 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FILE");
2639
2640 torture_assert(torture,
2641 (io.basic_info.out.attrib & FILE_ATTRIBUTE_COMPRESSED),
2642 "no compression attr after set");
2643
2644 smb2_util_close(tree, fh);
2645 talloc_free(tmp_ctx);
2646 return true;
2647 }
2648
2649 /*
2650 * Specify FILE_ATTRIBUTE_COMPRESSED on creation, Windows does not retain this
2651 * attribute.
2652 */
2653 static bool test_ioctl_compress_create_with_attr(struct torture_context *torture,
2654 struct smb2_tree *tree)
2655 {
2656 struct smb2_handle fh2;
2657 union smb_fileinfo io;
2658 NTSTATUS status;
2659 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2660 uint16_t compression_fmt;
2661 bool ok;
2662
2663 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2664 FNAME2, &fh2, 0, SEC_RIGHTS_FILE_ALL,
2665 (FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_COMPRESSED));
2666 torture_assert(torture, ok, "setup compression file");
2667
2668 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh2,
2669 &ok);
2670 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2671 if (!ok) {
2672 smb2_util_close(tree, fh2);
2673 torture_skip(torture, "FS compression not supported\n");
2674 }
2675
2676 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh2,
2677 &compression_fmt);
2678 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2679
2680 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2681 "initial compression state not NONE");
2682
2683 ZERO_STRUCT(io);
2684 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
2685 io.generic.in.file.handle = fh2;
2686 status = smb2_getinfo_file(tree, tmp_ctx, &io);
2687 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FILE");
2688
2689 torture_assert(torture,
2690 ((io.all_info2.out.attrib & FILE_ATTRIBUTE_COMPRESSED) == 0),
2691 "incorrect compression attr");
2692
2693 smb2_util_close(tree, fh2);
2694 talloc_free(tmp_ctx);
2695 return true;
2696 }
2697
2698 static bool test_ioctl_compress_inherit_disable(struct torture_context *torture,
2699 struct smb2_tree *tree)
2700 {
2701 struct smb2_handle fh;
2702 struct smb2_handle dirh;
2703 char path_buf[PATH_MAX];
2704 NTSTATUS status;
2705 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2706 bool ok;
2707 uint16_t compression_fmt;
2708
2709 struct smb2_create io;
2710
2711 smb2_deltree(tree, DNAME);
2712 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2713 DNAME, &dirh, 0, SEC_RIGHTS_FILE_ALL,
2714 FILE_ATTRIBUTE_DIRECTORY);
2715 torture_assert(torture, ok, "setup compression directory");
2716
2717 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &dirh,
2718 &ok);
2719 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2720 if (!ok) {
2721 smb2_util_close(tree, dirh);
2722 smb2_deltree(tree, DNAME);
2723 torture_skip(torture, "FS compression not supported\n");
2724 }
2725
2726 /* set compression on parent dir, then check for inheritance */
2727 status = test_ioctl_compress_set(torture, tmp_ctx, tree, dirh,
2728 COMPRESSION_FORMAT_LZNT1);
2729 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_COMPRESSION");
2730
2731 status = test_ioctl_compress_get(torture, tmp_ctx, tree, dirh,
2732 &compression_fmt);
2733 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2734
2735 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_LZNT1),
2736 "invalid compression state after set");
2737 smb2_util_close(tree, dirh);
2738
2739 snprintf(path_buf, PATH_MAX, "%s\\%s", DNAME, FNAME);
2740 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2741 path_buf, &fh, 0, SEC_RIGHTS_FILE_ALL,
2742 FILE_ATTRIBUTE_NORMAL);
2743 torture_assert(torture, ok, "setup compression file");
2744
2745 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2746 &compression_fmt);
2747 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2748
2749 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_LZNT1),
2750 "compression attr not inherited by new file");
2751 smb2_util_close(tree, fh);
2752
2753 snprintf(path_buf, PATH_MAX, "%s\\%s", DNAME, FNAME2);
2754
2755 /* NO_COMPRESSION option should block inheritance */
2756 ZERO_STRUCT(io);
2757 io.in.desired_access = SEC_RIGHTS_FILE_ALL;
2758 io.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
2759 io.in.create_disposition = NTCREATEX_DISP_CREATE;
2760 io.in.create_options = NTCREATEX_OPTIONS_NO_COMPRESSION;
2761 io.in.share_access =
2762 NTCREATEX_SHARE_ACCESS_DELETE|
2763 NTCREATEX_SHARE_ACCESS_READ|
2764 NTCREATEX_SHARE_ACCESS_WRITE;
2765 io.in.fname = path_buf;
2766
2767 status = smb2_create(tree, tmp_ctx, &io);
2768 torture_assert_ntstatus_ok(torture, status, "file create");
2769
2770 fh = io.out.file.handle;
2771
2772 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2773 &compression_fmt);
2774 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2775
2776 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2777 "compression attr inherited by NO_COMPRESSION file");
2778 smb2_util_close(tree, fh);
2779
2780
2781 snprintf(path_buf, PATH_MAX, "%s\\%s", DNAME, DNAME);
2782 ZERO_STRUCT(io);
2783 io.in.desired_access = SEC_RIGHTS_FILE_ALL;
2784 io.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
2785 io.in.create_disposition = NTCREATEX_DISP_CREATE;
2786 io.in.create_options = (NTCREATEX_OPTIONS_NO_COMPRESSION
2787 | NTCREATEX_OPTIONS_DIRECTORY);
2788 io.in.share_access =
2789 NTCREATEX_SHARE_ACCESS_DELETE|
2790 NTCREATEX_SHARE_ACCESS_READ|
2791 NTCREATEX_SHARE_ACCESS_WRITE;
2792 io.in.fname = path_buf;
2793
2794 status = smb2_create(tree, tmp_ctx, &io);
2795 torture_assert_ntstatus_ok(torture, status, "dir create");
2796
2797 dirh = io.out.file.handle;
2798
2799 status = test_ioctl_compress_get(torture, tmp_ctx, tree, dirh,
2800 &compression_fmt);
2801 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2802
2803 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2804 "compression attr inherited by NO_COMPRESSION dir");
2805 smb2_util_close(tree, dirh);
2806 smb2_deltree(tree, DNAME);
2807
2808 talloc_free(tmp_ctx);
2809 return true;
2810 }
2811
2812 /* attempting to set compression via SetInfo should not stick */
2813 static bool test_ioctl_compress_set_file_attr(struct torture_context *torture,
2814 struct smb2_tree *tree)
2815 {
2816 struct smb2_handle fh;
2817 struct smb2_handle dirh;
2818 union smb_fileinfo io;
2819 union smb_setfileinfo set_io;
2820 uint16_t compression_fmt;
2821 NTSTATUS status;
2822 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2823 bool ok;
2824
2825 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2826 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
2827 FILE_ATTRIBUTE_NORMAL);
2828 torture_assert(torture, ok, "setup compression file");
2829
2830 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
2831 &ok);
2832 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2833 if (!ok) {
2834 smb2_util_close(tree, fh);
2835 torture_skip(torture, "FS compression not supported\n");
2836 }
2837
2838 ZERO_STRUCT(io);
2839 io.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
2840 io.generic.in.file.handle = fh;
2841 status = smb2_getinfo_file(tree, tmp_ctx, &io);
2842 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FILE");
2843
2844 torture_assert(torture,
2845 ((io.basic_info.out.attrib & FILE_ATTRIBUTE_COMPRESSED) == 0),
2846 "compression attr before set");
2847
2848 ZERO_STRUCT(set_io);
2849 set_io.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
2850 set_io.basic_info.in.file.handle = fh;
2851 set_io.basic_info.in.create_time = io.basic_info.out.create_time;
2852 set_io.basic_info.in.access_time = io.basic_info.out.access_time;
2853 set_io.basic_info.in.write_time = io.basic_info.out.write_time;
2854 set_io.basic_info.in.change_time = io.basic_info.out.change_time;
2855 set_io.basic_info.in.attrib = (io.basic_info.out.attrib
2856 | FILE_ATTRIBUTE_COMPRESSED);
2857 status = smb2_setinfo_file(tree, &set_io);
2858 torture_assert_ntstatus_ok(torture, status, "SMB2_SETINFO_FILE");
2859
2860 ZERO_STRUCT(io);
2861 io.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
2862 io.generic.in.file.handle = fh;
2863 status = smb2_getinfo_file(tree, tmp_ctx, &io);
2864 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FILE");
2865
2866 torture_assert(torture,
2867 ((io.basic_info.out.attrib & FILE_ATTRIBUTE_COMPRESSED) == 0),
2868 "compression attr after set");
2869
2870 smb2_util_close(tree, fh);
2871 smb2_deltree(tree, DNAME);
2872 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2873 DNAME, &dirh, 0, SEC_RIGHTS_FILE_ALL,
2874 FILE_ATTRIBUTE_DIRECTORY);
2875 torture_assert(torture, ok, "setup compression directory");
2876
2877 ZERO_STRUCT(io);
2878 io.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
2879 io.generic.in.file.handle = dirh;
2880 status = smb2_getinfo_file(tree, tmp_ctx, &io);
2881 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FILE");
2882
2883 torture_assert(torture,
2884 ((io.basic_info.out.attrib & FILE_ATTRIBUTE_COMPRESSED) == 0),
2885 "compression attr before set");
2886
2887 ZERO_STRUCT(set_io);
2888 set_io.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
2889 set_io.basic_info.in.file.handle = dirh;
2890 set_io.basic_info.in.create_time = io.basic_info.out.create_time;
2891 set_io.basic_info.in.access_time = io.basic_info.out.access_time;
2892 set_io.basic_info.in.write_time = io.basic_info.out.write_time;
2893 set_io.basic_info.in.change_time = io.basic_info.out.change_time;
2894 set_io.basic_info.in.attrib = (io.basic_info.out.attrib
2895 | FILE_ATTRIBUTE_COMPRESSED);
2896 status = smb2_setinfo_file(tree, &set_io);
2897 torture_assert_ntstatus_ok(torture, status, "SMB2_SETINFO_FILE");
2898
2899 status = test_ioctl_compress_get(torture, tmp_ctx, tree, dirh,
2900 &compression_fmt);
2901 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2902
2903 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2904 "dir compression set after SetInfo");
2905
2906 smb2_util_close(tree, dirh);
2907 talloc_free(tmp_ctx);
2908 return true;
2909 }
2910
2911 static bool test_ioctl_compress_perms(struct torture_context *torture,
2912 struct smb2_tree *tree)
2913 {
2914 struct smb2_handle fh;
2915 uint16_t compression_fmt;
2916 union smb_fileinfo io;
2917 NTSTATUS status;
2918 TALLOC_CTX *tmp_ctx = talloc_new(tree);
2919 bool ok;
2920
2921 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2922 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
2923 FILE_ATTRIBUTE_NORMAL);
2924 torture_assert(torture, ok, "setup compression file");
2925
2926 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
2927 &ok);
2928 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
2929 smb2_util_close(tree, fh);
2930 if (!ok) {
2931 torture_skip(torture, "FS compression not supported\n");
2932 }
2933
2934 /* attempt get compression without READ_ATTR permission */
2935 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2936 FNAME, &fh, 0,
2937 (SEC_RIGHTS_FILE_READ & ~(SEC_FILE_READ_ATTRIBUTE
2938 | SEC_STD_READ_CONTROL
2939 | SEC_FILE_READ_EA)),
2940 FILE_ATTRIBUTE_NORMAL);
2941 torture_assert(torture, ok, "setup compression file");
2942
2943 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2944 &compression_fmt);
2945 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2946 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2947 "compression set after create");
2948 smb2_util_close(tree, fh);
2949
2950 /* set compression without WRITE_ATTR permission should succeed */
2951 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2952 FNAME, &fh, 0,
2953 (SEC_RIGHTS_FILE_WRITE & ~(SEC_FILE_WRITE_ATTRIBUTE
2954 | SEC_STD_WRITE_DAC
2955 | SEC_FILE_WRITE_EA)),
2956 FILE_ATTRIBUTE_NORMAL);
2957 torture_assert(torture, ok, "setup compression file");
2958
2959 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
2960 COMPRESSION_FORMAT_DEFAULT);
2961 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_COMPRESSION");
2962 smb2_util_close(tree, fh);
2963
2964 ok = test_setup_open(torture, tree, tmp_ctx,
2965 FNAME, &fh, SEC_RIGHTS_FILE_ALL,
2966 FILE_ATTRIBUTE_NORMAL);
2967 torture_assert(torture, ok, "setup compression file");
2968 ZERO_STRUCT(io);
2969 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
2970 io.generic.in.file.handle = fh;
2971 status = smb2_getinfo_file(tree, tmp_ctx, &io);
2972 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FILE");
2973
2974 torture_assert(torture,
2975 (io.all_info2.out.attrib & FILE_ATTRIBUTE_COMPRESSED),
2976 "incorrect compression attr");
2977 smb2_util_close(tree, fh);
2978
2979 /* attempt get compression without READ_DATA permission */
2980 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2981 FNAME, &fh, 0,
2982 (SEC_RIGHTS_FILE_READ & ~SEC_FILE_READ_DATA),
2983 FILE_ATTRIBUTE_NORMAL);
2984 torture_assert(torture, ok, "setup compression file");
2985
2986 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
2987 &compression_fmt);
2988 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
2989 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
2990 "compression enabled after set");
2991 smb2_util_close(tree, fh);
2992
2993 /* attempt get compression with only SYNCHRONIZE permission */
2994 ok = test_setup_create_fill(torture, tree, tmp_ctx,
2995 FNAME, &fh, 0,
2996 SEC_STD_SYNCHRONIZE,
2997 FILE_ATTRIBUTE_NORMAL);
2998 torture_assert(torture, ok, "setup compression file");
2999
3000 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
3001 &compression_fmt);
3002 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
3003 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
3004 "compression not enabled after set");
3005 smb2_util_close(tree, fh);
3006
3007 /* attempt to set compression without WRITE_DATA permission */
3008 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3009 FNAME, &fh, 0,
3010 (SEC_RIGHTS_FILE_WRITE & (~SEC_FILE_WRITE_DATA)),
3011 FILE_ATTRIBUTE_NORMAL);
3012 torture_assert(torture, ok, "setup compression file");
3013
3014 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
3015 COMPRESSION_FORMAT_DEFAULT);
3016 torture_assert_ntstatus_equal(torture, status,
3017 NT_STATUS_ACCESS_DENIED,
3018 "FSCTL_SET_COMPRESSION permission");
3019 smb2_util_close(tree, fh);
3020
3021 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3022 FNAME, &fh, 0,
3023 (SEC_RIGHTS_FILE_WRITE & (~SEC_FILE_WRITE_DATA)),
3024 FILE_ATTRIBUTE_NORMAL);
3025 torture_assert(torture, ok, "setup compression file");
3026
3027 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
3028 COMPRESSION_FORMAT_NONE);
3029 torture_assert_ntstatus_equal(torture, status,
3030 NT_STATUS_ACCESS_DENIED,
3031 "FSCTL_SET_COMPRESSION permission");
3032 smb2_util_close(tree, fh);
3033
3034 talloc_free(tmp_ctx);
3035 return true;
3036 }
3037
3038 static bool test_ioctl_compress_notsup_get(struct torture_context *torture,
3039 struct smb2_tree *tree)
3040 {
3041 struct smb2_handle fh;
3042 NTSTATUS status;
3043 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3044 bool ok;
3045 uint16_t compression_fmt;
3046
3047 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3048 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
3049 FILE_ATTRIBUTE_NORMAL);
3050 torture_assert(torture, ok, "setup compression file");
3051
3052 /* skip if the server DOES support compression */
3053 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
3054 &ok);
3055 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3056 if (ok) {
3057 smb2_util_close(tree, fh);
3058 torture_skip(torture, "FS compression supported\n");
3059 }
3060
3061 /*
3062 * Despite not supporting compression, we should get a successful
3063 * response indicating that the file is uncompressed - like WS2016.
3064 */
3065 status = test_ioctl_compress_get(torture, tmp_ctx, tree, fh,
3066 &compression_fmt);
3067 torture_assert_ntstatus_ok(torture, status, "FSCTL_GET_COMPRESSION");
3068
3069 torture_assert(torture, (compression_fmt == COMPRESSION_FORMAT_NONE),
3070 "initial compression state not NONE");
3071
3072 smb2_util_close(tree, fh);
3073 talloc_free(tmp_ctx);
3074 return true;
3075 }
3076
3077 static bool test_ioctl_compress_notsup_set(struct torture_context *torture,
3078 struct smb2_tree *tree)
3079 {
3080 struct smb2_handle fh;
3081 NTSTATUS status;
3082 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3083 bool ok;
3084
3085 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3086 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
3087 FILE_ATTRIBUTE_NORMAL);
3088 torture_assert(torture, ok, "setup compression file");
3089
3090 /* skip if the server DOES support compression */
3091 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
3092 &ok);
3093 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3094 if (ok) {
3095 smb2_util_close(tree, fh);
3096 torture_skip(torture, "FS compression supported\n");
3097 }
3098
3099 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
3100 COMPRESSION_FORMAT_DEFAULT);
3101 torture_assert_ntstatus_equal(torture, status,
3102 NT_STATUS_NOT_SUPPORTED,
3103 "FSCTL_SET_COMPRESSION default");
3104
3105 /*
3106 * Despite not supporting compression, we should get a successful
3107 * response for set(COMPRESSION_FORMAT_NONE) - like WS2016 ReFS.
3108 */
3109 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
3110 COMPRESSION_FORMAT_NONE);
3111 torture_assert_ntstatus_ok(torture, status,
3112 "FSCTL_SET_COMPRESSION none");
3113
3114 smb2_util_close(tree, fh);
3115 talloc_free(tmp_ctx);
3116 return true;
3117 }
3118
3119 /*
3120 basic testing of the SMB2 FSCTL_QUERY_NETWORK_INTERFACE_INFO ioctl
3121 */
3122 static bool test_ioctl_network_interface_info(struct torture_context *torture,
3123 struct smb2_tree *tree)
3124 {
3125 union smb_ioctl ioctl;
3126 struct smb2_handle fh;
3127 NTSTATUS status;
3128 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3129 struct fsctl_net_iface_info net_iface;
3130 enum ndr_err_code ndr_ret;
3131 uint32_t caps;
3132
3133 caps = smb2cli_conn_server_capabilities(tree->session->transport->conn);
3134 if (!(caps & SMB2_CAP_MULTI_CHANNEL)) {
3135 torture_skip(torture, "server doesn't support SMB2_CAP_MULTI_CHANNEL\n");
3136 }
3137
3138 ZERO_STRUCT(ioctl);
3139 ioctl.smb2.level = RAW_IOCTL_SMB2;
3140 fh.data[0] = UINT64_MAX;
3141 fh.data[1] = UINT64_MAX;
3142 ioctl.smb2.in.file.handle = fh;
3143 ioctl.smb2.in.function = FSCTL_QUERY_NETWORK_INTERFACE_INFO;
3144 ioctl.smb2.in.max_response_size = 0x10000; /* Windows client sets this to 64KiB */
3145 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3146
3147 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3148 torture_assert_ntstatus_ok(torture, status, "FSCTL_QUERY_NETWORK_INTERFACE_INFO");
3149
3150 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx, &net_iface,
3151 (ndr_pull_flags_fn_t)ndr_pull_fsctl_net_iface_info);
3152 torture_assert_ndr_success(torture, ndr_ret,
3153 "ndr_pull_fsctl_net_iface_info");
3154
3155 ndr_print_debug((ndr_print_fn_t)ndr_print_fsctl_net_iface_info,
3156 "Network Interface Info", &net_iface);
3157
3158 talloc_free(tmp_ctx);
3159 return true;
3160 }
3161
3162 /*
3163 * Check whether all @fs_support_flags are set in the server's
3164 * RAW_QFS_ATTRIBUTE_INFORMATION FileSystemAttributes response.
3165 */
3166 static NTSTATUS test_ioctl_fs_supported(struct torture_context *torture,
3167 struct smb2_tree *tree,
3168 TALLOC_CTX *mem_ctx,
3169 struct smb2_handle *fh,
3170 uint64_t fs_support_flags,
3171 bool *supported)
3172 {
3173 NTSTATUS status;
3174 union smb_fsinfo info;
3175
3176 ZERO_STRUCT(info);
3177 info.generic.level = RAW_QFS_ATTRIBUTE_INFORMATION;
3178 info.generic.handle = *fh;
3179 status = smb2_getinfo_fs(tree, tree, &info);
3180 if (!NT_STATUS_IS_OK(status)) {
3181 return status;
3182 }
3183
3184 if ((info.attribute_info.out.fs_attr & fs_support_flags)
3185 == fs_support_flags) {
3186 *supported = true;
3187 } else {
3188 *supported = false;
3189 }
3190 return NT_STATUS_OK;
3191 }
3192
3193 static NTSTATUS test_ioctl_sparse_req(struct torture_context *torture,
3194 TALLOC_CTX *mem_ctx,
3195 struct smb2_tree *tree,
3196 struct smb2_handle fh,
3197 bool set)
3198 {
3199 union smb_ioctl ioctl;
3200 NTSTATUS status;
3201 uint8_t set_sparse;
3202
3203 ZERO_STRUCT(ioctl);
3204 ioctl.smb2.level = RAW_IOCTL_SMB2;
3205 ioctl.smb2.in.file.handle = fh;
3206 ioctl.smb2.in.function = FSCTL_SET_SPARSE;
3207 ioctl.smb2.in.max_response_size = 0;
3208 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3209 set_sparse = (set ? 0xFF : 0x0);
3210 ioctl.smb2.in.out.data = &set_sparse;
3211 ioctl.smb2.in.out.length = sizeof(set_sparse);
3212
3213 status = smb2_ioctl(tree, mem_ctx, &ioctl.smb2);
3214 return status;
3215 }
3216
3217 static NTSTATUS test_sparse_get(struct torture_context *torture,
3218 TALLOC_CTX *mem_ctx,
3219 struct smb2_tree *tree,
3220 struct smb2_handle fh,
3221 bool *_is_sparse)
3222 {
3223 union smb_fileinfo io;
3224 NTSTATUS status;
3225
3226 ZERO_STRUCT(io);
3227 io.generic.level = RAW_FILEINFO_BASIC_INFORMATION;
3228 io.generic.in.file.handle = fh;
3229 status = smb2_getinfo_file(tree, mem_ctx, &io);
3230 if (!NT_STATUS_IS_OK(status)) {
3231 return status;
3232 }
3233 *_is_sparse = !!(io.basic_info.out.attrib & FILE_ATTRIBUTE_SPARSE);
3234
3235 return status;
3236 }
3237
3238 static bool test_ioctl_sparse_file_flag(struct torture_context *torture,
3239 struct smb2_tree *tree)
3240 {
3241 struct smb2_handle fh;
3242 union smb_fileinfo io;
3243 NTSTATUS status;
3244 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3245 bool ok;
3246 bool is_sparse;
3247
3248 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3249 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
3250 FILE_ATTRIBUTE_NORMAL);
3251 torture_assert(torture, ok, "setup file");
3252
3253 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
3254 FILE_SUPPORTS_SPARSE_FILES, &ok);
3255 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3256 if (!ok) {
3257 smb2_util_close(tree, fh);
3258 torture_skip(torture, "Sparse files not supported\n");
3259 }
3260
3261 ZERO_STRUCT(io);
3262 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
3263 io.generic.in.file.handle = fh;
3264 status = smb2_getinfo_file(tree, tmp_ctx, &io);
3265 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FILE");
3266
3267 torture_assert(torture,
3268 ((io.all_info2.out.attrib & FILE_ATTRIBUTE_SPARSE) == 0),
3269 "sparse attr before set");
3270
3271 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
3272 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3273
3274 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3275 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3276 torture_assert(torture, is_sparse, "no sparse attr after set");
3277
3278 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, false);
3279 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3280
3281 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3282 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3283 torture_assert(torture, !is_sparse, "sparse attr after unset");
3284
3285 smb2_util_close(tree, fh);
3286 talloc_free(tmp_ctx);
3287 return true;
3288 }
3289
3290 static bool test_ioctl_sparse_file_attr(struct torture_context *torture,
3291 struct smb2_tree *tree)
3292 {
3293 struct smb2_handle fh;
3294 NTSTATUS status;
3295 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3296 bool ok;
3297 bool is_sparse;
3298
3299 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3300 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
3301 (FILE_ATTRIBUTE_NORMAL | FILE_ATTRIBUTE_SPARSE));
3302 torture_assert(torture, ok, "setup file");
3303
3304 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
3305 FILE_SUPPORTS_SPARSE_FILES, &ok);
3306 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3307 if (!ok) {
3308 smb2_util_close(tree, fh);
3309 torture_skip(torture, "Sparse files not supported\n");
3310 }
3311
3312 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3313 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3314 torture_assert(torture, !is_sparse, "sparse attr on open");
3315
3316 smb2_util_close(tree, fh);
3317 talloc_free(tmp_ctx);
3318 return true;
3319 }
3320
3321 static bool test_ioctl_sparse_dir_flag(struct torture_context *torture,
3322 struct smb2_tree *tree)
3323 {
3324 struct smb2_handle dirh;
3325 NTSTATUS status;
3326 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3327 bool ok;
3328
3329 smb2_deltree(tree, DNAME);
3330 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3331 DNAME, &dirh, 0, SEC_RIGHTS_FILE_ALL,
3332 FILE_ATTRIBUTE_DIRECTORY);
3333 torture_assert(torture, ok, "setup sparse directory");
3334
3335 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &dirh,
3336 FILE_SUPPORTS_SPARSE_FILES, &ok);
3337 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3338 if (!ok) {
3339 smb2_util_close(tree, dirh);
3340 smb2_deltree(tree, DNAME);
3341 torture_skip(torture, "Sparse files not supported\n");
3342 }
3343
3344 /* set sparse dir should fail, check for 2k12 & 2k8 response */
3345 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, dirh, true);
3346 torture_assert_ntstatus_equal(torture, status,
3347 NT_STATUS_INVALID_PARAMETER,
3348 "dir FSCTL_SET_SPARSE status");
3349
3350 smb2_util_close(tree, dirh);
3351 smb2_deltree(tree, DNAME);
3352 talloc_free(tmp_ctx);
3353 return true;
3354 }
3355
3356 /*
3357 * FSCTL_SET_SPARSE can be sent with (already tested) or without a SetSparse
3358 * buffer to indicate whether the flag should be set or cleared. When sent
3359 * without a buffer, it must be handled as if SetSparse=TRUE.
3360 */
3361 static bool test_ioctl_sparse_set_nobuf(struct torture_context *torture,
3362 struct smb2_tree *tree)
3363 {
3364 struct smb2_handle fh;
3365 union smb_ioctl ioctl;
3366 NTSTATUS status;
3367 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3368 bool ok;
3369 bool is_sparse;
3370
3371 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3372 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
3373 FILE_ATTRIBUTE_NORMAL);
3374 torture_assert(torture, ok, "setup file");
3375
3376 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
3377 FILE_SUPPORTS_SPARSE_FILES, &ok);
3378 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3379 if (!ok) {
3380 smb2_util_close(tree, fh);
3381 torture_skip(torture, "Sparse files not supported\n");
3382 }
3383
3384 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3385 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3386 torture_assert(torture, !is_sparse, "sparse attr before set");
3387
3388 ZERO_STRUCT(ioctl);
3389 ioctl.smb2.level = RAW_IOCTL_SMB2;
3390 ioctl.smb2.in.file.handle = fh;
3391 ioctl.smb2.in.function = FSCTL_SET_SPARSE;
3392 ioctl.smb2.in.max_response_size = 0;
3393 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3394 /* ioctl.smb2.in.out is zeroed, no SetSparse buffer */
3395
3396 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3397 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3398
3399 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3400 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3401 torture_assert(torture, is_sparse, "no sparse attr after set");
3402
3403 /* second non-SetSparse request shouldn't toggle sparse */
3404 ZERO_STRUCT(ioctl);
3405 ioctl.smb2.level = RAW_IOCTL_SMB2;
3406 ioctl.smb2.in.file.handle = fh;
3407 ioctl.smb2.in.function = FSCTL_SET_SPARSE;
3408 ioctl.smb2.in.max_response_size = 0;
3409 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3410
3411 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3412 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3413
3414 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3415 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3416 torture_assert(torture, is_sparse, "no sparse attr after 2nd set");
3417
3418 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, false);
3419 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3420
3421 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3422 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3423 torture_assert(torture, !is_sparse, "sparse attr after unset");
3424
3425 smb2_util_close(tree, fh);
3426 talloc_free(tmp_ctx);
3427 return true;
3428 }
3429
3430 static bool test_ioctl_sparse_set_oversize(struct torture_context *torture,
3431 struct smb2_tree *tree)
3432 {
3433 struct smb2_handle fh;
3434 union smb_ioctl ioctl;
3435 NTSTATUS status;
3436 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3437 bool ok;
3438 bool is_sparse;
3439 uint8_t buf[100];
3440
3441 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3442 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
3443 FILE_ATTRIBUTE_NORMAL);
3444 torture_assert(torture, ok, "setup file");
3445
3446 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
3447 FILE_SUPPORTS_SPARSE_FILES, &ok);
3448 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3449 if (!ok) {
3450 smb2_util_close(tree, fh);
3451 torture_skip(torture, "Sparse files not supported\n");
3452 }
3453
3454 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3455 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3456 torture_assert(torture, !is_sparse, "sparse attr before set");
3457
3458 ZERO_STRUCT(ioctl);
3459 ioctl.smb2.level = RAW_IOCTL_SMB2;
3460 ioctl.smb2.in.file.handle = fh;
3461 ioctl.smb2.in.function = FSCTL_SET_SPARSE;
3462 ioctl.smb2.in.max_response_size = 0;
3463 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3464
3465 /*
3466 * Attach a request buffer larger than FILE_SET_SPARSE_BUFFER
3467 * Windows still successfully processes the request.
3468 */
3469 ZERO_ARRAY(buf);
3470 buf[0] = 0xFF; /* attempt to set sparse */
3471 ioctl.smb2.in.out.data = buf;
3472 ioctl.smb2.in.out.length = ARRAY_SIZE(buf);
3473
3474 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3475 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3476
3477 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3478 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3479 torture_assert(torture, is_sparse, "no sparse attr after set");
3480
3481 ZERO_STRUCT(ioctl);
3482 ioctl.smb2.level = RAW_IOCTL_SMB2;
3483 ioctl.smb2.in.file.handle = fh;
3484 ioctl.smb2.in.function = FSCTL_SET_SPARSE;
3485 ioctl.smb2.in.max_response_size = 0;
3486 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3487
3488 ZERO_ARRAY(buf); /* clear sparse */
3489 ioctl.smb2.in.out.data = buf;
3490 ioctl.smb2.in.out.length = ARRAY_SIZE(buf);
3491
3492 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3493 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3494
3495 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3496 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3497 torture_assert(torture, !is_sparse, "sparse attr after clear");
3498
3499 smb2_util_close(tree, fh);
3500 talloc_free(tmp_ctx);
3501 return true;
3502 }
3503
3504 static NTSTATUS test_ioctl_qar_req(struct torture_context *torture,
3505 TALLOC_CTX *mem_ctx,
3506 struct smb2_tree *tree,
3507 struct smb2_handle fh,
3508 int64_t req_off,
3509 int64_t req_len,
3510 struct file_alloced_range_buf **_rsp,
3511 uint64_t *_rsp_count)
3512 {
3513 union smb_ioctl ioctl;
3514 NTSTATUS status;
3515 enum ndr_err_code ndr_ret;
3516 struct file_alloced_range_buf far_buf;
3517 struct file_alloced_range_buf *far_rsp = NULL;
3518 uint64_t far_count = 0;
3519 int i;
3520 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
3521 if (tmp_ctx == NULL) {
3522 return NT_STATUS_NO_MEMORY;
3523 }
3524
3525 ZERO_STRUCT(ioctl);
3526 ioctl.smb2.level = RAW_IOCTL_SMB2;
3527 ioctl.smb2.in.file.handle = fh;
3528 ioctl.smb2.in.function = FSCTL_QUERY_ALLOCATED_RANGES;
3529 ioctl.smb2.in.max_response_size = 1024;
3530 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3531
3532 far_buf.file_off = req_off;
3533 far_buf.len = req_len;
3534
3535 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
3536 &far_buf,
3537 (ndr_push_flags_fn_t)ndr_push_file_alloced_range_buf);
3538 if (ndr_ret != NDR_ERR_SUCCESS) {
3539 status = NT_STATUS_UNSUCCESSFUL;
3540 goto err_out;
3541 }
3542
3543 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3544 if (!NT_STATUS_IS_OK(status)) {
3545 goto err_out;
3546 }
3547
3548 if (ioctl.smb2.out.out.length == 0) {
3549 goto done;
3550 }
3551
3552 if ((ioctl.smb2.out.out.length % sizeof(far_buf)) != 0) {
3553 torture_comment(torture, "invalid qry_alloced rsp len: %zd:",
3554 ioctl.smb2.out.out.length);
3555 status = NT_STATUS_INVALID_VIEW_SIZE;
3556 goto err_out;
3557 }
3558
3559 far_count = (ioctl.smb2.out.out.length / sizeof(far_buf));
3560 far_rsp = talloc_array(mem_ctx, struct file_alloced_range_buf,
3561 far_count);
3562 if (far_rsp == NULL) {
3563 status = NT_STATUS_NO_MEMORY;
3564 goto err_out;
3565 }
3566
3567 for (i = 0; i < far_count; i++) {
3568 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
3569 &far_rsp[i],
3570 (ndr_pull_flags_fn_t)ndr_pull_file_alloced_range_buf);
3571 if (ndr_ret != NDR_ERR_SUCCESS) {
3572 status = NT_STATUS_UNSUCCESSFUL;
3573 goto err_out;
3574 }
3575 /* move to next buffer */
3576 ioctl.smb2.out.out.data += sizeof(far_buf);
3577 ioctl.smb2.out.out.length -= sizeof(far_buf);
3578 }
3579
3580 done:
3581 *_rsp = far_rsp;
3582 *_rsp_count = far_count;
3583 status = NT_STATUS_OK;
3584 err_out:
3585 talloc_free(tmp_ctx);
3586 return status;
3587 }
3588
3589 static bool test_ioctl_sparse_qar(struct torture_context *torture,
3590 struct smb2_tree *tree)
3591 {
3592 struct smb2_handle fh;
3593 NTSTATUS status;
3594 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3595 bool ok;
3596 bool is_sparse;
3597 struct file_alloced_range_buf *far_rsp = NULL;
3598 uint64_t far_count = 0;
3599
3600 /* zero length file, shouldn't have any ranges */
3601 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3602 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
3603 FILE_ATTRIBUTE_NORMAL);
3604 torture_assert(torture, ok, "setup file");
3605
3606 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
3607 FILE_SUPPORTS_SPARSE_FILES, &ok);
3608 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3609 if (!ok) {
3610 smb2_util_close(tree, fh);
3611 torture_skip(torture, "Sparse files not supported\n");
3612 }
3613
3614 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3615 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3616 torture_assert(torture, !is_sparse, "sparse attr before set");
3617
3618 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3619 0, /* off */
3620 0, /* len */
3621 &far_rsp,
3622 &far_count);
3623 torture_assert_ntstatus_ok(torture, status,
3624 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3625 torture_assert_u64_equal(torture, far_count, 0,
3626 "unexpected response len");
3627
3628 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3629 0, /* off */
3630 1024, /* len */
3631 &far_rsp,
3632 &far_count);
3633 torture_assert_ntstatus_ok(torture, status,
3634 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3635 torture_assert_u64_equal(torture, far_count, 0,
3636 "unexpected response len");
3637
3638 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
3639 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3640
3641 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3642 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3643 torture_assert(torture, is_sparse, "no sparse attr after set");
3644
3645 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3646 0, /* off */
3647 1024, /* len */
3648 &far_rsp,
3649 &far_count);
3650 torture_assert_ntstatus_ok(torture, status,
3651 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3652 torture_assert_u64_equal(torture, far_count, 0,
3653 "unexpected response len");
3654
3655 /* write into the (now) sparse file at 4k offset */
3656 ok = write_pattern(torture, tree, tmp_ctx, fh,
3657 4096, /* off */
3658 1024, /* len */
3659 4096); /* pattern offset */
3660 torture_assert(torture, ok, "write pattern");
3661
3662 /*
3663 * Query range before write off. Whether it's allocated or not is FS
3664 * dependent. NTFS deallocates chunks in 64K increments, but others
3665 * (e.g. XFS, Btrfs, etc.) may deallocate 4K chunks.
3666 */
3667 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3668 0, /* off */
3669 4096, /* len */
3670 &far_rsp,
3671 &far_count);
3672 torture_assert_ntstatus_ok(torture, status,
3673 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3674 if (far_count == 0) {
3675 torture_comment(torture, "FS deallocated 4K chunk\n");
3676 } else {
3677 /* expect fully allocated */
3678 torture_assert_u64_equal(torture, far_count, 1,
3679 "unexpected response len");
3680 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0, "far offset");
3681 torture_assert_u64_equal(torture, far_rsp[0].len, 4096, "far len");
3682 }
3683
3684 /*
3685 * Query range before and past write, it should be allocated up to the
3686 * end of the write.
3687 */
3688 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3689 0, /* off */
3690 8192, /* len */
3691 &far_rsp,
3692 &far_count);
3693 torture_assert_ntstatus_ok(torture, status,
3694 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3695 torture_assert_u64_equal(torture, far_count, 1,
3696 "unexpected response len");
3697 /* FS dependent */
3698 if (far_rsp[0].file_off == 4096) {
3699 /* 4K chunk unallocated */
3700 torture_assert_u64_equal(torture, far_rsp[0].file_off, 4096, "far offset");
3701 torture_assert_u64_equal(torture, far_rsp[0].len, 1024, "far len");
3702 } else {
3703 /* expect fully allocated */
3704 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0, "far offset");
3705 torture_assert_u64_equal(torture, far_rsp[0].len, 5120, "far len");
3706 }
3707
3708 smb2_util_close(tree, fh);
3709 talloc_free(tmp_ctx);
3710 return true;
3711 }
3712
3713 static bool test_ioctl_sparse_qar_malformed(struct torture_context *torture,
3714 struct smb2_tree *tree)
3715 {
3716 struct smb2_handle fh;
3717 union smb_ioctl ioctl;
3718 struct file_alloced_range_buf far_buf;
3719 NTSTATUS status;
3720 enum ndr_err_code ndr_ret;
3721 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3722 bool ok;
3723 size_t old_len;
3724
3725 /* zero length file, shouldn't have any ranges */
3726 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3727 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
3728 FILE_ATTRIBUTE_NORMAL);
3729 torture_assert(torture, ok, "setup file");
3730
3731 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
3732 FILE_SUPPORTS_SPARSE_FILES, &ok);
3733 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3734 if (!ok) {
3735 smb2_util_close(tree, fh);
3736 torture_skip(torture, "Sparse files not supported\n");
3737 }
3738
3739 /* no allocated ranges, no space for range response, should pass */
3740 ZERO_STRUCT(ioctl);
3741 ioctl.smb2.level = RAW_IOCTL_SMB2;
3742 ioctl.smb2.in.file.handle = fh;
3743 ioctl.smb2.in.function = FSCTL_QUERY_ALLOCATED_RANGES;
3744 ioctl.smb2.in.max_response_size = 0;
3745 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3746
3747 far_buf.file_off = 0;
3748 far_buf.len = 1024;
3749 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
3750 &far_buf,
3751 (ndr_push_flags_fn_t)ndr_push_file_alloced_range_buf);
3752 torture_assert_ndr_success(torture, ndr_ret, "push far ndr buf");
3753
3754 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3755 torture_assert_ntstatus_ok(torture, status, "FSCTL_QUERY_ALLOCATED_RANGES");
3756
3757 /* write into the file at 4k offset */
3758 ok = write_pattern(torture, tree, tmp_ctx, fh,
3759 0, /* off */
3760 1024, /* len */
3761 0); /* pattern offset */
3762 torture_assert(torture, ok, "write pattern");
3763
3764 /* allocated range, no space for range response, should fail */
3765 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3766 torture_assert_ntstatus_equal(torture, status,
3767 NT_STATUS_BUFFER_TOO_SMALL, "qar no space");
3768
3769 /* oversize (2x) file_alloced_range_buf in request, should pass */
3770 ioctl.smb2.in.max_response_size = 1024;
3771 old_len = ioctl.smb2.in.out.length;
3772 ok = data_blob_realloc(tmp_ctx, &ioctl.smb2.in.out,
3773 (ioctl.smb2.in.out.length * 2));
3774 torture_assert(torture, ok, "2x data buffer");
3775 memcpy(ioctl.smb2.in.out.data + old_len, ioctl.smb2.in.out.data,
3776 old_len);
3777 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3778 torture_assert_ntstatus_ok(torture, status, "qar too big");
3779
3780 /* no file_alloced_range_buf in request, should fail */
3781 data_blob_free(&ioctl.smb2.in.out);
3782 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3783 torture_assert_ntstatus_equal(torture, status,
3784 NT_STATUS_INVALID_PARAMETER, "qar empty");
3785
3786 return true;
3787 }
3788
3789 /*
3790 * 2.3.57 FSCTL_SET_ZERO_DATA Request
3791 *
3792 * How an implementation zeros data within a file is implementation-dependent.
3793 * A file system MAY choose to deallocate regions of disk space that have been
3794 * zeroed.<50>
3795 * <50>
3796 * ... NTFS might deallocate disk space in the file if the file is stored on an
3797 * NTFS volume, and the file is sparse or compressed. It will free any allocated
3798 * space in chunks of 64 kilobytes that begin at an offset that is a multiple of
3799 * 64 kilobytes. Other bytes in the file (prior to the first freed 64-kilobyte
3800 * chunk and after the last freed 64-kilobyte chunk) will be zeroed but not
3801 * deallocated.
3802 */
3803 static NTSTATUS test_ioctl_zdata_req(struct torture_context *torture,
3804 TALLOC_CTX *mem_ctx,
3805 struct smb2_tree *tree,
3806 struct smb2_handle fh,
3807 int64_t off,
3808 int64_t beyond_final_zero)
3809 {
3810 union smb_ioctl ioctl;
3811 NTSTATUS status;
3812 enum ndr_err_code ndr_ret;
3813 struct file_zero_data_info zdata_info;
3814 TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
3815 if (tmp_ctx == NULL) {
3816 return NT_STATUS_NO_MEMORY;
3817 }
3818
3819 ZERO_STRUCT(ioctl);
3820 ioctl.smb2.level = RAW_IOCTL_SMB2;
3821 ioctl.smb2.in.file.handle = fh;
3822 ioctl.smb2.in.function = FSCTL_SET_ZERO_DATA;
3823 ioctl.smb2.in.max_response_size = 0;
3824 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
3825
3826 zdata_info.file_off = off;
3827 zdata_info.beyond_final_zero = beyond_final_zero;
3828
3829 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
3830 &zdata_info,
3831 (ndr_push_flags_fn_t)ndr_push_file_zero_data_info);
3832 if (ndr_ret != NDR_ERR_SUCCESS) {
3833 status = NT_STATUS_UNSUCCESSFUL;
3834 goto err_out;
3835 }
3836
3837 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
3838 if (!NT_STATUS_IS_OK(status)) {
3839 goto err_out;
3840 }
3841
3842 status = NT_STATUS_OK;
3843 err_out:
3844 talloc_free(tmp_ctx);
3845 return status;
3846 }
3847
3848 static bool test_ioctl_sparse_punch(struct torture_context *torture,
3849 struct smb2_tree *tree)
3850 {
3851 struct smb2_handle fh;
3852 NTSTATUS status;
3853 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3854 bool ok;
3855 bool is_sparse;
3856 struct file_alloced_range_buf *far_rsp = NULL;
3857 uint64_t far_count = 0;
3858
3859 ok = test_setup_create_fill(torture, tree, tmp_ctx,
3860 FNAME, &fh, 4096, SEC_RIGHTS_FILE_ALL,
3861 FILE_ATTRIBUTE_NORMAL);
3862 torture_assert(torture, ok, "setup file");
3863
3864 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
3865 FILE_SUPPORTS_SPARSE_FILES, &ok);
3866 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
3867 if (!ok) {
3868 smb2_util_close(tree, fh);
3869 torture_skip(torture, "Sparse files not supported\n");
3870 }
3871
3872 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
3873 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
3874 torture_assert(torture, !is_sparse, "sparse attr before set");
3875
3876 /* zero (hole-punch) the data, without sparse flag */
3877 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
3878 0, /* off */
3879 4096); /* beyond_final_zero */
3880 torture_assert_ntstatus_ok(torture, status, "zero_data");
3881
3882 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3883 0, /* off */
3884 4096, /* len */
3885 &far_rsp,
3886 &far_count);
3887 torture_assert_ntstatus_ok(torture, status,
3888 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3889 torture_assert_u64_equal(torture, far_count, 1,
3890 "unexpected response len");
3891
3892 /* expect fully allocated */
3893 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
3894 "unexpected far off");
3895 torture_assert_u64_equal(torture, far_rsp[0].len, 4096,
3896 "unexpected far len");
3897 /* check that the data is now zeroed */
3898 ok = check_zero(torture, tree, tmp_ctx, fh, 0, 4096);
3899 torture_assert(torture, ok, "non-sparse zeroed range");
3900
3901 /* set sparse */
3902 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
3903 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3904
3905 /* still fully allocated on NTFS, see note below for Samba */
3906 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3907 0, /* off */
3908 4096, /* len */
3909 &far_rsp,
3910 &far_count);
3911 torture_assert_ntstatus_ok(torture, status,
3912 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3913 /*
3914 * FS specific: Samba uses PUNCH_HOLE to zero the range, and
3915 * subsequently uses fallocate() to allocate the punched range if the
3916 * file is marked non-sparse and "strict allocate" is enabled. In both
3917 * cases, the zeroed range will not be detected by SEEK_DATA, so the
3918 * range won't be present in QAR responses until the file is marked
3919 * non-sparse again.
3920 */
3921 if (far_count == 0) {
3922 torture_comment(torture, "non-sparse zeroed range disappeared "
3923 "after marking sparse\n");
3924 } else {
3925 /* NTFS: range remains fully allocated */
3926 torture_assert_u64_equal(torture, far_count, 1,
3927 "unexpected response len");
3928 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
3929 "unexpected far off");
3930 torture_assert_u64_equal(torture, far_rsp[0].len, 4096,
3931 "unexpected far len");
3932 }
3933
3934 /* zero (hole-punch) the data, _with_ sparse flag */
3935 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
3936 0, /* off */
3937 4096); /* beyond_final_zero */
3938 torture_assert_ntstatus_ok(torture, status, "zero_data");
3939
3940 /* the range should no longer be alloced */
3941 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3942 0, /* off */
3943 4096, /* len */
3944 &far_rsp,
3945 &far_count);
3946 torture_assert_ntstatus_ok(torture, status,
3947 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3948 torture_assert_u64_equal(torture, far_count, 0,
3949 "unexpected response len");
3950
3951 ok = check_zero(torture, tree, tmp_ctx, fh, 0, 4096);
3952 torture_assert(torture, ok, "sparse zeroed range");
3953
3954 /* remove sparse flag, this should "unsparse" the zeroed range */
3955 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, false);
3956 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
3957
3958 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
3959 0, /* off */
3960 4096, /* len */
3961 &far_rsp,
3962 &far_count);
3963 torture_assert_ntstatus_ok(torture, status,
3964 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
3965 torture_assert_u64_equal(torture, far_count, 1,
3966 "unexpected response len");
3967 /* expect fully allocated */
3968 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
3969 "unexpected far off");
3970 torture_assert_u64_equal(torture, far_rsp[0].len, 4096,
3971 "unexpected far len");
3972
3973 ok = check_zero(torture, tree, tmp_ctx, fh, 0, 4096);
3974 torture_assert(torture, ok, "sparse zeroed range");
3975
3976 smb2_util_close(tree, fh);
3977 talloc_free(tmp_ctx);
3978 return true;
3979 }
3980
3981 /*
3982 * Find the point at which a zeroed range in a sparse file is deallocated by the
3983 * underlying filesystem. NTFS on Windows Server 2012 deallocates chunks in 64k
3984 * increments. Also check whether zeroed neighbours are merged for deallocation.
3985 */
3986 static bool test_ioctl_sparse_hole_dealloc(struct torture_context *torture,
3987 struct smb2_tree *tree)
3988 {
3989 struct smb2_handle fh;
3990 NTSTATUS status;
3991 TALLOC_CTX *tmp_ctx = talloc_new(tree);
3992 bool ok;
3993 uint64_t file_size;
3994 uint64_t hlen;
3995 uint64_t dealloc_chunk_len = 0;
3996 struct file_alloced_range_buf *far_rsp = NULL;
3997 uint64_t far_count = 0;
3998
3999 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4000 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
4001 FILE_ATTRIBUTE_NORMAL);
4002 torture_assert(torture, ok, "setup file 1");
4003
4004 /* check for FS sparse file */
4005 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
4006 FILE_SUPPORTS_SPARSE_FILES, &ok);
4007 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
4008 if (!ok) {
4009 smb2_util_close(tree, fh);
4010 torture_skip(torture, "Sparse files not supported\n");
4011 }
4012
4013 /* set sparse */
4014 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4015 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4016
4017 file_size = 1024 * 1024;
4018
4019 ok = write_pattern(torture, tree, tmp_ctx, fh,
4020 0, /* off */
4021 file_size, /* len */
4022 0); /* pattern offset */
4023 torture_assert(torture, ok, "write pattern");
4024
4025 /* check allocated ranges, should be fully allocated */
4026 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4027 0, /* off */
4028 file_size, /* len */
4029 &far_rsp,
4030 &far_count);
4031 torture_assert_ntstatus_ok(torture, status,
4032 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4033 torture_assert_u64_equal(torture, far_count, 1,
4034 "unexpected response len");
4035 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
4036 "unexpected far off");
4037 torture_assert_u64_equal(torture, far_rsp[0].len, file_size,
4038 "unexpected far len");
4039
4040 /* punch holes in sizes of 1k increments */
4041 for (hlen = 0; hlen <= file_size; hlen += 4096) {
4042
4043 /* punch a hole from zero to the current increment */
4044 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4045 0, /* off */
4046 hlen); /* beyond_final_zero */
4047 torture_assert_ntstatus_ok(torture, status, "zero_data");
4048
4049 /* ensure hole is zeroed, and pattern is consistent */
4050 ok = check_zero(torture, tree, tmp_ctx, fh, 0, hlen);
4051 torture_assert(torture, ok, "sparse zeroed range");
4052
4053 ok = check_pattern(torture, tree, tmp_ctx, fh, hlen,
4054 file_size - hlen, hlen);
4055 torture_assert(torture, ok, "allocated pattern range");
4056
4057 /* Check allocated ranges, hole might have been deallocated */
4058 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4059 0, /* off */
4060 file_size, /* len */
4061 &far_rsp,
4062 &far_count);
4063 torture_assert_ntstatus_ok(torture, status,
4064 "FSCTL_QUERY_ALLOCATED_RANGES");
4065 if ((hlen == file_size) && (far_count == 0)) {
4066 /* hole covered entire file, deallocation occurred */
4067 dealloc_chunk_len = file_size;
4068 break;
4069 }
4070
4071 torture_assert_u64_equal(torture, far_count, 1,
4072 "unexpected response len");
4073 if (far_rsp[0].file_off != 0) {
4074 /*
4075 * We now know the hole punch length needed to trigger a
4076 * deallocation on this FS...
4077 */
4078 dealloc_chunk_len = hlen;
4079 torture_comment(torture, "hole punch %ju@0 resulted in "
4080 "deallocation of %ju@0\n",
4081 (uintmax_t)hlen,
4082 (uintmax_t)far_rsp[0].file_off);
4083 torture_assert_u64_equal(torture,
4084 file_size - far_rsp[0].len,
4085 far_rsp[0].file_off,
4086 "invalid alloced range");
4087 break;
4088 }
4089 }
4090
4091 if (dealloc_chunk_len == 0) {
4092 torture_comment(torture, "strange, this FS never deallocates"
4093 "zeroed ranges in sparse files\n");
4094 return true; /* FS specific, not a failure */
4095 }
4096
4097 /*
4098 * Check whether deallocation occurs when the (now known)
4099 * deallocation chunk size is punched via two ZERO_DATA requests.
4100 * I.e. Does the FS merge the two ranges and deallocate the chunk?
4101 * NTFS on Windows Server 2012 does not.
4102 */
4103 ok = write_pattern(torture, tree, tmp_ctx, fh,
4104 0, /* off */
4105 file_size, /* len */
4106 0); /* pattern offset */
4107 torture_assert(torture, ok, "write pattern");
4108
4109 /* divide dealloc chunk size by two, to use as punch length */
4110 hlen = dealloc_chunk_len >> 1;
4111
4112 /*
4113 * /half of dealloc chunk size 1M\
4114 * | |
4115 * /offset 0 | /dealloc chunk size |
4116 * |------------------ |-------------------|-------------------|
4117 * | zeroed, 1st punch | zeroed, 2nd punch | existing pattern |
4118 */
4119 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4120 0, /* off */
4121 hlen); /* beyond final zero */
4122 torture_assert_ntstatus_ok(torture, status, "zero_data");
4123
4124 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4125 hlen, /* off */
4126 dealloc_chunk_len); /* beyond final */
4127 torture_assert_ntstatus_ok(torture, status, "zero_data");
4128
4129 /* ensure holes are zeroed, and pattern is consistent */
4130 ok = check_zero(torture, tree, tmp_ctx, fh, 0, dealloc_chunk_len);
4131 torture_assert(torture, ok, "sparse zeroed range");
4132
4133 ok = check_pattern(torture, tree, tmp_ctx, fh, dealloc_chunk_len,
4134 file_size - dealloc_chunk_len, dealloc_chunk_len);
4135 torture_assert(torture, ok, "allocated pattern range");
4136
4137 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4138 0, /* off */
4139 file_size, /* len */
4140 &far_rsp,
4141 &far_count);
4142 torture_assert_ntstatus_ok(torture, status,
4143 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4144
4145 if ((far_count == 0) && (dealloc_chunk_len == file_size)) {
4146 torture_comment(torture, "holes merged for deallocation of "
4147 "full file\n");
4148 return true;
4149 }
4150 torture_assert_u64_equal(torture, far_count, 1,
4151 "unexpected response len");
4152 if (far_rsp[0].file_off == dealloc_chunk_len) {
4153 torture_comment(torture, "holes merged for deallocation of "
4154 "%ju chunk\n", (uintmax_t)dealloc_chunk_len);
4155 torture_assert_u64_equal(torture,
4156 file_size - far_rsp[0].len,
4157 far_rsp[0].file_off,
4158 "invalid alloced range");
4159 } else {
4160 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
4161 "unexpected deallocation");
4162 torture_comment(torture, "holes not merged for deallocation\n");
4163 }
4164
4165 smb2_util_close(tree, fh);
4166
4167 /*
4168 * Check whether an unwritten range is allocated when a sparse file is
4169 * written to at an offset past the dealloc chunk size:
4170 *
4171 * /dealloc chunk size
4172 * /offset 0 |
4173 * |------------------ |-------------------|
4174 * | unwritten | pattern |
4175 */
4176 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4177 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
4178 FILE_ATTRIBUTE_NORMAL);
4179 torture_assert(torture, ok, "setup file 1");
4180
4181 /* set sparse */
4182 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4183 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4184
4185 ok = write_pattern(torture, tree, tmp_ctx, fh,
4186 dealloc_chunk_len, /* off */
4187 1024, /* len */
4188 dealloc_chunk_len); /* pattern offset */
4189 torture_assert(torture, ok, "write pattern");
4190
4191 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4192 0, /* off */
4193 dealloc_chunk_len + 1024, /* len */
4194 &far_rsp,
4195 &far_count);
4196 torture_assert_ntstatus_ok(torture, status,
4197 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4198 torture_assert_u64_equal(torture, far_count, 1,
4199 "unexpected response len");
4200 if (far_rsp[0].file_off == 0) {
4201 torture_assert_u64_equal(torture, far_rsp[0].len,
4202 dealloc_chunk_len + 1024,
4203 "unexpected far len");
4204 torture_comment(torture, "unwritten range fully allocated\n");
4205 } else {
4206 torture_assert_u64_equal(torture, far_rsp[0].file_off, dealloc_chunk_len,
4207 "unexpected deallocation");
4208 torture_assert_u64_equal(torture, far_rsp[0].len, 1024,
4209 "unexpected far len");
4210 torture_comment(torture, "unwritten range not allocated\n");
4211 }
4212
4213 ok = check_zero(torture, tree, tmp_ctx, fh, 0, dealloc_chunk_len);
4214 torture_assert(torture, ok, "sparse zeroed range");
4215
4216 ok = check_pattern(torture, tree, tmp_ctx, fh, dealloc_chunk_len,
4217 1024, dealloc_chunk_len);
4218 torture_assert(torture, ok, "allocated pattern range");
4219
4220 /* unsparse, should now be fully allocated */
4221 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, false);
4222 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4223
4224 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4225 0, /* off */
4226 dealloc_chunk_len + 1024, /* len */
4227 &far_rsp,
4228 &far_count);
4229 torture_assert_ntstatus_ok(torture, status,
4230 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4231 torture_assert_u64_equal(torture, far_count, 1,
4232 "unexpected response len");
4233 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
4234 "unexpected deallocation");
4235 torture_assert_u64_equal(torture, far_rsp[0].len,
4236 dealloc_chunk_len + 1024,
4237 "unexpected far len");
4238
4239 smb2_util_close(tree, fh);
4240 talloc_free(tmp_ctx);
4241 return true;
4242 }
4243
4244 /* check whether a file with compression and sparse attrs can be deallocated */
4245 static bool test_ioctl_sparse_compressed(struct torture_context *torture,
4246 struct smb2_tree *tree)
4247 {
4248 struct smb2_handle fh;
4249 NTSTATUS status;
4250 TALLOC_CTX *tmp_ctx = talloc_new(tree);
4251 bool ok;
4252 uint64_t file_size = 1024 * 1024;
4253 struct file_alloced_range_buf *far_rsp = NULL;
4254 uint64_t far_count = 0;
4255
4256 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4257 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
4258 FILE_ATTRIBUTE_NORMAL);
4259 torture_assert(torture, ok, "setup file 1");
4260
4261 /* check for FS sparse file and compression support */
4262 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
4263 FILE_SUPPORTS_SPARSE_FILES, &ok);
4264 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
4265 if (!ok) {
4266 smb2_util_close(tree, fh);
4267 torture_skip(torture, "Sparse files not supported\n");
4268 }
4269
4270 status = test_ioctl_compress_fs_supported(torture, tree, tmp_ctx, &fh,
4271 &ok);
4272 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
4273 if (!ok) {
4274 smb2_util_close(tree, fh);
4275 torture_skip(torture, "FS compression not supported\n");
4276 }
4277
4278 /* set compression and write some data */
4279 status = test_ioctl_compress_set(torture, tmp_ctx, tree, fh,
4280 COMPRESSION_FORMAT_DEFAULT);
4281 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_COMPRESSION");
4282
4283 ok = write_pattern(torture, tree, tmp_ctx, fh,
4284 0, /* off */
4285 file_size, /* len */
4286 0); /* pattern offset */
4287 torture_assert(torture, ok, "write pattern");
4288
4289 /* set sparse - now sparse and compressed */
4290 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4291 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4292
4293 /* check allocated ranges, should be fully alloced */
4294 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4295 0, /* off */
4296 file_size, /* len */
4297 &far_rsp,
4298 &far_count);
4299 torture_assert_ntstatus_ok(torture, status,
4300 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4301 torture_assert_u64_equal(torture, far_count, 1,
4302 "unexpected response len");
4303 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
4304 "unexpected far off");
4305 torture_assert_u64_equal(torture, far_rsp[0].len, file_size,
4306 "unexpected far len");
4307
4308 /* zero (hole-punch) all data, with sparse and compressed attrs */
4309 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4310 0, /* off */
4311 file_size); /* beyond_final_zero */
4312 torture_assert_ntstatus_ok(torture, status, "zero_data");
4313
4314 /*
4315 * Windows Server 2012 still deallocates a zeroed range when a sparse
4316 * file carries the compression attribute.
4317 */
4318 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4319 0, /* off */
4320 file_size, /* len */
4321 &far_rsp,
4322 &far_count);
4323 torture_assert_ntstatus_ok(torture, status,
4324 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4325 if (far_count == 0) {
4326 torture_comment(torture, "sparse & compressed file "
4327 "deallocated after hole-punch\n");
4328 } else {
4329 torture_assert_u64_equal(torture, far_count, 1,
4330 "unexpected response len");
4331 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
4332 "unexpected far off");
4333 torture_assert_u64_equal(torture, far_rsp[0].len, file_size,
4334 "unexpected far len");
4335 torture_comment(torture, "sparse & compressed file fully "
4336 "allocated after hole-punch\n");
4337 }
4338
4339 smb2_util_close(tree, fh);
4340 talloc_free(tmp_ctx);
4341 return true;
4342 }
4343
4344 /*
4345 * Create a sparse file, then attempt to copy unallocated and allocated ranges
4346 * into a target file using FSCTL_SRV_COPYCHUNK.
4347 */
4348 static bool test_ioctl_sparse_copy_chunk(struct torture_context *torture,
4349 struct smb2_tree *tree)
4350 {
4351 struct smb2_handle src_h;
4352 struct smb2_handle dest_h;
4353 NTSTATUS status;
4354 TALLOC_CTX *tmp_ctx = talloc_new(tree);
4355 bool ok;
4356 uint64_t dealloc_chunk_len = 64 * 1024; /* Windows 2012 */
4357 struct file_alloced_range_buf *far_rsp = NULL;
4358 uint64_t far_count = 0;
4359 union smb_ioctl ioctl;
4360 struct srv_copychunk_copy cc_copy;
4361 struct srv_copychunk_rsp cc_rsp;
4362 enum ndr_err_code ndr_ret;
4363
4364 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4365 FNAME, &src_h, 0, SEC_RIGHTS_FILE_ALL,
4366 FILE_ATTRIBUTE_NORMAL);
4367 torture_assert(torture, ok, "setup file");
4368
4369 /* check for FS sparse file support */
4370 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &src_h,
4371 FILE_SUPPORTS_SPARSE_FILES, &ok);
4372 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
4373 smb2_util_close(tree, src_h);
4374 if (!ok) {
4375 torture_skip(torture, "Sparse files not supported\n");
4376 }
4377
4378 ok = test_setup_copy_chunk(torture, tree, tree, tmp_ctx,
4379 1, /* chunks */
4380 FNAME,
4381 &src_h, 0, /* src file */
4382 SEC_RIGHTS_FILE_ALL,
4383 FNAME2,
4384 &dest_h, 0, /* dest file */
4385 SEC_RIGHTS_FILE_ALL,
4386 &cc_copy,
4387 &ioctl);
4388 torture_assert(torture, ok, "setup copy chunk error");
4389
4390 /* set sparse */
4391 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, src_h, true);
4392 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4393
4394 /* start after dealloc_chunk_len, to create an unwritten sparse range */
4395 ok = write_pattern(torture, tree, tmp_ctx, src_h,
4396 dealloc_chunk_len, /* off */
4397 1024, /* len */
4398 dealloc_chunk_len); /* pattern offset */
4399 torture_assert(torture, ok, "write pattern");
4400
4401 /* Skip test if 64k chunk is allocated - FS specific */
4402 status = test_ioctl_qar_req(torture, tmp_ctx, tree, src_h,
4403 0, /* off */
4404 dealloc_chunk_len + 1024, /* len */
4405 &far_rsp,
4406 &far_count);
4407 torture_assert_ntstatus_ok(torture, status,
4408 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4409 torture_assert_u64_equal(torture, far_count, 1,
4410 "unexpected response len");
4411 if (far_rsp[0].file_off == 0) {
4412 torture_skip(torture, "unwritten range fully allocated\n");
4413 }
4414
4415 torture_assert_u64_equal(torture, far_rsp[0].file_off, dealloc_chunk_len,
4416 "unexpected allocation");
4417 torture_assert_u64_equal(torture, far_rsp[0].len, 1024,
4418 "unexpected far len");
4419
4420 /* copy-chunk unallocated + written ranges into non-sparse dest */
4421
4422 cc_copy.chunks[0].source_off = 0;
4423 cc_copy.chunks[0].target_off = 0;
4424 cc_copy.chunks[0].length = dealloc_chunk_len + 1024;
4425
4426 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
4427 &cc_copy,
4428 (ndr_push_flags_fn_t)ndr_push_srv_copychunk_copy);
4429 torture_assert_ndr_success(torture, ndr_ret,
4430 "ndr_push_srv_copychunk_copy");
4431
4432 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
4433 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_COPYCHUNK");
4434
4435 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
4436 &cc_rsp,
4437 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
4438 torture_assert_ndr_success(torture, ndr_ret,
4439 "ndr_pull_srv_copychunk_rsp");
4440
4441 ok = check_copy_chunk_rsp(torture, &cc_rsp,
4442 1, /* chunks written */
4443 0, /* chunk bytes unsuccessfully written */
4444 dealloc_chunk_len + 1024); /* bytes written */
4445 torture_assert(torture, ok, "bad copy chunk response data");
4446
4447 ok = check_zero(torture, tree, tmp_ctx, dest_h, 0, dealloc_chunk_len);
4448 torture_assert(torture, ok, "sparse zeroed range");
4449
4450 ok = check_pattern(torture, tree, tmp_ctx, dest_h, dealloc_chunk_len,
4451 1024, dealloc_chunk_len);
4452 torture_assert(torture, ok, "copychunked range");
4453
4454 /* copied range should be allocated in non-sparse dest */
4455 status = test_ioctl_qar_req(torture, tmp_ctx, tree, dest_h,
4456 0, /* off */
4457 dealloc_chunk_len + 1024, /* len */
4458 &far_rsp,
4459 &far_count);
4460 torture_assert_ntstatus_ok(torture, status,
4461 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4462 torture_assert_u64_equal(torture, far_count, 1,
4463 "unexpected response len");
4464 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
4465 "unexpected allocation");
4466 torture_assert_u64_equal(torture, far_rsp[0].len,
4467 dealloc_chunk_len + 1024,
4468 "unexpected far len");
4469
4470 /* set dest as sparse */
4471 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, dest_h, true);
4472 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4473
4474 /* zero (hole-punch) all data */
4475 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, dest_h,
4476 0, /* off */
4477 dealloc_chunk_len + 1024);
4478 torture_assert_ntstatus_ok(torture, status, "zero_data");
4479
4480 /* zeroed range might be deallocated */
4481 status = test_ioctl_qar_req(torture, tmp_ctx, tree, dest_h,
4482 0, /* off */
4483 dealloc_chunk_len + 1024, /* len */
4484 &far_rsp,
4485 &far_count);
4486 torture_assert_ntstatus_ok(torture, status,
4487 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4488 if (far_count == 0) {
4489 /* FS specific (e.g. NTFS) */
4490 torture_comment(torture, "FS deallocates file on full-range "
4491 "punch\n");
4492 } else {
4493 /* FS specific (e.g. EXT4) */
4494 torture_comment(torture, "FS doesn't deallocate file on "
4495 "full-range punch\n");
4496 }
4497 ok = check_zero(torture, tree, tmp_ctx, dest_h, 0,
4498 dealloc_chunk_len + 1024);
4499 torture_assert(torture, ok, "punched zeroed range");
4500
4501 /* copy-chunk again, this time with sparse dest */
4502 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
4503 torture_assert_ntstatus_ok(torture, status, "FSCTL_SRV_COPYCHUNK");
4504
4505 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
4506 &cc_rsp,
4507 (ndr_pull_flags_fn_t)ndr_pull_srv_copychunk_rsp);
4508 torture_assert_ndr_success(torture, ndr_ret,
4509 "ndr_pull_srv_copychunk_rsp");
4510
4511 ok = check_copy_chunk_rsp(torture, &cc_rsp,
4512 1, /* chunks written */
4513 0, /* chunk bytes unsuccessfully written */
4514 dealloc_chunk_len + 1024); /* bytes written */
4515 torture_assert(torture, ok, "bad copy chunk response data");
4516
4517 ok = check_zero(torture, tree, tmp_ctx, dest_h, 0, dealloc_chunk_len);
4518 torture_assert(torture, ok, "sparse zeroed range");
4519
4520 ok = check_pattern(torture, tree, tmp_ctx, dest_h, dealloc_chunk_len,
4521 1024, dealloc_chunk_len);
4522 torture_assert(torture, ok, "copychunked range");
4523
4524 /* copied range may be allocated in sparse dest */
4525 status = test_ioctl_qar_req(torture, tmp_ctx, tree, dest_h,
4526 0, /* off */
4527 dealloc_chunk_len + 1024, /* len */
4528 &far_rsp,
4529 &far_count);
4530 torture_assert_ntstatus_ok(torture, status,
4531 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4532 torture_assert_u64_equal(torture, far_count, 1,
4533 "unexpected response len");
4534 /*
4535 * FS specific: sparse region may be unallocated in dest if copy-chunk
4536 * is handled in a sparse preserving way - E.g. vfs_btrfs
4537 * with BTRFS_IOC_CLONE_RANGE.
4538 */
4539 if (far_rsp[0].file_off == dealloc_chunk_len) {
4540 torture_comment(torture, "copy-chunk sparse range preserved\n");
4541 torture_assert_u64_equal(torture, far_rsp[0].len, 1024,
4542 "unexpected far len");
4543 } else {
4544 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
4545 "unexpected allocation");
4546 torture_assert_u64_equal(torture, far_rsp[0].len,
4547 dealloc_chunk_len + 1024,
4548 "unexpected far len");
4549 }
4550
4551 smb2_util_close(tree, src_h);
4552 smb2_util_close(tree, dest_h);
4553 talloc_free(tmp_ctx);
4554 return true;
4555 }
4556
4557 static bool test_ioctl_sparse_punch_invalid(struct torture_context *torture,
4558 struct smb2_tree *tree)
4559 {
4560 struct smb2_handle fh;
4561 NTSTATUS status;
4562 TALLOC_CTX *tmp_ctx = talloc_new(tree);
4563 bool ok;
4564 bool is_sparse;
4565 int i;
4566
4567 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4568 FNAME, &fh, 4096, SEC_RIGHTS_FILE_ALL,
4569 FILE_ATTRIBUTE_NORMAL);
4570 torture_assert(torture, ok, "setup file");
4571
4572 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
4573 FILE_SUPPORTS_SPARSE_FILES, &ok);
4574 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
4575 if (!ok) {
4576 smb2_util_close(tree, fh);
4577 torture_skip(torture, "Sparse files not supported\n");
4578 }
4579
4580 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
4581 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
4582 torture_assert(torture, !is_sparse, "sparse attr before set");
4583
4584 /* loop twice, without and with sparse attrib */
4585 for (i = 0; i <= 1; i++) {
4586 union smb_fileinfo io;
4587 struct file_alloced_range_buf *far_rsp = NULL;
4588 uint64_t far_count = 0;
4589
4590 /* get size before & after. zero data should never change it */
4591 ZERO_STRUCT(io);
4592 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
4593 io.generic.in.file.handle = fh;
4594 status = smb2_getinfo_file(tree, tmp_ctx, &io);
4595 torture_assert_ntstatus_ok(torture, status, "getinfo");
4596 torture_assert_int_equal(torture, (int)io.all_info2.out.size,
4597 4096, "size after IO");
4598
4599 /* valid 8 byte zero data, but after EOF */
4600 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4601 4096, /* off */
4602 4104); /* beyond_final_zero */
4603 torture_assert_ntstatus_ok(torture, status, "zero_data");
4604
4605 /* valid 8 byte zero data, but after EOF */
4606 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4607 8192, /* off */
4608 8200); /* beyond_final_zero */
4609 torture_assert_ntstatus_ok(torture, status, "zero_data");
4610
4611 ZERO_STRUCT(io);
4612 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
4613 io.generic.in.file.handle = fh;
4614 status = smb2_getinfo_file(tree, tmp_ctx, &io);
4615 torture_assert_ntstatus_ok(torture, status, "getinfo");
4616 torture_assert_int_equal(torture, (int)io.all_info2.out.size,
4617 4096, "size after IO");
4618
4619 /* valid 0 byte zero data, without sparse flag */
4620 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4621 4095, /* off */
4622 4095); /* beyond_final_zero */
4623 torture_assert_ntstatus_ok(torture, status, "zero_data");
4624
4625 /* INVALID off is past beyond_final_zero */
4626 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4627 4096, /* off */
4628 4095); /* beyond_final_zero */
4629 torture_assert_ntstatus_equal(torture, status,
4630 NT_STATUS_INVALID_PARAMETER,
4631 "invalid zero_data");
4632
4633 /* zero length QAR - valid */
4634 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4635 0, /* off */
4636 0, /* len */
4637 &far_rsp, &far_count);
4638 torture_assert_ntstatus_ok(torture, status,
4639 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4640 torture_assert_u64_equal(torture, far_count, 0,
4641 "unexpected response len");
4642
4643 /* QAR after EOF - valid */
4644 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4645 4096, /* off */
4646 1024, /* len */
4647 &far_rsp, &far_count);
4648 torture_assert_ntstatus_ok(torture, status,
4649 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4650 torture_assert_u64_equal(torture, far_count, 0,
4651 "unexpected response len");
4652
4653 /* set sparse */
4654 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh,
4655 true);
4656 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4657 }
4658
4659 smb2_util_close(tree, fh);
4660 talloc_free(tmp_ctx);
4661 return true;
4662 }
4663
4664 static bool test_ioctl_sparse_perms(struct torture_context *torture,
4665 struct smb2_tree *tree)
4666 {
4667 struct smb2_handle fh;
4668 NTSTATUS status;
4669 TALLOC_CTX *tmp_ctx = talloc_new(tree);
4670 bool ok;
4671 bool is_sparse;
4672 struct file_alloced_range_buf *far_rsp = NULL;
4673 uint64_t far_count = 0;
4674
4675 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4676 FNAME, &fh, 0, SEC_RIGHTS_FILE_ALL,
4677 FILE_ATTRIBUTE_NORMAL);
4678 torture_assert(torture, ok, "setup file");
4679
4680 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
4681 FILE_SUPPORTS_SPARSE_FILES, &ok);
4682 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
4683 smb2_util_close(tree, fh);
4684 if (!ok) {
4685 torture_skip(torture, "Sparse files not supported\n");
4686 }
4687
4688 /* set sparse without WRITE_ATTR permission should succeed */
4689 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4690 FNAME, &fh, 0,
4691 (SEC_RIGHTS_FILE_WRITE & ~(SEC_FILE_WRITE_ATTRIBUTE
4692 | SEC_STD_WRITE_DAC
4693 | SEC_FILE_WRITE_EA)),
4694 FILE_ATTRIBUTE_NORMAL);
4695 torture_assert(torture, ok, "setup file");
4696
4697 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4698 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4699 smb2_util_close(tree, fh);
4700
4701 ok = test_setup_open(torture, tree, tmp_ctx,
4702 FNAME, &fh, SEC_RIGHTS_FILE_ALL,
4703 FILE_ATTRIBUTE_NORMAL);
4704 torture_assert(torture, ok, "setup file");
4705 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
4706 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
4707 torture_assert(torture, is_sparse, "sparse after set");
4708 smb2_util_close(tree, fh);
4709
4710 /* attempt get sparse without READ_DATA permission */
4711 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4712 FNAME, &fh, 0,
4713 (SEC_RIGHTS_FILE_READ & ~SEC_FILE_READ_DATA),
4714 FILE_ATTRIBUTE_NORMAL);
4715 torture_assert(torture, ok, "setup file");
4716
4717 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
4718 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
4719 torture_assert(torture, !is_sparse, "sparse set");
4720 smb2_util_close(tree, fh);
4721
4722 /* attempt to set sparse with only WRITE_ATTR permission */
4723 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4724 FNAME, &fh, 0,
4725 SEC_FILE_WRITE_ATTRIBUTE,
4726 FILE_ATTRIBUTE_NORMAL);
4727 torture_assert(torture, ok, "setup file");
4728
4729 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4730 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4731 smb2_util_close(tree, fh);
4732
4733 /* attempt to set sparse with only WRITE_DATA permission */
4734 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4735 FNAME, &fh, 0,
4736 SEC_FILE_WRITE_DATA,
4737 FILE_ATTRIBUTE_NORMAL);
4738 torture_assert(torture, ok, "setup file");
4739
4740 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4741 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4742 smb2_util_close(tree, fh);
4743
4744 ok = test_setup_open(torture, tree, tmp_ctx,
4745 FNAME, &fh, SEC_RIGHTS_FILE_ALL,
4746 FILE_ATTRIBUTE_NORMAL);
4747 torture_assert(torture, ok, "setup file");
4748 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
4749 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
4750 torture_assert(torture, is_sparse, "sparse after set");
4751 smb2_util_close(tree, fh);
4752
4753 /* attempt to set sparse with only APPEND_DATA permission */
4754 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4755 FNAME, &fh, 0,
4756 SEC_FILE_APPEND_DATA,
4757 FILE_ATTRIBUTE_NORMAL);
4758 torture_assert(torture, ok, "setup file");
4759
4760 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4761 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4762 smb2_util_close(tree, fh);
4763
4764 ok = test_setup_open(torture, tree, tmp_ctx,
4765 FNAME, &fh, SEC_RIGHTS_FILE_ALL,
4766 FILE_ATTRIBUTE_NORMAL);
4767 torture_assert(torture, ok, "setup file");
4768 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
4769 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
4770 torture_assert(torture, is_sparse, "sparse after set");
4771 smb2_util_close(tree, fh);
4772
4773 /* attempt to set sparse with only WRITE_EA permission - should fail */
4774 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4775 FNAME, &fh, 0,
4776 SEC_FILE_WRITE_EA,
4777 FILE_ATTRIBUTE_NORMAL);
4778 torture_assert(torture, ok, "setup file");
4779
4780 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4781 torture_assert_ntstatus_equal(torture, status,
4782 NT_STATUS_ACCESS_DENIED,
4783 "FSCTL_SET_SPARSE permission");
4784 smb2_util_close(tree, fh);
4785
4786 ok = test_setup_open(torture, tree, tmp_ctx,
4787 FNAME, &fh, SEC_RIGHTS_FILE_ALL,
4788 FILE_ATTRIBUTE_NORMAL);
4789 torture_assert(torture, ok, "setup file");
4790 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
4791 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
4792 torture_assert(torture, !is_sparse, "sparse after set");
4793 smb2_util_close(tree, fh);
4794
4795 /* attempt QAR with only READ_ATTR permission - should fail */
4796 ok = test_setup_open(torture, tree, tmp_ctx,
4797 FNAME, &fh, SEC_FILE_READ_ATTRIBUTE,
4798 FILE_ATTRIBUTE_NORMAL);
4799 torture_assert(torture, ok, "setup file");
4800 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4801 4096, /* off */
4802 1024, /* len */
4803 &far_rsp, &far_count);
4804 torture_assert_ntstatus_equal(torture, status,
4805 NT_STATUS_ACCESS_DENIED,
4806 "FSCTL_QUERY_ALLOCATED_RANGES req passed");
4807 smb2_util_close(tree, fh);
4808
4809 /* attempt QAR with only READ_DATA permission */
4810 ok = test_setup_open(torture, tree, tmp_ctx,
4811 FNAME, &fh, SEC_FILE_READ_DATA,
4812 FILE_ATTRIBUTE_NORMAL);
4813 torture_assert(torture, ok, "setup file");
4814 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4815 0, /* off */
4816 1024, /* len */
4817 &far_rsp, &far_count);
4818 torture_assert_ntstatus_ok(torture, status,
4819 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
4820 torture_assert_u64_equal(torture, far_count, 0,
4821 "unexpected response len");
4822 smb2_util_close(tree, fh);
4823
4824 /* attempt QAR with only READ_EA permission - should fail */
4825 ok = test_setup_open(torture, tree, tmp_ctx,
4826 FNAME, &fh, SEC_FILE_READ_EA,
4827 FILE_ATTRIBUTE_NORMAL);
4828 torture_assert(torture, ok, "setup file");
4829 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4830 4096, /* off */
4831 1024, /* len */
4832 &far_rsp, &far_count);
4833 torture_assert_ntstatus_equal(torture, status,
4834 NT_STATUS_ACCESS_DENIED,
4835 "FSCTL_QUERY_ALLOCATED_RANGES req passed");
4836 smb2_util_close(tree, fh);
4837
4838 /* setup file for ZERO_DATA permissions tests */
4839 ok = test_setup_create_fill(torture, tree, tmp_ctx,
4840 FNAME, &fh, 8192,
4841 SEC_RIGHTS_FILE_ALL,
4842 FILE_ATTRIBUTE_NORMAL);
4843 torture_assert(torture, ok, "setup file");
4844
4845 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4846 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4847 smb2_util_close(tree, fh);
4848
4849 /* attempt ZERO_DATA with only WRITE_ATTR permission - should fail */
4850 ok = test_setup_open(torture, tree, tmp_ctx,
4851 FNAME, &fh, SEC_FILE_WRITE_ATTRIBUTE,
4852 FILE_ATTRIBUTE_NORMAL);
4853 torture_assert(torture, ok, "setup file");
4854 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4855 0, /* off */
4856 4096); /* beyond_final_zero */
4857 torture_assert_ntstatus_equal(torture, status,
4858 NT_STATUS_ACCESS_DENIED,
4859 "zero_data permission");
4860 smb2_util_close(tree, fh);
4861
4862 /* attempt ZERO_DATA with only WRITE_DATA permission */
4863 ok = test_setup_open(torture, tree, tmp_ctx,
4864 FNAME, &fh, SEC_FILE_WRITE_DATA,
4865 FILE_ATTRIBUTE_NORMAL);
4866 torture_assert(torture, ok, "setup file");
4867 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4868 0, /* off */
4869 4096); /* beyond_final_zero */
4870 torture_assert_ntstatus_ok(torture, status, "zero_data");
4871 smb2_util_close(tree, fh);
4872
4873 /* attempt ZERO_DATA with only APPEND_DATA permission - should fail */
4874 ok = test_setup_open(torture, tree, tmp_ctx,
4875 FNAME, &fh, SEC_FILE_APPEND_DATA,
4876 FILE_ATTRIBUTE_NORMAL);
4877 torture_assert(torture, ok, "setup file");
4878 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4879 0, /* off */
4880 4096); /* beyond_final_zero */
4881 torture_assert_ntstatus_equal(torture, status,
4882 NT_STATUS_ACCESS_DENIED,
4883 "zero_data permission");
4884 smb2_util_close(tree, fh);
4885
4886 /* attempt ZERO_DATA with only WRITE_EA permission - should fail */
4887 ok = test_setup_open(torture, tree, tmp_ctx,
4888 FNAME, &fh, SEC_FILE_WRITE_EA,
4889 FILE_ATTRIBUTE_NORMAL);
4890 torture_assert(torture, ok, "setup file");
4891 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4892 0, /* off */
4893 4096); /* beyond_final_zero */
4894 torture_assert_ntstatus_equal(torture, status,
4895 NT_STATUS_ACCESS_DENIED,
4896 "zero_data permission");
4897 smb2_util_close(tree, fh);
4898
4899 talloc_free(tmp_ctx);
4900 return true;
4901 }
4902
4903 static bool test_ioctl_sparse_lck(struct torture_context *torture,
4904 struct smb2_tree *tree)
4905 {
4906 struct smb2_handle fh;
4907 struct smb2_handle fh2;
4908 NTSTATUS status;
4909 uint64_t dealloc_chunk_len = 64 * 1024; /* Windows 2012 */
4910 TALLOC_CTX *tmp_ctx = talloc_new(tree);
4911 bool ok;
4912 bool is_sparse;
4913 struct smb2_lock lck;
4914 struct smb2_lock_element el[1];
4915 struct file_alloced_range_buf *far_rsp = NULL;
4916 uint64_t far_count = 0;
4917
4918 ok = test_setup_create_fill(torture, tree, tmp_ctx, FNAME, &fh,
4919 dealloc_chunk_len, SEC_RIGHTS_FILE_ALL,
4920 FILE_ATTRIBUTE_NORMAL);
4921 torture_assert(torture, ok, "setup file");
4922
4923 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
4924 FILE_SUPPORTS_SPARSE_FILES, &ok);
4925 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
4926 if (!ok) {
4927 torture_skip(torture, "Sparse files not supported\n");
4928 smb2_util_close(tree, fh);
4929 }
4930
4931 /* open and lock via separate fh2 */
4932 status = torture_smb2_testfile(tree, FNAME, &fh2);
4933 torture_assert_ntstatus_ok(torture, status, "2nd src open");
4934
4935 lck.in.lock_count = 0x0001;
4936 lck.in.lock_sequence = 0x00000000;
4937 lck.in.file.handle = fh2;
4938 lck.in.locks = el;
4939 el[0].offset = 0;
4940 el[0].length = dealloc_chunk_len;
4941 el[0].reserved = 0;
4942 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
4943
4944 status = smb2_lock(tree, &lck);
4945 torture_assert_ntstatus_ok(torture, status, "lock");
4946
4947 /* set sparse while locked */
4948 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
4949 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
4950
4951 status = test_sparse_get(torture, tmp_ctx, tree, fh, &is_sparse);
4952 torture_assert_ntstatus_ok(torture, status, "test_sparse_get");
4953 torture_assert(torture, is_sparse, "sparse attr after set");
4954
4955 /* zero data over locked range should fail */
4956 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4957 0, /* off */
4958 4096); /* beyond_final_zero */
4959 torture_assert_ntstatus_equal(torture, status,
4960 NT_STATUS_FILE_LOCK_CONFLICT,
4961 "zero_data locked");
4962
4963 /* QAR over locked range should pass */
4964 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4965 0, /* off */
4966 4096, /* len */
4967 &far_rsp, &far_count);
4968 torture_assert_ntstatus_ok(torture, status,
4969 "FSCTL_QUERY_ALLOCATED_RANGES locked");
4970 torture_assert_u64_equal(torture, far_count, 1,
4971 "unexpected response len");
4972 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
4973 "unexpected allocation");
4974 torture_assert_u64_equal(torture, far_rsp[0].len,
4975 4096,
4976 "unexpected far len");
4977
4978 /* zero data over range past EOF should pass */
4979 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
4980 dealloc_chunk_len, /* off */
4981 dealloc_chunk_len + 4096);
4982 torture_assert_ntstatus_ok(torture, status,
4983 "zero_data past EOF locked");
4984
4985 /* QAR over range past EOF should pass */
4986 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
4987 dealloc_chunk_len, /* off */
4988 4096, /* len */
4989 &far_rsp, &far_count);
4990 torture_assert_ntstatus_ok(torture, status,
4991 "FSCTL_QUERY_ALLOCATED_RANGES past EOF locked");
4992 torture_assert_u64_equal(torture, far_count, 0,
4993 "unexpected response len");
4994
4995 lck.in.lock_count = 0x0001;
4996 lck.in.lock_sequence = 0x00000001;
4997 lck.in.file.handle = fh2;
4998 lck.in.locks = el;
4999 el[0].offset = 0;
5000 el[0].length = dealloc_chunk_len;
5001 el[0].reserved = 0;
5002 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
5003 status = smb2_lock(tree, &lck);
5004 torture_assert_ntstatus_ok(torture, status, "unlock");
5005
5006 smb2_util_close(tree, fh2);
5007 smb2_util_close(tree, fh);
5008 talloc_free(tmp_ctx);
5009 return true;
5010 }
5011
5012 /* alleviate QAR off-by-one bug paranoia - help me ob1 */
5013 static bool test_ioctl_sparse_qar_ob1(struct torture_context *torture,
5014 struct smb2_tree *tree)
5015 {
5016 struct smb2_handle fh;
5017 NTSTATUS status;
5018 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5019 bool ok;
5020 uint64_t dealloc_chunk_len = 64 * 1024; /* Windows 2012 */
5021 struct file_alloced_range_buf *far_rsp = NULL;
5022 uint64_t far_count = 0;
5023
5024 ok = test_setup_create_fill(torture, tree, tmp_ctx,
5025 FNAME, &fh, dealloc_chunk_len * 2,
5026 SEC_RIGHTS_FILE_ALL,
5027 FILE_ATTRIBUTE_NORMAL);
5028 torture_assert(torture, ok, "setup file");
5029
5030 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
5031 FILE_SUPPORTS_SPARSE_FILES, &ok);
5032 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
5033 if (!ok) {
5034 torture_skip(torture, "Sparse files not supported\n");
5035 smb2_util_close(tree, fh);
5036 }
5037
5038 /* non-sparse QAR with range one before EOF */
5039 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5040 0, /* off */
5041 dealloc_chunk_len * 2 - 1, /* len */
5042 &far_rsp, &far_count);
5043 torture_assert_ntstatus_ok(torture, status,
5044 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5045 torture_assert_u64_equal(torture, far_count, 1,
5046 "unexpected response len");
5047 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
5048 "unexpected allocation");
5049 torture_assert_u64_equal(torture, far_rsp[0].len,
5050 dealloc_chunk_len * 2 - 1,
5051 "unexpected far len");
5052
5053 /* non-sparse QAR with range one after EOF */
5054 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5055 0, /* off */
5056 dealloc_chunk_len * 2 + 1, /* len */
5057 &far_rsp, &far_count);
5058 torture_assert_ntstatus_ok(torture, status,
5059 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5060 torture_assert_u64_equal(torture, far_count, 1,
5061 "unexpected response len");
5062 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
5063 "unexpected allocation");
5064 torture_assert_u64_equal(torture, far_rsp[0].len,
5065 dealloc_chunk_len * 2,
5066 "unexpected far len");
5067
5068 /* non-sparse QAR with range one after EOF from off=1 */
5069 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5070 1, /* off */
5071 dealloc_chunk_len * 2, /* len */
5072 &far_rsp, &far_count);
5073 torture_assert_ntstatus_ok(torture, status,
5074 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5075 torture_assert_u64_equal(torture, far_count, 1,
5076 "unexpected response len");
5077 torture_assert_u64_equal(torture, far_rsp[0].file_off, 1,
5078 "unexpected allocation");
5079 torture_assert_u64_equal(torture, far_rsp[0].len,
5080 dealloc_chunk_len * 2 - 1,
5081 "unexpected far len");
5082
5083 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
5084 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
5085
5086 /* punch out second chunk */
5087 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
5088 dealloc_chunk_len, /* off */
5089 dealloc_chunk_len * 2);
5090 torture_assert_ntstatus_ok(torture, status, "zero_data");
5091
5092 /* sparse QAR with range one before hole */
5093 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5094 0, /* off */
5095 dealloc_chunk_len - 1, /* len */
5096 &far_rsp, &far_count);
5097 torture_assert_ntstatus_ok(torture, status,
5098 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5099 torture_assert_u64_equal(torture, far_count, 1,
5100 "unexpected response len");
5101 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
5102 "unexpected allocation");
5103 torture_assert_u64_equal(torture, far_rsp[0].len,
5104 dealloc_chunk_len - 1,
5105 "unexpected far len");
5106
5107 /* sparse QAR with range one after hole */
5108 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5109 0, /* off */
5110 dealloc_chunk_len + 1, /* len */
5111 &far_rsp, &far_count);
5112 torture_assert_ntstatus_ok(torture, status,
5113 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5114 torture_assert_u64_equal(torture, far_count, 1,
5115 "unexpected response len");
5116 torture_assert_u64_equal(torture, far_rsp[0].file_off, 0,
5117 "unexpected allocation");
5118 torture_assert_u64_equal(torture, far_rsp[0].len,
5119 dealloc_chunk_len,
5120 "unexpected far len");
5121
5122 /* sparse QAR with range one after hole from off=1 */
5123 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5124 1, /* off */
5125 dealloc_chunk_len, /* len */
5126 &far_rsp, &far_count);
5127 torture_assert_ntstatus_ok(torture, status,
5128 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5129 torture_assert_u64_equal(torture, far_count, 1,
5130 "unexpected response len");
5131 torture_assert_u64_equal(torture, far_rsp[0].file_off, 1,
5132 "unexpected allocation");
5133 torture_assert_u64_equal(torture, far_rsp[0].len,
5134 dealloc_chunk_len - 1,
5135 "unexpected far len");
5136
5137 /* sparse QAR with range one before EOF from off=chunk_len-1 */
5138 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5139 dealloc_chunk_len - 1, /* off */
5140 dealloc_chunk_len, /* len */
5141 &far_rsp, &far_count);
5142 torture_assert_ntstatus_ok(torture, status,
5143 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5144 torture_assert_u64_equal(torture, far_count, 1,
5145 "unexpected response len");
5146 torture_assert_u64_equal(torture, far_rsp[0].file_off,
5147 dealloc_chunk_len - 1,
5148 "unexpected allocation");
5149 torture_assert_u64_equal(torture, far_rsp[0].len,
5150 1, "unexpected far len");
5151
5152 /* sparse QAR with range one after EOF from off=chunk_len+1 */
5153 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5154 dealloc_chunk_len + 1, /* off */
5155 dealloc_chunk_len, /* len */
5156 &far_rsp, &far_count);
5157 torture_assert_ntstatus_ok(torture, status,
5158 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5159 torture_assert_u64_equal(torture, far_count, 0,
5160 "unexpected response len");
5161 smb2_util_close(tree, fh);
5162 talloc_free(tmp_ctx);
5163 return true;
5164 }
5165
5166 /* test QAR with multi-range responses */
5167 static bool test_ioctl_sparse_qar_multi(struct torture_context *torture,
5168 struct smb2_tree *tree)
5169 {
5170 struct smb2_handle fh;
5171 NTSTATUS status;
5172 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5173 bool ok;
5174 uint64_t dealloc_chunk_len = 64 * 1024; /* Windows 2012 */
5175 uint64_t this_off;
5176 int i;
5177 struct file_alloced_range_buf *far_rsp = NULL;
5178 uint64_t far_count = 0;
5179
5180 ok = test_setup_create_fill(torture, tree, tmp_ctx,
5181 FNAME, &fh, dealloc_chunk_len * 2,
5182 SEC_RIGHTS_FILE_ALL,
5183 FILE_ATTRIBUTE_NORMAL);
5184 torture_assert(torture, ok, "setup file");
5185
5186 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
5187 FILE_SUPPORTS_SPARSE_FILES, &ok);
5188 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
5189 if (!ok) {
5190 torture_skip(torture, "Sparse files not supported\n");
5191 smb2_util_close(tree, fh);
5192 }
5193
5194 status = test_ioctl_sparse_req(torture, tmp_ctx, tree, fh, true);
5195 torture_assert_ntstatus_ok(torture, status, "FSCTL_SET_SPARSE");
5196
5197 /* each loop, write out two chunks and punch the first out */
5198 for (i = 0; i < 10; i++) {
5199 this_off = i * dealloc_chunk_len * 2;
5200
5201 ok = write_pattern(torture, tree, tmp_ctx, fh,
5202 this_off, /* off */
5203 dealloc_chunk_len * 2, /* len */
5204 this_off); /* pattern offset */
5205 torture_assert(torture, ok, "write pattern");
5206
5207 status = test_ioctl_zdata_req(torture, tmp_ctx, tree, fh,
5208 this_off, /* off */
5209 this_off + dealloc_chunk_len);
5210 torture_assert_ntstatus_ok(torture, status, "zero_data");
5211 }
5212
5213 /* should now have one separate region for each iteration */
5214 status = test_ioctl_qar_req(torture, tmp_ctx, tree, fh,
5215 0,
5216 10 * dealloc_chunk_len * 2,
5217 &far_rsp, &far_count);
5218 torture_assert_ntstatus_ok(torture, status,
5219 "FSCTL_QUERY_ALLOCATED_RANGES req failed");
5220 if (far_count == 1) {
5221 torture_comment(torture, "this FS doesn't deallocate 64K"
5222 "zeroed ranges in sparse files\n");
5223 return true; /* FS specific, not a failure */
5224 }
5225 torture_assert_u64_equal(torture, far_count, 10,
5226 "unexpected response len");
5227 for (i = 0; i < 10; i++) {
5228 this_off = i * dealloc_chunk_len * 2;
5229
5230 torture_assert_u64_equal(torture, far_rsp[i].file_off,
5231 this_off + dealloc_chunk_len,
5232 "unexpected allocation");
5233 torture_assert_u64_equal(torture, far_rsp[i].len,
5234 dealloc_chunk_len,
5235 "unexpected far len");
5236 }
5237
5238 smb2_util_close(tree, fh);
5239 talloc_free(tmp_ctx);
5240 return true;
5241 }
5242
5243 static bool test_ioctl_sparse_qar_overflow(struct torture_context *torture,
5244 struct smb2_tree *tree)
5245 {
5246 struct smb2_handle fh;
5247 union smb_ioctl ioctl;
5248 struct file_alloced_range_buf far_buf;
5249 NTSTATUS status;
5250 enum ndr_err_code ndr_ret;
5251 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5252 bool ok;
5253
5254 ok = test_setup_create_fill(torture, tree, tmp_ctx,
5255 FNAME, &fh, 1024, SEC_RIGHTS_FILE_ALL,
5256 FILE_ATTRIBUTE_NORMAL);
5257 torture_assert(torture, ok, "setup file");
5258
5259 status = test_ioctl_fs_supported(torture, tree, tmp_ctx, &fh,
5260 FILE_SUPPORTS_SPARSE_FILES, &ok);
5261 torture_assert_ntstatus_ok(torture, status, "SMB2_GETINFO_FS");
5262 if (!ok) {
5263 smb2_util_close(tree, fh);
5264 torture_skip(torture, "Sparse files not supported\n");
5265 }
5266
5267 /* no allocated ranges, no space for range response, should pass */
5268 ZERO_STRUCT(ioctl);
5269 ioctl.smb2.level = RAW_IOCTL_SMB2;
5270 ioctl.smb2.in.file.handle = fh;
5271 ioctl.smb2.in.function = FSCTL_QUERY_ALLOCATED_RANGES;
5272 ioctl.smb2.in.max_response_size = 1024;
5273 ioctl.smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
5274
5275 /* off + length wraps around to 511 */
5276 far_buf.file_off = 512;
5277 far_buf.len = 0xffffffffffffffffLL;
5278 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
5279 &far_buf,
5280 (ndr_push_flags_fn_t)ndr_push_file_alloced_range_buf);
5281 torture_assert_ndr_success(torture, ndr_ret, "push far ndr buf");
5282
5283 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5284 torture_assert_ntstatus_equal(torture, status,
5285 NT_STATUS_INVALID_PARAMETER,
5286 "FSCTL_QUERY_ALLOCATED_RANGES overflow");
5287
5288 return true;
5289 }
5290
5291 static NTSTATUS test_ioctl_trim_supported(struct torture_context *torture,
5292 struct smb2_tree *tree,
5293 TALLOC_CTX *mem_ctx,
5294 struct smb2_handle *fh,
5295 bool *trim_support)
5296 {
5297 NTSTATUS status;
5298 union smb_fsinfo info;
5299
5300 ZERO_STRUCT(info);
5301 info.generic.level = RAW_QFS_SECTOR_SIZE_INFORMATION;
5302 info.generic.handle = *fh;
5303 status = smb2_getinfo_fs(tree, tree, &info);
5304 if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_INFO_CLASS)) {
5305 /*
5306 * Windows < Server 2012, 8 etc. don't support this info level
5307 * or the trim ioctl. Ignore the error and let the caller skip.
5308 */
5309 *trim_support = false;
5310 return NT_STATUS_OK;
5311 } else if (!NT_STATUS_IS_OK(status)) {
5312 return status;
5313 }
5314
5315 torture_comment(torture, "sector size info: lb/s=%u, pb/sA=%u, "
5316 "pb/sP=%u, fse/sA=%u, flags=0x%x, bosa=%u, bopa=%u\n",
5317 (unsigned)info.sector_size_info.out.logical_bytes_per_sector,
5318 (unsigned)info.sector_size_info.out.phys_bytes_per_sector_atomic,
5319 (unsigned)info.sector_size_info.out.phys_bytes_per_sector_perf,
5320 (unsigned)info.sector_size_info.out.fs_effective_phys_bytes_per_sector_atomic,
5321 (unsigned)info.sector_size_info.out.flags,
5322 (unsigned)info.sector_size_info.out.byte_off_sector_align,
5323 (unsigned)info.sector_size_info.out.byte_off_partition_align);
5324
5325 if (info.sector_size_info.out.flags & QFS_SSINFO_FLAGS_TRIM_ENABLED) {
5326 *trim_support = true;
5327 } else {
5328 *trim_support = false;
5329 }
5330 return NT_STATUS_OK;
5331 }
5332
5333 static bool test_setup_trim(struct torture_context *torture,
5334 struct smb2_tree *tree,
5335 TALLOC_CTX *mem_ctx,
5336 uint32_t num_ranges,
5337 struct smb2_handle *fh,
5338 uint64_t file_size,
5339 uint32_t desired_access,
5340 struct fsctl_file_level_trim_req *trim_req,
5341 union smb_ioctl *ioctl)
5342 {
5343 bool ok;
5344
5345 ok = test_setup_create_fill(torture, tree, mem_ctx, FNAME,
5346 fh, file_size, desired_access,
5347 FILE_ATTRIBUTE_NORMAL);
5348 torture_assert(torture, ok, "src file create fill");
5349
5350 ZERO_STRUCTPN(ioctl);
5351 ioctl->smb2.level = RAW_IOCTL_SMB2;
5352 ioctl->smb2.in.file.handle = *fh;
5353 ioctl->smb2.in.function = FSCTL_FILE_LEVEL_TRIM;
5354 ioctl->smb2.in.max_response_size
5355 = sizeof(struct fsctl_file_level_trim_rsp);
5356 ioctl->smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
5357
5358 ZERO_STRUCTPN(trim_req);
5359 /* leave key as zero for now. TODO test locking with differing keys */
5360 trim_req->num_ranges = num_ranges;
5361 trim_req->ranges = talloc_zero_array(mem_ctx,
5362 struct file_level_trim_range,
5363 num_ranges);
5364 torture_assert(torture, (trim_req->ranges != NULL), "no memory for ranges");
5365
5366 return true;
5367 }
5368
5369 static bool test_ioctl_trim_simple(struct torture_context *torture,
5370 struct smb2_tree *tree)
5371 {
5372 struct smb2_handle fh;
5373 NTSTATUS status;
5374 union smb_ioctl ioctl;
5375 bool trim_supported;
5376 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5377 struct fsctl_file_level_trim_req trim_req;
5378 struct fsctl_file_level_trim_rsp trim_rsp;
5379 uint64_t trim_chunk_len = 64 * 1024; /* trim 64K chunks */
5380 enum ndr_err_code ndr_ret;
5381 bool ok;
5382
5383 ok = test_setup_trim(torture, tree, tmp_ctx,
5384 1, /* 1 range */
5385 &fh, 2 * trim_chunk_len, /* fill 128K file */
5386 SEC_RIGHTS_FILE_ALL,
5387 &trim_req,
5388 &ioctl);
5389 if (!ok) {
5390 torture_fail(torture, "setup trim error");
5391 }
5392
5393 status = test_ioctl_trim_supported(torture, tree, tmp_ctx, &fh,
5394 &trim_supported);
5395 torture_assert_ntstatus_ok(torture, status, "fsinfo");
5396 if (!trim_supported) {
5397 smb2_util_close(tree, fh);
5398 talloc_free(tmp_ctx);
5399 torture_skip(torture, "trim not supported\n");
5400 }
5401
5402 /* trim first chunk, leave second */
5403 trim_req.ranges[0].off = 0;
5404 trim_req.ranges[0].len = trim_chunk_len;
5405
5406 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx, &trim_req,
5407 (ndr_push_flags_fn_t)ndr_push_fsctl_file_level_trim_req);
5408 torture_assert_ndr_success(torture, ndr_ret,
5409 "ndr_push_fsctl_file_level_trim_req");
5410
5411 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5412 torture_assert_ntstatus_ok(torture, status, "FILE_LEVEL_TRIM_RANGE");
5413
5414 ndr_ret = ndr_pull_struct_blob(&ioctl.smb2.out.out, tmp_ctx,
5415 &trim_rsp,
5416 (ndr_pull_flags_fn_t)ndr_pull_fsctl_file_level_trim_rsp);
5417 torture_assert_ndr_success(torture, ndr_ret,
5418 "ndr_pull_fsctl_file_level_trim_rsp");
5419
5420 torture_assert_int_equal(torture, trim_rsp.num_ranges_processed, 1, "");
5421
5422 /* second half of the file should remain consitent */
5423 ok = check_pattern(torture, tree, tmp_ctx, fh, trim_chunk_len,
5424 trim_chunk_len, trim_chunk_len);
5425 torture_assert(torture, ok, "non-trimmed range inconsistent");
5426
5427 return true;
5428 }
5429
5430 static bool test_setup_dup_extents(struct torture_context *tctx,
5431 struct smb2_tree *tree,
5432 TALLOC_CTX *mem_ctx,
5433 struct smb2_handle *src_h,
5434 uint64_t src_size,
5435 uint32_t src_desired_access,
5436 struct smb2_handle *dest_h,
5437 uint64_t dest_size,
5438 uint32_t dest_desired_access,
5439 struct fsctl_dup_extents_to_file *dup_ext_buf,
5440 union smb_ioctl *ioctl)
5441 {
5442 bool ok;
5443
5444 ok = test_setup_create_fill(tctx, tree, mem_ctx, FNAME,
5445 src_h, src_size, src_desired_access,
5446 FILE_ATTRIBUTE_NORMAL);
5447 torture_assert(tctx, ok, "src file create fill");
5448
5449 ok = test_setup_create_fill(tctx, tree, mem_ctx, FNAME2,
5450 dest_h, dest_size, dest_desired_access,
5451 FILE_ATTRIBUTE_NORMAL);
5452 torture_assert(tctx, ok, "dest file create fill");
5453
5454 ZERO_STRUCTPN(ioctl);
5455 ioctl->smb2.level = RAW_IOCTL_SMB2;
5456 ioctl->smb2.in.file.handle = *dest_h;
5457 ioctl->smb2.in.function = FSCTL_DUP_EXTENTS_TO_FILE;
5458 ioctl->smb2.in.max_response_size = 0;
5459 ioctl->smb2.in.flags = SMB2_IOCTL_FLAG_IS_FSCTL;
5460
5461 ZERO_STRUCTPN(dup_ext_buf);
5462 smb2_push_handle(dup_ext_buf->source_fid, src_h);
5463
5464 return true;
5465 }
5466
5467 static bool test_ioctl_dup_extents_simple(struct torture_context *tctx,
5468 struct smb2_tree *tree)
5469 {
5470 struct smb2_handle src_h;
5471 struct smb2_handle dest_h;
5472 NTSTATUS status;
5473 union smb_ioctl ioctl;
5474 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5475 struct fsctl_dup_extents_to_file dup_ext_buf;
5476 enum ndr_err_code ndr_ret;
5477 union smb_fileinfo io;
5478 union smb_setfileinfo sinfo;
5479 bool ok;
5480
5481 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
5482 &src_h, 4096, /* fill 4096 byte src file */
5483 SEC_RIGHTS_FILE_ALL,
5484 &dest_h, 0, /* 0 byte dest file */
5485 SEC_RIGHTS_FILE_ALL,
5486 &dup_ext_buf,
5487 &ioctl);
5488 if (!ok) {
5489 torture_fail(tctx, "setup dup extents error");
5490 }
5491
5492 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
5493 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
5494 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
5495 if (!ok) {
5496 smb2_util_close(tree, src_h);
5497 smb2_util_close(tree, dest_h);
5498 talloc_free(tmp_ctx);
5499 torture_skip(tctx, "block refcounting not supported\n");
5500 }
5501
5502 /* extend dest to match src len */
5503 ZERO_STRUCT(sinfo);
5504 sinfo.end_of_file_info.level =
5505 RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5506 sinfo.end_of_file_info.in.file.handle = dest_h;
5507 sinfo.end_of_file_info.in.size = 4096;
5508 status = smb2_setinfo_file(tree, &sinfo);
5509 torture_assert_ntstatus_ok(tctx, status, "smb2_setinfo_file");
5510
5511 /* copy all src file data */
5512 dup_ext_buf.source_off = 0;
5513 dup_ext_buf.target_off = 0;
5514 dup_ext_buf.byte_count = 4096;
5515
5516 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
5517 &dup_ext_buf,
5518 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
5519 torture_assert_ndr_success(tctx, ndr_ret,
5520 "ndr_push_fsctl_dup_extents_to_file");
5521
5522 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5523 torture_assert_ntstatus_ok(tctx, status,
5524 "FSCTL_DUP_EXTENTS_TO_FILE");
5525
5526 /* the file size shouldn't have been changed by this operation! */
5527 ZERO_STRUCT(io);
5528 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5529 io.generic.in.file.handle = dest_h;
5530 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5531 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5532 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5533 4096, "size after IO");
5534
5535 smb2_util_close(tree, src_h);
5536 smb2_util_close(tree, dest_h);
5537
5538 /* reopen for pattern check */
5539 ok = test_setup_open(tctx, tree, tmp_ctx, FNAME, &src_h,
5540 SEC_RIGHTS_FILE_ALL, FILE_ATTRIBUTE_NORMAL);
5541 torture_assert_ntstatus_ok(tctx, status, "src open after dup");
5542 ok = test_setup_open(tctx, tree, tmp_ctx, FNAME2, &dest_h,
5543 SEC_RIGHTS_FILE_ALL, FILE_ATTRIBUTE_NORMAL);
5544 torture_assert_ntstatus_ok(tctx, status, "dest open after dup");
5545
5546 ok = check_pattern(tctx, tree, tmp_ctx, src_h, 0, 4096, 0);
5547 if (!ok) {
5548 torture_fail(tctx, "inconsistent src file data");
5549 }
5550
5551 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 4096, 0);
5552 if (!ok) {
5553 torture_fail(tctx, "inconsistent dest file data");
5554 }
5555
5556 smb2_util_close(tree, src_h);
5557 smb2_util_close(tree, dest_h);
5558 talloc_free(tmp_ctx);
5559 return true;
5560 }
5561
5562 static bool test_ioctl_dup_extents_len_beyond_dest(struct torture_context *tctx,
5563 struct smb2_tree *tree)
5564 {
5565 struct smb2_handle src_h;
5566 struct smb2_handle dest_h;
5567 NTSTATUS status;
5568 union smb_ioctl ioctl;
5569 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5570 struct fsctl_dup_extents_to_file dup_ext_buf;
5571 enum ndr_err_code ndr_ret;
5572 union smb_fileinfo io;
5573 union smb_setfileinfo sinfo;
5574 bool ok;
5575
5576 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
5577 &src_h, 32768, /* fill 32768 byte src file */
5578 SEC_RIGHTS_FILE_ALL,
5579 &dest_h, 0, /* 0 byte dest file */
5580 SEC_RIGHTS_FILE_ALL,
5581 &dup_ext_buf,
5582 &ioctl);
5583 if (!ok) {
5584 torture_fail(tctx, "setup dup extents error");
5585 }
5586
5587 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
5588 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
5589 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
5590 if (!ok) {
5591 smb2_util_close(tree, src_h);
5592 smb2_util_close(tree, dest_h);
5593 talloc_free(tmp_ctx);
5594 torture_skip(tctx, "block refcounting not supported\n");
5595 }
5596
5597 ZERO_STRUCT(io);
5598 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5599 io.generic.in.file.handle = dest_h;
5600 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5601 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5602 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5603 0, "size after IO");
5604
5605 /* copy all src file data */
5606 dup_ext_buf.source_off = 0;
5607 dup_ext_buf.target_off = 0;
5608 dup_ext_buf.byte_count = 32768;
5609
5610 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
5611 &dup_ext_buf,
5612 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
5613 torture_assert_ndr_success(tctx, ndr_ret,
5614 "ndr_push_fsctl_dup_extents_to_file");
5615
5616 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5617 #if 0
5618 /*
5619 * 2.3.8 FSCTL_DUPLICATE_EXTENTS_TO_FILE Reply - this should fail, but
5620 * passes against WS2016 RTM!
5621 */
5622 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NOT_SUPPORTED,
5623 "FSCTL_DUP_EXTENTS_TO_FILE");
5624 #endif
5625
5626 /* the file sizes shouldn't have been changed */
5627 ZERO_STRUCT(io);
5628 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5629 io.generic.in.file.handle = src_h;
5630 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5631 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5632 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5633 32768, "size after IO");
5634
5635 ZERO_STRUCT(io);
5636 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5637 io.generic.in.file.handle = dest_h;
5638 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5639 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5640 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5641 0, "size after IO");
5642
5643 /* extend dest */
5644 ZERO_STRUCT(sinfo);
5645 sinfo.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5646 sinfo.end_of_file_info.in.file.handle = dest_h;
5647 sinfo.end_of_file_info.in.size = 32768;
5648 status = smb2_setinfo_file(tree, &sinfo);
5649 torture_assert_ntstatus_ok(tctx, status, "smb2_setinfo_file");
5650
5651 ok = check_zero(tctx, tree, tmp_ctx, dest_h, 0, 32768);
5652 if (!ok) {
5653 torture_fail(tctx, "inconsistent file data");
5654 }
5655
5656 /* reissue ioctl, now with enough space */
5657 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5658 torture_assert_ntstatus_ok(tctx, status,
5659 "FSCTL_DUP_EXTENTS_TO_FILE");
5660
5661 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 32768, 0);
5662 if (!ok) {
5663 torture_fail(tctx, "inconsistent file data");
5664 }
5665
5666 smb2_util_close(tree, src_h);
5667 smb2_util_close(tree, dest_h);
5668 talloc_free(tmp_ctx);
5669 return true;
5670 }
5671
5672 static bool test_ioctl_dup_extents_len_beyond_src(struct torture_context *tctx,
5673 struct smb2_tree *tree)
5674 {
5675 struct smb2_handle src_h;
5676 struct smb2_handle dest_h;
5677 NTSTATUS status;
5678 union smb_ioctl ioctl;
5679 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5680 struct fsctl_dup_extents_to_file dup_ext_buf;
5681 enum ndr_err_code ndr_ret;
5682 union smb_fileinfo io;
5683 bool ok;
5684
5685 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
5686 &src_h, 32768, /* fill 32768 byte src file */
5687 SEC_RIGHTS_FILE_ALL,
5688 &dest_h, 0, /* 0 byte dest file */
5689 SEC_RIGHTS_FILE_ALL,
5690 &dup_ext_buf,
5691 &ioctl);
5692 if (!ok) {
5693 torture_fail(tctx, "setup dup extents error");
5694 }
5695
5696 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
5697 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
5698 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
5699 if (!ok) {
5700 smb2_util_close(tree, src_h);
5701 smb2_util_close(tree, dest_h);
5702 talloc_free(tmp_ctx);
5703 torture_skip(tctx, "block refcounting not supported\n");
5704 }
5705
5706 ZERO_STRUCT(io);
5707 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5708 io.generic.in.file.handle = dest_h;
5709 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5710 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5711 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5712 0, "size after IO");
5713
5714 /* exceed src file len */
5715 dup_ext_buf.source_off = 0;
5716 dup_ext_buf.target_off = 0;
5717 dup_ext_buf.byte_count = 32768 * 2;
5718
5719 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
5720 &dup_ext_buf,
5721 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
5722 torture_assert_ndr_success(tctx, ndr_ret,
5723 "ndr_push_fsctl_dup_extents_to_file");
5724
5725 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5726 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NOT_SUPPORTED,
5727 "FSCTL_DUP_EXTENTS_TO_FILE");
5728
5729 /* the file sizes shouldn't have been changed */
5730 ZERO_STRUCT(io);
5731 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5732 io.generic.in.file.handle = src_h;
5733 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5734 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5735 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5736 32768, "size after IO");
5737
5738 ZERO_STRUCT(io);
5739 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5740 io.generic.in.file.handle = dest_h;
5741 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5742 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5743 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5744 0, "size after IO");
5745
5746 smb2_util_close(tree, src_h);
5747 smb2_util_close(tree, dest_h);
5748 talloc_free(tmp_ctx);
5749 return true;
5750 }
5751
5752 static bool test_ioctl_dup_extents_len_zero(struct torture_context *tctx,
5753 struct smb2_tree *tree)
5754 {
5755 struct smb2_handle src_h;
5756 struct smb2_handle dest_h;
5757 NTSTATUS status;
5758 union smb_ioctl ioctl;
5759 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5760 struct fsctl_dup_extents_to_file dup_ext_buf;
5761 enum ndr_err_code ndr_ret;
5762 union smb_fileinfo io;
5763 bool ok;
5764
5765 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
5766 &src_h, 32768, /* fill 32768 byte src file */
5767 SEC_RIGHTS_FILE_ALL,
5768 &dest_h, 0, /* 0 byte dest file */
5769 SEC_RIGHTS_FILE_ALL,
5770 &dup_ext_buf,
5771 &ioctl);
5772 if (!ok) {
5773 torture_fail(tctx, "setup dup extents error");
5774 }
5775
5776 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
5777 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
5778 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
5779 if (!ok) {
5780 smb2_util_close(tree, src_h);
5781 smb2_util_close(tree, dest_h);
5782 talloc_free(tmp_ctx);
5783 torture_skip(tctx, "block refcounting not supported\n");
5784 }
5785
5786 ZERO_STRUCT(io);
5787 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5788 io.generic.in.file.handle = dest_h;
5789 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5790 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5791 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5792 0, "size after IO");
5793
5794 dup_ext_buf.source_off = 0;
5795 dup_ext_buf.target_off = 0;
5796 dup_ext_buf.byte_count = 0;
5797
5798 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
5799 &dup_ext_buf,
5800 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
5801 torture_assert_ndr_success(tctx, ndr_ret,
5802 "ndr_push_fsctl_dup_extents_to_file");
5803
5804 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5805 torture_assert_ntstatus_ok(tctx, status, "FSCTL_DUP_EXTENTS_TO_FILE");
5806
5807 /* the file sizes shouldn't have been changed */
5808 ZERO_STRUCT(io);
5809 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5810 io.generic.in.file.handle = src_h;
5811 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5812 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5813 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5814 32768, "size after IO");
5815
5816 ZERO_STRUCT(io);
5817 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
5818 io.generic.in.file.handle = dest_h;
5819 status = smb2_getinfo_file(tree, tmp_ctx, &io);
5820 torture_assert_ntstatus_ok(tctx, status, "getinfo");
5821 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
5822 0, "size after IO");
5823
5824 smb2_util_close(tree, src_h);
5825 smb2_util_close(tree, dest_h);
5826 talloc_free(tmp_ctx);
5827 return true;
5828 }
5829
5830 static bool test_ioctl_dup_extents_sparse_src(struct torture_context *tctx,
5831 struct smb2_tree *tree)
5832 {
5833 struct smb2_handle src_h;
5834 struct smb2_handle dest_h;
5835 NTSTATUS status;
5836 union smb_ioctl ioctl;
5837 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5838 struct fsctl_dup_extents_to_file dup_ext_buf;
5839 enum ndr_err_code ndr_ret;
5840 union smb_setfileinfo sinfo;
5841 bool ok;
5842
5843 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
5844 &src_h, 0, /* filled after sparse flag */
5845 SEC_RIGHTS_FILE_ALL,
5846 &dest_h, 0, /* 0 byte dest file */
5847 SEC_RIGHTS_FILE_ALL,
5848 &dup_ext_buf,
5849 &ioctl);
5850 if (!ok) {
5851 torture_fail(tctx, "setup dup extents error");
5852 }
5853
5854 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
5855 FILE_SUPPORTS_BLOCK_REFCOUNTING
5856 | FILE_SUPPORTS_SPARSE_FILES, &ok);
5857 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
5858 if (!ok) {
5859 smb2_util_close(tree, src_h);
5860 smb2_util_close(tree, dest_h);
5861 talloc_free(tmp_ctx);
5862 torture_skip(tctx,
5863 "block refcounting and sparse files not supported\n");
5864 }
5865
5866 /* set sparse flag on src */
5867 status = test_ioctl_sparse_req(tctx, tmp_ctx, tree, src_h, true);
5868 torture_assert_ntstatus_ok(tctx, status, "FSCTL_SET_SPARSE");
5869
5870 ok = write_pattern(tctx, tree, tmp_ctx, src_h, 0, 4096, 0);
5871 torture_assert(tctx, ok, "write pattern");
5872
5873 /* extend dest */
5874 ZERO_STRUCT(sinfo);
5875 sinfo.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5876 sinfo.end_of_file_info.in.file.handle = dest_h;
5877 sinfo.end_of_file_info.in.size = 4096;
5878 status = smb2_setinfo_file(tree, &sinfo);
5879 torture_assert_ntstatus_ok(tctx, status, "smb2_setinfo_file");
5880
5881 /* copy all src file data */
5882 dup_ext_buf.source_off = 0;
5883 dup_ext_buf.target_off = 0;
5884 dup_ext_buf.byte_count = 4096;
5885
5886 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
5887 &dup_ext_buf,
5888 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
5889 torture_assert_ndr_success(tctx, ndr_ret,
5890 "ndr_push_fsctl_dup_extents_to_file");
5891
5892 /*
5893 * src is sparse, but spec says: 2.3.8 FSCTL_DUPLICATE_EXTENTS_TO_FILE
5894 * Reply... STATUS_NOT_SUPPORTED: Target file is sparse, while source
5895 * is a non-sparse file.
5896 */
5897 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5898 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NOT_SUPPORTED,
5899 "FSCTL_DUP_EXTENTS_TO_FILE");
5900
5901 smb2_util_close(tree, src_h);
5902 smb2_util_close(tree, dest_h);
5903 talloc_free(tmp_ctx);
5904 return true;
5905 }
5906
5907 static bool test_ioctl_dup_extents_sparse_dest(struct torture_context *tctx,
5908 struct smb2_tree *tree)
5909 {
5910 struct smb2_handle src_h;
5911 struct smb2_handle dest_h;
5912 NTSTATUS status;
5913 union smb_ioctl ioctl;
5914 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5915 struct fsctl_dup_extents_to_file dup_ext_buf;
5916 enum ndr_err_code ndr_ret;
5917 union smb_setfileinfo sinfo;
5918 bool ok;
5919
5920 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
5921 &src_h, 4096, /* fill 4096 byte src file */
5922 SEC_RIGHTS_FILE_ALL,
5923 &dest_h, 0, /* 0 byte dest file */
5924 SEC_RIGHTS_FILE_ALL,
5925 &dup_ext_buf,
5926 &ioctl);
5927 if (!ok) {
5928 torture_fail(tctx, "setup dup extents error");
5929 }
5930
5931 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
5932 FILE_SUPPORTS_BLOCK_REFCOUNTING
5933 | FILE_SUPPORTS_SPARSE_FILES, &ok);
5934 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
5935 if (!ok) {
5936 smb2_util_close(tree, src_h);
5937 smb2_util_close(tree, dest_h);
5938 talloc_free(tmp_ctx);
5939 torture_skip(tctx,
5940 "block refcounting and sparse files not supported\n");
5941 }
5942
5943 /* set sparse flag on dest */
5944 status = test_ioctl_sparse_req(tctx, tmp_ctx, tree, dest_h, true);
5945 torture_assert_ntstatus_ok(tctx, status, "FSCTL_SET_SPARSE");
5946
5947 /* extend dest */
5948 ZERO_STRUCT(sinfo);
5949 sinfo.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
5950 sinfo.end_of_file_info.in.file.handle = dest_h;
5951 sinfo.end_of_file_info.in.size = dup_ext_buf.byte_count;
5952 status = smb2_setinfo_file(tree, &sinfo);
5953 torture_assert_ntstatus_ok(tctx, status, "smb2_setinfo_file");
5954
5955 /* copy all src file data */
5956 dup_ext_buf.source_off = 0;
5957 dup_ext_buf.target_off = 0;
5958 dup_ext_buf.byte_count = 4096;
5959
5960 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
5961 &dup_ext_buf,
5962 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
5963 torture_assert_ndr_success(tctx, ndr_ret,
5964 "ndr_push_fsctl_dup_extents_to_file");
5965
5966 /*
5967 * dest is sparse, but spec says: 2.3.8 FSCTL_DUPLICATE_EXTENTS_TO_FILE
5968 * Reply... STATUS_NOT_SUPPORTED: Target file is sparse, while source
5969 * is a non-sparse file.
5970 */
5971 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
5972 torture_assert_ntstatus_ok(tctx, status, "FSCTL_DUP_EXTENTS_TO_FILE");
5973
5974 smb2_util_close(tree, src_h);
5975 smb2_util_close(tree, dest_h);
5976 talloc_free(tmp_ctx);
5977 return true;
5978 }
5979
5980 static bool test_ioctl_dup_extents_sparse_both(struct torture_context *tctx,
5981 struct smb2_tree *tree)
5982 {
5983 struct smb2_handle src_h;
5984 struct smb2_handle dest_h;
5985 NTSTATUS status;
5986 union smb_ioctl ioctl;
5987 TALLOC_CTX *tmp_ctx = talloc_new(tree);
5988 struct fsctl_dup_extents_to_file dup_ext_buf;
5989 enum ndr_err_code ndr_ret;
5990 union smb_setfileinfo sinfo;
5991 bool ok;
5992
5993 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
5994 &src_h, 0, /* fill 4096 byte src file */
5995 SEC_RIGHTS_FILE_ALL,
5996 &dest_h, 0, /* 0 byte dest file */
5997 SEC_RIGHTS_FILE_ALL,
5998 &dup_ext_buf,
5999 &ioctl);
6000 if (!ok) {
6001 torture_fail(tctx, "setup dup extents error");
6002 }
6003
6004 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
6005 FILE_SUPPORTS_BLOCK_REFCOUNTING
6006 | FILE_SUPPORTS_SPARSE_FILES, &ok);
6007 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
6008 if (!ok) {
6009 smb2_util_close(tree, src_h);
6010 smb2_util_close(tree, dest_h);
6011 talloc_free(tmp_ctx);
6012 torture_skip(tctx,
6013 "block refcounting and sparse files not supported\n");
6014 }
6015
6016 /* set sparse flag on src and dest */
6017 status = test_ioctl_sparse_req(tctx, tmp_ctx, tree, src_h, true);
6018 torture_assert_ntstatus_ok(tctx, status, "FSCTL_SET_SPARSE");
6019 status = test_ioctl_sparse_req(tctx, tmp_ctx, tree, dest_h, true);
6020 torture_assert_ntstatus_ok(tctx, status, "FSCTL_SET_SPARSE");
6021
6022 ok = write_pattern(tctx, tree, tmp_ctx, src_h, 0, 4096, 0);
6023 torture_assert(tctx, ok, "write pattern");
6024
6025 /* extend dest */
6026 ZERO_STRUCT(sinfo);
6027 sinfo.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
6028 sinfo.end_of_file_info.in.file.handle = dest_h;
6029 sinfo.end_of_file_info.in.size = 4096;
6030 status = smb2_setinfo_file(tree, &sinfo);
6031 torture_assert_ntstatus_ok(tctx, status, "smb2_setinfo_file");
6032
6033 /* copy all src file data */
6034 dup_ext_buf.source_off = 0;
6035 dup_ext_buf.target_off = 0;
6036 dup_ext_buf.byte_count = 4096;
6037
6038 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6039 &dup_ext_buf,
6040 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6041 torture_assert_ndr_success(tctx, ndr_ret,
6042 "ndr_push_fsctl_dup_extents_to_file");
6043
6044 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6045 torture_assert_ntstatus_ok(tctx, status, "FSCTL_DUP_EXTENTS_TO_FILE");
6046
6047 smb2_util_close(tree, src_h);
6048 smb2_util_close(tree, dest_h);
6049
6050 /* reopen for pattern check */
6051 ok = test_setup_open(tctx, tree, tmp_ctx, FNAME2, &dest_h,
6052 SEC_RIGHTS_FILE_ALL, FILE_ATTRIBUTE_NORMAL);
6053 torture_assert_ntstatus_ok(tctx, status, "dest open ater dup");
6054
6055 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 4096, 0);
6056 if (!ok) {
6057 torture_fail(tctx, "inconsistent file data");
6058 }
6059
6060 smb2_util_close(tree, dest_h);
6061 talloc_free(tmp_ctx);
6062 return true;
6063 }
6064
6065 static bool test_ioctl_dup_extents_src_is_dest(struct torture_context *tctx,
6066 struct smb2_tree *tree)
6067 {
6068 struct smb2_handle src_h;
6069 struct smb2_handle dest_h;
6070 NTSTATUS status;
6071 union smb_ioctl ioctl;
6072 TALLOC_CTX *tmp_ctx = talloc_new(tree);
6073 struct fsctl_dup_extents_to_file dup_ext_buf;
6074 enum ndr_err_code ndr_ret;
6075 union smb_fileinfo io;
6076 bool ok;
6077
6078 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
6079 &src_h, 32768, /* fill 32768 byte src file */
6080 SEC_RIGHTS_FILE_ALL,
6081 &dest_h, 0,
6082 SEC_RIGHTS_FILE_ALL,
6083 &dup_ext_buf,
6084 &ioctl);
6085 if (!ok) {
6086 torture_fail(tctx, "setup dup extents error");
6087 }
6088 /* dest_h not needed for this test */
6089 smb2_util_close(tree, dest_h);
6090
6091 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
6092 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
6093 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
6094 if (!ok) {
6095 smb2_util_close(tree, src_h);
6096 talloc_free(tmp_ctx);
6097 torture_skip(tctx, "block refcounting not supported\n");
6098 }
6099
6100 /* src and dest are the same file handle */
6101 ioctl.smb2.in.file.handle = src_h;
6102
6103 /* no overlap between src and tgt */
6104 dup_ext_buf.source_off = 0;
6105 dup_ext_buf.target_off = 16384;
6106 dup_ext_buf.byte_count = 16384;
6107
6108 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6109 &dup_ext_buf,
6110 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6111 torture_assert_ndr_success(tctx, ndr_ret,
6112 "ndr_push_fsctl_dup_extents_to_file");
6113
6114 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6115 torture_assert_ntstatus_ok(tctx, status, "FSCTL_DUP_EXTENTS_TO_FILE");
6116
6117 /* the file size shouldn't have been changed */
6118 ZERO_STRUCT(io);
6119 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
6120 io.generic.in.file.handle = src_h;
6121 status = smb2_getinfo_file(tree, tmp_ctx, &io);
6122 torture_assert_ntstatus_ok(tctx, status, "getinfo");
6123 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
6124 32768, "size after IO");
6125
6126 ok = check_pattern(tctx, tree, tmp_ctx, src_h, 0, 16384, 0);
6127 if (!ok) {
6128 torture_fail(tctx, "inconsistent file data");
6129 }
6130 ok = check_pattern(tctx, tree, tmp_ctx, src_h, 16384, 16384, 0);
6131 if (!ok) {
6132 torture_fail(tctx, "inconsistent file data");
6133 }
6134
6135 smb2_util_close(tree, src_h);
6136 talloc_free(tmp_ctx);
6137 return true;
6138 }
6139
6140 /*
6141 * unlike copy-chunk, dup extents doesn't support overlapping ranges between
6142 * source and target. This makes it a *lot* cleaner to implement on the server.
6143 */
6144 static bool
6145 test_ioctl_dup_extents_src_is_dest_overlap(struct torture_context *tctx,
6146 struct smb2_tree *tree)
6147 {
6148 struct smb2_handle src_h;
6149 struct smb2_handle dest_h;
6150 NTSTATUS status;
6151 union smb_ioctl ioctl;
6152 TALLOC_CTX *tmp_ctx = talloc_new(tree);
6153 struct fsctl_dup_extents_to_file dup_ext_buf;
6154 enum ndr_err_code ndr_ret;
6155 union smb_fileinfo io;
6156 bool ok;
6157
6158 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
6159 &src_h, 32768, /* fill 32768 byte src file */
6160 SEC_RIGHTS_FILE_ALL,
6161 &dest_h, 0,
6162 SEC_RIGHTS_FILE_ALL,
6163 &dup_ext_buf,
6164 &ioctl);
6165 if (!ok) {
6166 torture_fail(tctx, "setup dup extents error");
6167 }
6168 /* dest_h not needed for this test */
6169 smb2_util_close(tree, dest_h);
6170
6171 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
6172 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
6173 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
6174 if (!ok) {
6175 smb2_util_close(tree, src_h);
6176 talloc_free(tmp_ctx);
6177 torture_skip(tctx, "block refcounting not supported\n");
6178 }
6179
6180 /* src and dest are the same file handle */
6181 ioctl.smb2.in.file.handle = src_h;
6182
6183 /* 8K overlap between src and tgt */
6184 dup_ext_buf.source_off = 0;
6185 dup_ext_buf.target_off = 8192;
6186 dup_ext_buf.byte_count = 16384;
6187
6188 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6189 &dup_ext_buf,
6190 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6191 torture_assert_ndr_success(tctx, ndr_ret,
6192 "ndr_push_fsctl_dup_extents_to_file");
6193
6194 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6195 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_NOT_SUPPORTED,
6196 "FSCTL_DUP_EXTENTS_TO_FILE");
6197
6198 /* the file size and data should match beforehand */
6199 ZERO_STRUCT(io);
6200 io.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
6201 io.generic.in.file.handle = src_h;
6202 status = smb2_getinfo_file(tree, tmp_ctx, &io);
6203 torture_assert_ntstatus_ok(tctx, status, "getinfo");
6204 torture_assert_int_equal(tctx, (int)io.all_info2.out.size,
6205 32768, "size after IO");
6206
6207 ok = check_pattern(tctx, tree, tmp_ctx, src_h, 0, 32768, 0);
6208 if (!ok) {
6209 torture_fail(tctx, "inconsistent file data");
6210 }
6211
6212 smb2_util_close(tree, src_h);
6213 talloc_free(tmp_ctx);
6214 return true;
6215 }
6216
6217 /*
6218 * The compression tests won't run against Windows servers yet - ReFS doesn't
6219 * (yet) offer support for compression.
6220 */
6221 static bool test_ioctl_dup_extents_compressed_src(struct torture_context *tctx,
6222 struct smb2_tree *tree)
6223 {
6224 struct smb2_handle src_h;
6225 struct smb2_handle dest_h;
6226 NTSTATUS status;
6227 union smb_ioctl ioctl;
6228 TALLOC_CTX *tmp_ctx = talloc_new(tree);
6229 struct fsctl_dup_extents_to_file dup_ext_buf;
6230 enum ndr_err_code ndr_ret;
6231 union smb_setfileinfo sinfo;
6232 bool ok;
6233
6234 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
6235 &src_h, 0, /* filled after compressed flag */
6236 SEC_RIGHTS_FILE_ALL,
6237 &dest_h, 0,
6238 SEC_RIGHTS_FILE_ALL,
6239 &dup_ext_buf,
6240 &ioctl);
6241 if (!ok) {
6242 torture_fail(tctx, "setup dup extents error");
6243 }
6244
6245 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
6246 FILE_SUPPORTS_BLOCK_REFCOUNTING
6247 | FILE_FILE_COMPRESSION, &ok);
6248 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
6249 if (!ok) {
6250 smb2_util_close(tree, src_h);
6251 smb2_util_close(tree, dest_h);
6252 talloc_free(tmp_ctx);
6253 torture_skip(tctx,
6254 "block refcounting and compressed files not supported\n");
6255 }
6256
6257 /* set compressed flag on src */
6258 status = test_ioctl_compress_set(tctx, tmp_ctx, tree, src_h,
6259 COMPRESSION_FORMAT_DEFAULT);
6260 torture_assert_ntstatus_ok(tctx, status, "FSCTL_SET_COMPRESSION");
6261
6262 ok = write_pattern(tctx, tree, tmp_ctx, src_h, 0, 4096, 0);
6263 torture_assert(tctx, ok, "write pattern");
6264
6265 /* extend dest */
6266 ZERO_STRUCT(sinfo);
6267 sinfo.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
6268 sinfo.end_of_file_info.in.file.handle = dest_h;
6269 sinfo.end_of_file_info.in.size = 4096;
6270 status = smb2_setinfo_file(tree, &sinfo);
6271 torture_assert_ntstatus_ok(tctx, status, "smb2_setinfo_file");
6272
6273 /* copy all src file data */
6274 dup_ext_buf.source_off = 0;
6275 dup_ext_buf.target_off = 0;
6276 dup_ext_buf.byte_count = 4096;
6277
6278 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6279 &dup_ext_buf,
6280 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6281 torture_assert_ndr_success(tctx, ndr_ret,
6282 "ndr_push_fsctl_dup_extents_to_file");
6283
6284 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6285 torture_assert_ntstatus_ok(tctx, status,
6286 "FSCTL_DUP_EXTENTS_TO_FILE");
6287
6288 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 4096, 0);
6289 if (!ok) {
6290 torture_fail(tctx, "inconsistent file data");
6291 }
6292
6293 smb2_util_close(tree, src_h);
6294 smb2_util_close(tree, dest_h);
6295 talloc_free(tmp_ctx);
6296 return true;
6297 }
6298
6299 static bool test_ioctl_dup_extents_compressed_dest(struct torture_context *tctx,
6300 struct smb2_tree *tree)
6301 {
6302 struct smb2_handle src_h;
6303 struct smb2_handle dest_h;
6304 NTSTATUS status;
6305 union smb_ioctl ioctl;
6306 TALLOC_CTX *tmp_ctx = talloc_new(tree);
6307 struct fsctl_dup_extents_to_file dup_ext_buf;
6308 enum ndr_err_code ndr_ret;
6309 union smb_setfileinfo sinfo;
6310 bool ok;
6311
6312 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
6313 &src_h, 4096,
6314 SEC_RIGHTS_FILE_ALL,
6315 &dest_h, 0,
6316 SEC_RIGHTS_FILE_ALL,
6317 &dup_ext_buf,
6318 &ioctl);
6319 if (!ok) {
6320 torture_fail(tctx, "setup dup extents error");
6321 }
6322
6323 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
6324 FILE_SUPPORTS_BLOCK_REFCOUNTING
6325 | FILE_FILE_COMPRESSION, &ok);
6326 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
6327 if (!ok) {
6328 smb2_util_close(tree, src_h);
6329 smb2_util_close(tree, dest_h);
6330 talloc_free(tmp_ctx);
6331 torture_skip(tctx,
6332 "block refcounting and compressed files not supported\n");
6333 }
6334
6335 /* set compressed flag on dest */
6336 status = test_ioctl_compress_set(tctx, tmp_ctx, tree, dest_h,
6337 COMPRESSION_FORMAT_DEFAULT);
6338 torture_assert_ntstatus_ok(tctx, status, "FSCTL_SET_COMPRESSION");
6339
6340 /* extend dest */
6341 ZERO_STRUCT(sinfo);
6342 sinfo.end_of_file_info.level = RAW_SFILEINFO_END_OF_FILE_INFORMATION;
6343 sinfo.end_of_file_info.in.file.handle = dest_h;
6344 sinfo.end_of_file_info.in.size = 4096;
6345 status = smb2_setinfo_file(tree, &sinfo);
6346 torture_assert_ntstatus_ok(tctx, status, "smb2_setinfo_file");
6347
6348 /* copy all src file data */
6349 dup_ext_buf.source_off = 0;
6350 dup_ext_buf.target_off = 0;
6351 dup_ext_buf.byte_count = 4096;
6352
6353 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6354 &dup_ext_buf,
6355 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6356 torture_assert_ndr_success(tctx, ndr_ret,
6357 "ndr_push_fsctl_dup_extents_to_file");
6358
6359 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6360 torture_assert_ntstatus_ok(tctx, status,
6361 "FSCTL_DUP_EXTENTS_TO_FILE");
6362
6363 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 4096, 0);
6364 if (!ok) {
6365 torture_fail(tctx, "inconsistent file data");
6366 }
6367
6368 smb2_util_close(tree, src_h);
6369 smb2_util_close(tree, dest_h);
6370 talloc_free(tmp_ctx);
6371 return true;
6372 }
6373
6374 static bool test_ioctl_dup_extents_bad_handle(struct torture_context *tctx,
6375 struct smb2_tree *tree)
6376 {
6377 struct smb2_handle src_h;
6378 struct smb2_handle dest_h;
6379 struct smb2_handle bogus_h;
6380 NTSTATUS status;
6381 union smb_ioctl ioctl;
6382 TALLOC_CTX *tmp_ctx = talloc_new(tree);
6383 struct fsctl_dup_extents_to_file dup_ext_buf;
6384 enum ndr_err_code ndr_ret;
6385 bool ok;
6386
6387 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
6388 &src_h, 32768, /* fill 32768 byte src file */
6389 SEC_RIGHTS_FILE_ALL,
6390 &dest_h, 32768,
6391 SEC_RIGHTS_FILE_ALL,
6392 &dup_ext_buf,
6393 &ioctl);
6394 if (!ok) {
6395 torture_fail(tctx, "setup dup extents error");
6396 }
6397
6398 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
6399 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
6400 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
6401 if (!ok) {
6402 smb2_util_close(tree, src_h);
6403 smb2_util_close(tree, dest_h);
6404 talloc_free(tmp_ctx);
6405 torture_skip(tctx, "block refcounting not supported\n");
6406 }
6407
6408 /* open and close a file, keeping the handle as now a "bogus" handle */
6409 ok = test_setup_create_fill(tctx, tree, tmp_ctx, "bogus_file",
6410 &bogus_h, 0, SEC_RIGHTS_FILE_ALL,
6411 FILE_ATTRIBUTE_NORMAL);
6412 torture_assert(tctx, ok, "bogus file create fill");
6413 smb2_util_close(tree, bogus_h);
6414
6415 /* bogus dest file handle */
6416 ioctl.smb2.in.file.handle = bogus_h;
6417
6418 dup_ext_buf.source_off = 0;
6419 dup_ext_buf.target_off = 0;
6420 dup_ext_buf.byte_count = 32768;
6421
6422 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6423 &dup_ext_buf,
6424 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6425 torture_assert_ndr_success(tctx, ndr_ret,
6426 "ndr_push_fsctl_dup_extents_to_file");
6427
6428 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6429 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_FILE_CLOSED,
6430 "FSCTL_DUP_EXTENTS_TO_FILE");
6431
6432 ok = check_pattern(tctx, tree, tmp_ctx, src_h, 0, 32768, 0);
6433 if (!ok) {
6434 torture_fail(tctx, "inconsistent file data");
6435 }
6436 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 32768, 0);
6437 if (!ok) {
6438 torture_fail(tctx, "inconsistent file data");
6439 }
6440
6441 /* reinstate dest, add bogus src file handle */
6442 ioctl.smb2.in.file.handle = dest_h;
6443 smb2_push_handle(dup_ext_buf.source_fid, &bogus_h);
6444
6445 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6446 &dup_ext_buf,
6447 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6448 torture_assert_ndr_success(tctx, ndr_ret,
6449 "ndr_push_fsctl_dup_extents_to_file");
6450
6451 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6452 torture_assert_ntstatus_equal(tctx, status, NT_STATUS_INVALID_HANDLE,
6453 "FSCTL_DUP_EXTENTS_TO_FILE");
6454
6455 ok = check_pattern(tctx, tree, tmp_ctx, src_h, 0, 32768, 0);
6456 if (!ok) {
6457 torture_fail(tctx, "inconsistent file data");
6458 }
6459 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 32768, 0);
6460 if (!ok) {
6461 torture_fail(tctx, "inconsistent file data");
6462 }
6463
6464 smb2_util_close(tree, src_h);
6465 smb2_util_close(tree, dest_h);
6466 talloc_free(tmp_ctx);
6467 return true;
6468 }
6469
6470 static bool test_ioctl_dup_extents_src_lck(struct torture_context *tctx,
6471 struct smb2_tree *tree)
6472 {
6473 struct smb2_handle src_h;
6474 struct smb2_handle src_h2;
6475 struct smb2_handle dest_h;
6476 NTSTATUS status;
6477 union smb_ioctl ioctl;
6478 TALLOC_CTX *tmp_ctx = talloc_new(tree);
6479 struct fsctl_dup_extents_to_file dup_ext_buf;
6480 enum ndr_err_code ndr_ret;
6481 bool ok;
6482 struct smb2_lock lck;
6483 struct smb2_lock_element el[1];
6484
6485 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
6486 &src_h, 32768, /* fill 32768 byte src file */
6487 SEC_RIGHTS_FILE_ALL,
6488 &dest_h, 0,
6489 SEC_RIGHTS_FILE_ALL,
6490 &dup_ext_buf,
6491 &ioctl);
6492 if (!ok) {
6493 torture_fail(tctx, "setup dup extents error");
6494 }
6495
6496 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
6497 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
6498 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
6499 if (!ok) {
6500 smb2_util_close(tree, src_h);
6501 smb2_util_close(tree, dest_h);
6502 talloc_free(tmp_ctx);
6503 torture_skip(tctx, "block refcounting not supported\n");
6504 }
6505
6506 /* dest pattern is different to src */
6507 ok = write_pattern(tctx, tree, tmp_ctx, dest_h, 0, 32768, 32768);
6508 torture_assert(tctx, ok, "write pattern");
6509
6510 /* setup dup ext req, values used for locking */
6511 dup_ext_buf.source_off = 0;
6512 dup_ext_buf.target_off = 0;
6513 dup_ext_buf.byte_count = 32768;
6514
6515 /* open and lock the dup extents src file */
6516 status = torture_smb2_testfile(tree, FNAME, &src_h2);
6517 torture_assert_ntstatus_ok(tctx, status, "2nd src open");
6518
6519 lck.in.lock_count = 0x0001;
6520 lck.in.lock_sequence = 0x00000000;
6521 lck.in.file.handle = src_h2;
6522 lck.in.locks = el;
6523 el[0].offset = dup_ext_buf.source_off;
6524 el[0].length = dup_ext_buf.byte_count;
6525 el[0].reserved = 0;
6526 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
6527
6528 status = smb2_lock(tree, &lck);
6529 torture_assert_ntstatus_ok(tctx, status, "lock");
6530
6531 status = smb2_util_write(tree, src_h,
6532 "conflicted", 0, sizeof("conflicted"));
6533 torture_assert_ntstatus_equal(tctx, status,
6534 NT_STATUS_FILE_LOCK_CONFLICT, "file write");
6535
6536 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6537 &dup_ext_buf,
6538 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6539 torture_assert_ndr_success(tctx, ndr_ret,
6540 "ndr_push_fsctl_dup_extents_to_file");
6541
6542 /*
6543 * In contrast to copy-chunk, dup extents doesn't cause a lock conflict
6544 * here.
6545 */
6546 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6547 torture_assert_ntstatus_ok(tctx, status, "FSCTL_DUP_EXTENTS_TO_FILE");
6548
6549 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 32768, 0);
6550 if (!ok) {
6551 torture_fail(tctx, "inconsistent file data");
6552 }
6553
6554 lck.in.lock_count = 0x0001;
6555 lck.in.lock_sequence = 0x00000001;
6556 lck.in.file.handle = src_h2;
6557 lck.in.locks = el;
6558 el[0].offset = dup_ext_buf.source_off;
6559 el[0].length = dup_ext_buf.byte_count;
6560 el[0].reserved = 0;
6561 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
6562 status = smb2_lock(tree, &lck);
6563 torture_assert_ntstatus_ok(tctx, status, "unlock");
6564
6565 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6566 torture_assert_ntstatus_ok(tctx, status,
6567 "FSCTL_DUP_EXTENTS_TO_FILE unlocked");
6568
6569 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 32768, 0);
6570 if (!ok) {
6571 torture_fail(tctx, "inconsistent file data");
6572 }
6573
6574 smb2_util_close(tree, src_h2);
6575 smb2_util_close(tree, src_h);
6576 smb2_util_close(tree, dest_h);
6577 talloc_free(tmp_ctx);
6578 return true;
6579 }
6580
6581 static bool test_ioctl_dup_extents_dest_lck(struct torture_context *tctx,
6582 struct smb2_tree *tree)
6583 {
6584 struct smb2_handle src_h;
6585 struct smb2_handle dest_h;
6586 struct smb2_handle dest_h2;
6587 NTSTATUS status;
6588 union smb_ioctl ioctl;
6589 TALLOC_CTX *tmp_ctx = talloc_new(tree);
6590 struct fsctl_dup_extents_to_file dup_ext_buf;
6591 enum ndr_err_code ndr_ret;
6592 bool ok;
6593 struct smb2_lock lck;
6594 struct smb2_lock_element el[1];
6595
6596 ok = test_setup_dup_extents(tctx, tree, tmp_ctx,
6597 &src_h, 32768, /* fill 32768 byte src file */
6598 SEC_RIGHTS_FILE_ALL,
6599 &dest_h, 0,
6600 SEC_RIGHTS_FILE_ALL,
6601 &dup_ext_buf,
6602 &ioctl);
6603 if (!ok) {
6604 torture_fail(tctx, "setup dup extents error");
6605 }
6606
6607 status = test_ioctl_fs_supported(tctx, tree, tmp_ctx, &src_h,
6608 FILE_SUPPORTS_BLOCK_REFCOUNTING, &ok);
6609 torture_assert_ntstatus_ok(tctx, status, "SMB2_GETINFO_FS");
6610 if (!ok) {
6611 smb2_util_close(tree, src_h);
6612 smb2_util_close(tree, dest_h);
6613 talloc_free(tmp_ctx);
6614 torture_skip(tctx, "block refcounting not supported\n");
6615 }
6616
6617 /* dest pattern is different to src */
6618 ok = write_pattern(tctx, tree, tmp_ctx, dest_h, 0, 32768, 32768);
6619 torture_assert(tctx, ok, "write pattern");
6620
6621 /* setup dup ext req, values used for locking */
6622 dup_ext_buf.source_off = 0;
6623 dup_ext_buf.target_off = 0;
6624 dup_ext_buf.byte_count = 32768;
6625
6626 /* open and lock the dup extents dest file */
6627 status = torture_smb2_testfile(tree, FNAME2, &dest_h2);
6628 torture_assert_ntstatus_ok(tctx, status, "2nd src open");
6629
6630 lck.in.lock_count = 0x0001;
6631 lck.in.lock_sequence = 0x00000000;
6632 lck.in.file.handle = dest_h2;
6633 lck.in.locks = el;
6634 el[0].offset = dup_ext_buf.source_off;
6635 el[0].length = dup_ext_buf.byte_count;
6636 el[0].reserved = 0;
6637 el[0].flags = SMB2_LOCK_FLAG_EXCLUSIVE;
6638
6639 status = smb2_lock(tree, &lck);
6640 torture_assert_ntstatus_ok(tctx, status, "lock");
6641
6642 status = smb2_util_write(tree, dest_h,
6643 "conflicted", 0, sizeof("conflicted"));
6644 torture_assert_ntstatus_equal(tctx, status,
6645 NT_STATUS_FILE_LOCK_CONFLICT, "file write");
6646
6647 ndr_ret = ndr_push_struct_blob(&ioctl.smb2.in.out, tmp_ctx,
6648 &dup_ext_buf,
6649 (ndr_push_flags_fn_t)ndr_push_fsctl_dup_extents_to_file);
6650 torture_assert_ndr_success(tctx, ndr_ret,
6651 "ndr_push_fsctl_dup_extents_to_file");
6652
6653 /*
6654 * In contrast to copy-chunk, dup extents doesn't cause a lock conflict
6655 * here.
6656 */
6657 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6658 torture_assert_ntstatus_ok(tctx, status, "FSCTL_DUP_EXTENTS_TO_FILE");
6659
6660 lck.in.lock_count = 0x0001;
6661 lck.in.lock_sequence = 0x00000001;
6662 lck.in.file.handle = dest_h2;
6663 lck.in.locks = el;
6664 el[0].offset = dup_ext_buf.source_off;
6665 el[0].length = dup_ext_buf.byte_count;
6666 el[0].reserved = 0;
6667 el[0].flags = SMB2_LOCK_FLAG_UNLOCK;
6668 status = smb2_lock(tree, &lck);
6669 torture_assert_ntstatus_ok(tctx, status, "unlock");
6670
6671 status = smb2_ioctl(tree, tmp_ctx, &ioctl.smb2);
6672 torture_assert_ntstatus_ok(tctx, status,
6673 "FSCTL_DUP_EXTENTS_TO_FILE unlocked");
6674
6675 ok = check_pattern(tctx, tree, tmp_ctx, dest_h, 0, 32768, 0);
6676 if (!ok) {
6677 torture_fail(tctx, "inconsistent file data");
6678 }
6679
6680 smb2_util_close(tree, src_h);
6681 smb2_util_close(tree, dest_h);
6682 smb2_util_close(tree, dest_h2);
6683 talloc_free(tmp_ctx);
6684 return true;
6685 }
6686
6687 /*
6688 * testing of SMB2 ioctls
6689 */
6690 struct torture_suite *torture_smb2_ioctl_init(TALLOC_CTX *ctx)
6691 {
6692 struct torture_suite *suite = torture_suite_create(ctx, "ioctl");
6693
6694 torture_suite_add_1smb2_test(suite, "shadow_copy",
6695 test_ioctl_get_shadow_copy);
6696 torture_suite_add_1smb2_test(suite, "req_resume_key",
6697 test_ioctl_req_resume_key);
6698 torture_suite_add_1smb2_test(suite, "req_two_resume_keys",
6699 test_ioctl_req_two_resume_keys);
6700 torture_suite_add_1smb2_test(suite, "copy_chunk_simple",
6701 test_ioctl_copy_chunk_simple);
6702 torture_suite_add_1smb2_test(suite, "copy_chunk_multi",
6703 test_ioctl_copy_chunk_multi);
6704 torture_suite_add_1smb2_test(suite, "copy_chunk_tiny",
6705 test_ioctl_copy_chunk_tiny);
6706 torture_suite_add_1smb2_test(suite, "copy_chunk_overwrite",
6707 test_ioctl_copy_chunk_over);
6708 torture_suite_add_1smb2_test(suite, "copy_chunk_append",
6709 test_ioctl_copy_chunk_append);
6710 torture_suite_add_1smb2_test(suite, "copy_chunk_limits",
6711 test_ioctl_copy_chunk_limits);
6712 torture_suite_add_1smb2_test(suite, "copy_chunk_src_lock",
6713 test_ioctl_copy_chunk_src_lck);
6714 torture_suite_add_1smb2_test(suite, "copy_chunk_dest_lock",
6715 test_ioctl_copy_chunk_dest_lck);
6716 torture_suite_add_1smb2_test(suite, "copy_chunk_bad_key",
6717 test_ioctl_copy_chunk_bad_key);
6718 torture_suite_add_1smb2_test(suite, "copy_chunk_src_is_dest",
6719 test_ioctl_copy_chunk_src_is_dest);
6720 torture_suite_add_1smb2_test(suite, "copy_chunk_src_is_dest_overlap",
6721 test_ioctl_copy_chunk_src_is_dest_overlap);
6722 torture_suite_add_1smb2_test(suite, "copy_chunk_bad_access",
6723 test_ioctl_copy_chunk_bad_access);
6724 torture_suite_add_1smb2_test(suite, "copy_chunk_write_access",
6725 test_ioctl_copy_chunk_write_access);
6726 torture_suite_add_1smb2_test(suite, "copy_chunk_src_exceed",
6727 test_ioctl_copy_chunk_src_exceed);
6728 torture_suite_add_1smb2_test(suite, "copy_chunk_src_exceed_multi",
6729 test_ioctl_copy_chunk_src_exceed_multi);
6730 torture_suite_add_1smb2_test(suite, "copy_chunk_sparse_dest",
6731 test_ioctl_copy_chunk_sparse_dest);
6732 torture_suite_add_1smb2_test(suite, "copy_chunk_max_output_sz",
6733 test_ioctl_copy_chunk_max_output_sz);
6734 torture_suite_add_1smb2_test(suite, "copy_chunk_zero_length",
6735 test_ioctl_copy_chunk_zero_length);
6736 torture_suite_add_1smb2_test(suite, "copy-chunk streams",
6737 test_copy_chunk_streams);
6738 torture_suite_add_1smb2_test(suite, "copy_chunk_across_shares",
6739 test_copy_chunk_across_shares);
6740 torture_suite_add_1smb2_test(suite, "copy_chunk_across_shares2",
6741 test_copy_chunk_across_shares2);
6742 torture_suite_add_1smb2_test(suite, "copy_chunk_across_shares3",
6743 test_copy_chunk_across_shares3);
6744 torture_suite_add_1smb2_test(suite, "compress_file_flag",
6745 test_ioctl_compress_file_flag);
6746 torture_suite_add_1smb2_test(suite, "compress_dir_inherit",
6747 test_ioctl_compress_dir_inherit);
6748 torture_suite_add_1smb2_test(suite, "compress_invalid_format",
6749 test_ioctl_compress_invalid_format);
6750 torture_suite_add_1smb2_test(suite, "compress_invalid_buf",
6751 test_ioctl_compress_invalid_buf);
6752 torture_suite_add_1smb2_test(suite, "compress_query_file_attr",
6753 test_ioctl_compress_query_file_attr);
6754 torture_suite_add_1smb2_test(suite, "compress_create_with_attr",
6755 test_ioctl_compress_create_with_attr);
6756 torture_suite_add_1smb2_test(suite, "compress_inherit_disable",
6757 test_ioctl_compress_inherit_disable);
6758 torture_suite_add_1smb2_test(suite, "compress_set_file_attr",
6759 test_ioctl_compress_set_file_attr);
6760 torture_suite_add_1smb2_test(suite, "compress_perms",
6761 test_ioctl_compress_perms);
6762 torture_suite_add_1smb2_test(suite, "compress_notsup_get",
6763 test_ioctl_compress_notsup_get);
6764 torture_suite_add_1smb2_test(suite, "compress_notsup_set",
6765 test_ioctl_compress_notsup_set);
6766 torture_suite_add_1smb2_test(suite, "network_interface_info",
6767 test_ioctl_network_interface_info);
6768 torture_suite_add_1smb2_test(suite, "sparse_file_flag",
6769 test_ioctl_sparse_file_flag);
6770 torture_suite_add_1smb2_test(suite, "sparse_file_attr",
6771 test_ioctl_sparse_file_attr);
6772 torture_suite_add_1smb2_test(suite, "sparse_dir_flag",
6773 test_ioctl_sparse_dir_flag);
6774 torture_suite_add_1smb2_test(suite, "sparse_set_nobuf",
6775 test_ioctl_sparse_set_nobuf);
6776 torture_suite_add_1smb2_test(suite, "sparse_set_oversize",
6777 test_ioctl_sparse_set_oversize);
6778 torture_suite_add_1smb2_test(suite, "sparse_qar",
6779 test_ioctl_sparse_qar);
6780 torture_suite_add_1smb2_test(suite, "sparse_qar_malformed",
6781 test_ioctl_sparse_qar_malformed);
6782 torture_suite_add_1smb2_test(suite, "sparse_punch",
6783 test_ioctl_sparse_punch);
6784 torture_suite_add_1smb2_test(suite, "sparse_hole_dealloc",
6785 test_ioctl_sparse_hole_dealloc);
6786 torture_suite_add_1smb2_test(suite, "sparse_compressed",
6787 test_ioctl_sparse_compressed);
6788 torture_suite_add_1smb2_test(suite, "sparse_copy_chunk",
6789 test_ioctl_sparse_copy_chunk);
6790 torture_suite_add_1smb2_test(suite, "sparse_punch_invalid",
6791 test_ioctl_sparse_punch_invalid);
6792 torture_suite_add_1smb2_test(suite, "sparse_perms",
6793 test_ioctl_sparse_perms);
6794 torture_suite_add_1smb2_test(suite, "sparse_lock",
6795 test_ioctl_sparse_lck);
6796 torture_suite_add_1smb2_test(suite, "sparse_qar_ob1",
6797 test_ioctl_sparse_qar_ob1);
6798 torture_suite_add_1smb2_test(suite, "sparse_qar_multi",
6799 test_ioctl_sparse_qar_multi);
6800 torture_suite_add_1smb2_test(suite, "sparse_qar_overflow",
6801 test_ioctl_sparse_qar_overflow);
6802 torture_suite_add_1smb2_test(suite, "trim_simple",
6803 test_ioctl_trim_simple);
6804 torture_suite_add_1smb2_test(suite, "dup_extents_simple",
6805 test_ioctl_dup_extents_simple);
6806 torture_suite_add_1smb2_test(suite, "dup_extents_len_beyond_dest",
6807 test_ioctl_dup_extents_len_beyond_dest);
6808 torture_suite_add_1smb2_test(suite, "dup_extents_len_beyond_src",
6809 test_ioctl_dup_extents_len_beyond_src);
6810 torture_suite_add_1smb2_test(suite, "dup_extents_len_zero",
6811 test_ioctl_dup_extents_len_zero);
6812 torture_suite_add_1smb2_test(suite, "dup_extents_sparse_src",
6813 test_ioctl_dup_extents_sparse_src);
6814 torture_suite_add_1smb2_test(suite, "dup_extents_sparse_dest",
6815 test_ioctl_dup_extents_sparse_dest);
6816 torture_suite_add_1smb2_test(suite, "dup_extents_sparse_both",
6817 test_ioctl_dup_extents_sparse_both);
6818 torture_suite_add_1smb2_test(suite, "dup_extents_src_is_dest",
6819 test_ioctl_dup_extents_src_is_dest);
6820 torture_suite_add_1smb2_test(suite, "dup_extents_src_is_dest_overlap",
6821 test_ioctl_dup_extents_src_is_dest_overlap);
6822 torture_suite_add_1smb2_test(suite, "dup_extents_compressed_src",
6823 test_ioctl_dup_extents_compressed_src);
6824 torture_suite_add_1smb2_test(suite, "dup_extents_compressed_dest",
6825 test_ioctl_dup_extents_compressed_dest);
6826 torture_suite_add_1smb2_test(suite, "dup_extents_bad_handle",
6827 test_ioctl_dup_extents_bad_handle);
6828 torture_suite_add_1smb2_test(suite, "dup_extents_src_lock",
6829 test_ioctl_dup_extents_src_lck);
6830 torture_suite_add_1smb2_test(suite, "dup_extents_dest_lock",
6831 test_ioctl_dup_extents_dest_lck);
6832
6833 suite->description = talloc_strdup(suite, "SMB2-IOCTL tests");
6834
6835 return suite;
6836 }
6837
Samba GIT mirror