Change uint_t to unsigned int in source4
[Samba/nascimento.git] / source4 / torture / smb2 / dir.c
blob8c3cb7633602a27d93946dbd473f2854a8e392c5
1 /*
2 Unix SMB/CIFS implementation.
4 SMB2 dir list test suite
6 Copyright (C) Andrew Tridgell 2005
7 Copyright (C) Zachary Loafman 2009
8 Copyright (C) Aravind Srinivasan 2009
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "includes.h"
25 #include "libcli/smb2/smb2.h"
26 #include "libcli/smb2/smb2_calls.h"
27 #include "libcli/smb_composite/smb_composite.h"
28 #include "libcli/raw/libcliraw.h"
29 #include "libcli/raw/raw_proto.h"
30 #include "libcli/libcli.h"
32 #include "torture/torture.h"
33 #include "torture/smb2/proto.h"
34 #include "torture/util.h"
36 #include "system/filesys.h"
38 #define DNAME "smb2_dir"
39 #define NFILES 100
41 struct file_elem {
42 char *name;
43 bool found;
46 static NTSTATUS populate_tree(struct torture_context *tctx,
47 TALLOC_CTX *mem_ctx,
48 struct smb2_tree *tree,
49 struct file_elem *files,
50 int nfiles,
51 struct smb2_handle *h_out)
53 struct smb2_create create;
54 char **strs = NULL;
55 NTSTATUS status;
56 bool ret;
57 int i;
59 smb2_deltree(tree, DNAME);
61 ZERO_STRUCT(create);
62 create.in.desired_access = SEC_RIGHTS_DIR_ALL;
63 create.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
64 create.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
65 create.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
66 NTCREATEX_SHARE_ACCESS_WRITE |
67 NTCREATEX_SHARE_ACCESS_DELETE;
68 create.in.create_disposition = NTCREATEX_DISP_CREATE;
69 create.in.fname = DNAME;
71 status = smb2_create(tree, mem_ctx, &create);
72 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
73 *h_out = create.out.file.handle;
75 ZERO_STRUCT(create);
76 create.in.desired_access = SEC_RIGHTS_FILE_ALL;
77 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
78 create.in.create_disposition = NTCREATEX_DISP_CREATE;
80 strs = generate_unique_strs(mem_ctx, 8, nfiles);
81 if (strs == NULL) {
82 status = NT_STATUS_OBJECT_NAME_COLLISION;
83 goto done;
85 for (i = 0; i < nfiles; i++) {
86 files[i].name = strs[i];
87 create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s",
88 DNAME, files[i].name);
89 status = smb2_create(tree, mem_ctx, &create);
90 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
91 smb2_util_close(tree, create.out.file.handle);
93 done:
94 return status;
98 test find continue
101 static bool test_find(struct torture_context *tctx,
102 struct smb2_tree *tree)
104 TALLOC_CTX *mem_ctx = talloc_new(tctx);
105 struct smb2_handle h;
106 struct smb2_find f;
107 union smb_search_data *d;
108 struct file_elem files[NFILES] = {};
109 NTSTATUS status;
110 bool ret = true;
111 unsigned int count;
112 int i, j, file_count = 0;
114 status = populate_tree(tctx, mem_ctx, tree, files, NFILES, &h);
116 ZERO_STRUCT(f);
117 f.in.file.handle = h;
118 f.in.pattern = "*";
119 f.in.continue_flags = SMB2_CONTINUE_FLAG_SINGLE;
120 f.in.max_response_size = 0x100;
121 f.in.level = SMB2_FIND_BOTH_DIRECTORY_INFO;
123 do {
124 status = smb2_find_level(tree, tree, &f, &count, &d);
125 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
126 break;
127 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
129 for (i = 0; i < count; i++) {
130 bool expected;
131 const char *found = d[i].both_directory_info.name.s;
133 if (!strcmp(found, ".") || !strcmp(found, ".."))
134 continue;
136 expected = false;
137 for (j = 0; j < NFILES; j++) {
138 if (!strcmp(files[j].name, found)) {
139 files[j].found = true;
140 expected = true;
141 break;
145 if (expected)
146 continue;
148 torture_result(tctx, TORTURE_FAIL,
149 "(%s): didn't expect %s\n",
150 __location__, found);
151 ret = false;
152 goto done;
155 file_count = file_count + i;
156 f.in.continue_flags = 0;
157 f.in.max_response_size = 4096;
158 } while (count != 0);
160 torture_assert_int_equal_goto(tctx, file_count, NFILES + 2, ret, done,
161 "");
163 for (i = 0; i < NFILES; i++) {
164 if (files[j].found)
165 continue;
167 torture_result(tctx, TORTURE_FAIL,
168 "(%s): expected to find %s, but didn't\n",
169 __location__, files[j].name);
170 ret = false;
171 goto done;
174 done:
175 smb2_deltree(tree, DNAME);
176 talloc_free(mem_ctx);
178 return ret;
182 test fixed enumeration
185 static bool test_fixed(struct torture_context *tctx,
186 struct smb2_tree *tree)
188 TALLOC_CTX *mem_ctx = talloc_new(tctx);
189 struct smb2_create create;
190 struct smb2_handle h, h2;
191 struct smb2_find f;
192 union smb_search_data *d;
193 struct file_elem files[NFILES] = {};
194 NTSTATUS status;
195 bool ret = true;
196 unsigned int count;
197 int i;
199 status = populate_tree(tctx, mem_ctx, tree, files, NFILES, &h);
201 ZERO_STRUCT(create);
202 create.in.desired_access = SEC_RIGHTS_DIR_ALL;
203 create.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
204 create.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
205 create.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
206 NTCREATEX_SHARE_ACCESS_WRITE |
207 NTCREATEX_SHARE_ACCESS_DELETE;
208 create.in.create_disposition = NTCREATEX_DISP_OPEN;
209 create.in.fname = DNAME;
211 status = smb2_create(tree, mem_ctx, &create);
212 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
213 h2 = create.out.file.handle;
215 ZERO_STRUCT(f);
216 f.in.file.handle = h;
217 f.in.pattern = "*";
218 f.in.continue_flags = SMB2_CONTINUE_FLAG_SINGLE;
219 f.in.max_response_size = 0x100;
220 f.in.level = SMB2_FIND_BOTH_DIRECTORY_INFO;
222 /* Start enumeration on h, then delete all from h2 */
223 status = smb2_find_level(tree, tree, &f, &count, &d);
224 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
226 f.in.file.handle = h2;
228 do {
229 status = smb2_find_level(tree, tree, &f, &count, &d);
230 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
231 break;
232 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
234 for (i = 0; i < count; i++) {
235 const char *found = d[i].both_directory_info.name.s;
236 char *path = talloc_asprintf(mem_ctx, "%s\\%s",
237 DNAME, found);
239 if (!strcmp(found, ".") || !strcmp(found, ".."))
240 continue;
242 status = smb2_util_unlink(tree, path);
243 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
244 "");
246 talloc_free(path);
249 f.in.continue_flags = 0;
250 f.in.max_response_size = 4096;
251 } while (count != 0);
253 /* Now finish h enumeration. */
254 f.in.file.handle = h;
256 do {
257 status = smb2_find_level(tree, tree, &f, &count, &d);
258 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
259 break;
260 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
262 for (i = 0; i < count; i++) {
263 const char *found = d[i].both_directory_info.name.s;
265 if (!strcmp(found, ".") || !strcmp(found, ".."))
266 continue;
268 torture_result(tctx, TORTURE_FAIL,
269 "(%s): didn't expect %s\n",
270 __location__, found);
271 ret = false;
272 goto done;
275 f.in.continue_flags = 0;
276 f.in.max_response_size = 4096;
277 } while (count != 0);
279 done:
280 smb2_util_close(tree, h);
281 smb2_util_close(tree, h2);
282 smb2_deltree(tree, DNAME);
283 talloc_free(mem_ctx);
285 return ret;
288 static struct {
289 const char *name;
290 uint8_t level;
291 enum smb_search_data_level data_level;
292 int name_offset;
293 int resume_key_offset;
294 uint32_t capability_mask;
295 NTSTATUS status;
296 union smb_search_data data;
297 } levels[] = {
298 {"SMB2_FIND_DIRECTORY_INFO",
299 SMB2_FIND_DIRECTORY_INFO, RAW_SEARCH_DATA_DIRECTORY_INFO,
300 offsetof(union smb_search_data, directory_info.name.s),
301 offsetof(union smb_search_data, directory_info.file_index),
303 {"SMB2_FIND_FULL_DIRECTORY_INFO",
304 SMB2_FIND_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,
305 offsetof(union smb_search_data, full_directory_info.name.s),
306 offsetof(union smb_search_data, full_directory_info.file_index),
308 {"SMB2_FIND_NAME_INFO",
309 SMB2_FIND_NAME_INFO, RAW_SEARCH_DATA_NAME_INFO,
310 offsetof(union smb_search_data, name_info.name.s),
311 offsetof(union smb_search_data, name_info.file_index),
313 {"SMB2_FIND_BOTH_DIRECTORY_INFO",
314 SMB2_FIND_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
315 offsetof(union smb_search_data, both_directory_info.name.s),
316 offsetof(union smb_search_data, both_directory_info.file_index),
318 {"SMB2_FIND_ID_FULL_DIRECTORY_INFO",
319 SMB2_FIND_ID_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO,
320 offsetof(union smb_search_data, id_full_directory_info.name.s),
321 offsetof(union smb_search_data, id_full_directory_info.file_index),
323 {"SMB2_FIND_ID_BOTH_DIRECTORY_INFO",
324 SMB2_FIND_ID_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO,
325 offsetof(union smb_search_data, id_both_directory_info.name.s),
326 offsetof(union smb_search_data, id_both_directory_info.file_index),
331 extract the name from a smb_data structure and level
333 static const char *extract_name(union smb_search_data *data,
334 uint8_t level,
335 enum smb_search_data_level data_level)
337 int i;
338 for (i=0;i<ARRAY_SIZE(levels);i++) {
339 if (level == levels[i].level &&
340 data_level == levels[i].data_level) {
341 return *(const char **)(levels[i].name_offset + (char *)data);
344 return NULL;
347 /* find a level in the table by name */
348 static union smb_search_data *find(const char *name)
350 int i;
351 for (i=0;i<ARRAY_SIZE(levels);i++) {
352 if (NT_STATUS_IS_OK(levels[i].status) &&
353 strcmp(levels[i].name, name) == 0) {
354 return &levels[i].data;
357 return NULL;
360 static bool fill_level_data(TALLOC_CTX *mem_ctx,
361 union smb_search_data *data,
362 union smb_search_data *d,
363 unsigned int count,
364 uint8_t level,
365 enum smb_search_data_level data_level)
367 int i;
368 const char *sname = NULL;
369 for (i=0; i < count ; i++) {
370 sname = extract_name(&d[i], level, data_level);
371 if (sname == NULL)
372 return false;
373 if (!strcmp(sname, ".") || !strcmp(sname, ".."))
374 continue;
375 *data = d[i];
377 return true;
381 NTSTATUS torture_single_file_search(struct smb2_tree *tree,
382 TALLOC_CTX *mem_ctx,
383 const char *pattern,
384 uint8_t level,
385 enum smb_search_data_level data_level,
386 int idx,
387 union smb_search_data *d,
388 unsigned int *count,
389 struct smb2_handle *h)
391 struct smb2_find f;
392 NTSTATUS status;
394 ZERO_STRUCT(f);
395 f.in.file.handle = *h;
396 f.in.pattern = pattern;
397 f.in.continue_flags = SMB2_CONTINUE_FLAG_RESTART;
398 f.in.max_response_size = 0x100;
399 f.in.level = level;
401 status = smb2_find_level(tree, tree, &f, count, &d);
402 if (NT_STATUS_IS_OK(status))
403 fill_level_data(mem_ctx, &levels[idx].data, d, *count, level,
404 data_level);
405 return status;
409 basic testing of all File Information Classes using a single file
411 static bool test_one_file(struct torture_context *tctx,
412 struct smb2_tree *tree)
414 TALLOC_CTX *mem_ctx = talloc_new(tctx);
415 bool ret = true;
416 const char *fname = "torture_search.txt";
417 NTSTATUS status;
418 int i;
419 unsigned int count;
420 union smb_fileinfo all_info2, alt_info, internal_info;
421 union smb_search_data *s;
422 union smb_search_data d;
423 struct smb2_handle h, h2;
425 status = torture_smb2_testdir(tree, DNAME, &h);
426 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
428 status = smb2_create_complex_file(tree, DNAME "\\torture_search.txt",
429 &h2);
430 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
432 /* call all the File Information Classes */
433 for (i=0;i<ARRAY_SIZE(levels);i++) {
434 torture_comment(tctx, "testing %s %d\n", levels[i].name,
435 levels[i].level);
437 levels[i].status = torture_single_file_search(tree, mem_ctx,
438 fname, levels[i].level, levels[i].data_level,
439 i, &d, &count, &h);
440 torture_assert_ntstatus_ok_goto(tctx, levels[i].status, ret,
441 done, "");
444 /* get the all_info file into to check against */
445 all_info2.generic.level = RAW_FILEINFO_SMB2_ALL_INFORMATION;
446 all_info2.generic.in.file.handle = h2;
447 status = smb2_getinfo_file(tree, tctx, &all_info2);
448 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
449 "RAW_FILEINFO_ALL_INFO failed");
451 alt_info.generic.level = RAW_FILEINFO_ALT_NAME_INFORMATION;
452 alt_info.generic.in.file.handle = h2;
453 status = smb2_getinfo_file(tree, tctx, &alt_info);
454 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
455 "RAW_FILEINFO_ALT_NAME_INFO failed");
457 internal_info.generic.level = RAW_FILEINFO_INTERNAL_INFORMATION;
458 internal_info.generic.in.file.handle = h2;
459 status = smb2_getinfo_file(tree, tctx, &internal_info);
460 torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
461 "RAW_FILEINFO_INTERNAL_INFORMATION "
462 "failed");
464 #define CHECK_VAL(name, sname1, field1, v, sname2, field2) do { \
465 s = find(name); \
466 if (s) { \
467 if ((s->sname1.field1) != (v.sname2.out.field2)) { \
468 torture_result(tctx, TORTURE_FAIL, \
469 "(%s) %s/%s [0x%x] != %s/%s [0x%x]\n", \
470 __location__, \
471 #sname1, #field1, (int)s->sname1.field1, \
472 #sname2, #field2, (int)v.sname2.out.field2); \
473 ret = false; \
475 }} while (0)
477 #define CHECK_TIME(name, sname1, field1, v, sname2, field2) do { \
478 s = find(name); \
479 if (s) { \
480 if (s->sname1.field1 != \
481 (~1 & nt_time_to_unix(v.sname2.out.field2))) { \
482 torture_result(tctx, TORTURE_FAIL, \
483 "(%s) %s/%s [%s] != %s/%s [%s]\n", \
484 __location__, \
485 #sname1, #field1, \
486 timestring(tctx, s->sname1.field1), \
487 #sname2, #field2, \
488 nt_time_string(tctx, v.sname2.out.field2)); \
489 ret = false; \
491 }} while (0)
493 #define CHECK_NTTIME(name, sname1, field1, v, sname2, field2) do { \
494 s = find(name); \
495 if (s) { \
496 if (s->sname1.field1 != v.sname2.out.field2) { \
497 torture_result(tctx, TORTURE_FAIL, \
498 "(%s) %s/%s [%s] != %s/%s [%s]\n", \
499 __location__, \
500 #sname1, #field1, \
501 nt_time_string(tctx, s->sname1.field1), \
502 #sname2, #field2, \
503 nt_time_string(tctx, v.sname2.out.field2)); \
504 ret = false; \
506 }} while (0)
508 #define CHECK_STR(name, sname1, field1, v, sname2, field2) do { \
509 s = find(name); \
510 if (s) { \
511 if (!s->sname1.field1 || \
512 strcmp(s->sname1.field1, v.sname2.out.field2.s)) { \
513 torture_result(tctx, TORTURE_FAIL, \
514 "(%s) %s/%s [%s] != %s/%s [%s]\n", \
515 __location__, \
516 #sname1, #field1, s->sname1.field1, \
517 #sname2, #field2, v.sname2.out.field2.s); \
518 ret = false; \
520 }} while (0)
522 #define CHECK_WSTR(name, sname1, field1, v, sname2, field2, flags) do { \
523 s = find(name); \
524 if (s) { \
525 if (!s->sname1.field1.s || \
526 strcmp(s->sname1.field1.s, v.sname2.out.field2.s)) { \
527 torture_result(tctx, TORTURE_FAIL, \
528 "(%s) %s/%s [%s] != %s/%s [%s]\n", \
529 __location__, \
530 #sname1, #field1, s->sname1.field1.s, \
531 #sname2, #field2, v.sname2.out.field2.s); \
532 ret = false; \
534 }} while (0)
536 #define CHECK_NAME(name, sname1, field1, fname, flags) do { \
537 s = find(name); \
538 if (s) { \
539 if (!s->sname1.field1.s || \
540 strcmp(s->sname1.field1.s, fname)) { \
541 torture_result(tctx, TORTURE_FAIL, \
542 "(%s) %s/%s [%s] != %s\n", \
543 __location__, \
544 #sname1, #field1, s->sname1.field1.s, fname); \
545 ret = false; \
547 }} while (0)
549 #define CHECK_UNIX_NAME(name, sname1, field1, fname, flags) do { \
550 s = find(name); \
551 if (s) { \
552 if (!s->sname1.field1 || \
553 strcmp(s->sname1.field1, fname)) { \
554 torture_result(tctx, TORTURE_FAIL, \
555 "(%s) %s/%s [%s] != %s\n", \
556 __location__, \
557 #sname1, #field1, s->sname1.field1, fname); \
558 ret = false; \
560 }} while (0)
562 /* check that all the results are as expected */
563 CHECK_VAL("SMB2_FIND_DIRECTORY_INFO", directory_info, attrib, all_info2, all_info2, attrib);
564 CHECK_VAL("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, attrib, all_info2, all_info2, attrib);
565 CHECK_VAL("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, attrib, all_info2, all_info2, attrib);
566 CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, attrib, all_info2, all_info2, attrib);
567 CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, attrib, all_info2, all_info2, attrib);
569 CHECK_NTTIME("SMB2_FIND_DIRECTORY_INFO", directory_info, write_time, all_info2, all_info2, write_time);
570 CHECK_NTTIME("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, write_time, all_info2, all_info2, write_time);
571 CHECK_NTTIME("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, write_time, all_info2, all_info2, write_time);
572 CHECK_NTTIME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, write_time, all_info2, all_info2, write_time);
573 CHECK_NTTIME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, write_time, all_info2, all_info2, write_time);
575 CHECK_NTTIME("SMB2_FIND_DIRECTORY_INFO", directory_info, create_time, all_info2, all_info2, create_time);
576 CHECK_NTTIME("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, create_time, all_info2, all_info2, create_time);
577 CHECK_NTTIME("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, create_time, all_info2, all_info2, create_time);
578 CHECK_NTTIME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, create_time, all_info2, all_info2, create_time);
579 CHECK_NTTIME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, create_time, all_info2, all_info2, create_time);
581 CHECK_NTTIME("SMB2_FIND_DIRECTORY_INFO", directory_info, access_time, all_info2, all_info2, access_time);
582 CHECK_NTTIME("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, access_time, all_info2, all_info2, access_time);
583 CHECK_NTTIME("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, access_time, all_info2, all_info2, access_time);
584 CHECK_NTTIME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, access_time, all_info2, all_info2, access_time);
585 CHECK_NTTIME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, access_time, all_info2, all_info2, access_time);
587 CHECK_NTTIME("SMB2_FIND_DIRECTORY_INFO", directory_info, change_time, all_info2, all_info2, change_time);
588 CHECK_NTTIME("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, change_time, all_info2, all_info2, change_time);
589 CHECK_NTTIME("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, change_time, all_info2, all_info2, change_time);
590 CHECK_NTTIME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, change_time, all_info2, all_info2, change_time);
591 CHECK_NTTIME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, change_time, all_info2, all_info2, change_time);
593 CHECK_VAL("SMB2_FIND_DIRECTORY_INFO", directory_info, size, all_info2, all_info2, size);
594 CHECK_VAL("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, size, all_info2, all_info2, size);
595 CHECK_VAL("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, size, all_info2, all_info2, size);
596 CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, size, all_info2, all_info2, size);
597 CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, size, all_info2, all_info2, size);
599 CHECK_VAL("SMB2_FIND_DIRECTORY_INFO", directory_info, alloc_size, all_info2, all_info2, alloc_size);
600 CHECK_VAL("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, alloc_size, all_info2, all_info2, alloc_size);
601 CHECK_VAL("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, alloc_size, all_info2, all_info2, alloc_size);
602 CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, alloc_size, all_info2, all_info2, alloc_size);
603 CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, alloc_size, all_info2, all_info2, alloc_size);
605 CHECK_VAL("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, ea_size, all_info2, all_info2, ea_size);
606 CHECK_VAL("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, ea_size, all_info2, all_info2, ea_size);
607 CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, ea_size, all_info2, all_info2, ea_size);
608 CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, ea_size, all_info2, all_info2, ea_size);
610 CHECK_NAME("SMB2_FIND_DIRECTORY_INFO", directory_info, name, fname, STR_TERMINATE_ASCII);
611 CHECK_NAME("SMB2_FIND_FULL_DIRECTORY_INFO", full_directory_info, name, fname, STR_TERMINATE_ASCII);
612 CHECK_NAME("SMB2_FIND_NAME_INFO", name_info, name, fname, STR_TERMINATE_ASCII);
613 CHECK_NAME("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, name, fname, STR_TERMINATE_ASCII);
614 CHECK_NAME("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, name, fname, STR_TERMINATE_ASCII);
615 CHECK_NAME("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, name, fname, STR_TERMINATE_ASCII);
617 CHECK_WSTR("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, short_name, alt_info, alt_name_info, fname, STR_UNICODE);
619 CHECK_VAL("SMB2_FIND_ID_FULL_DIRECTORY_INFO", id_full_directory_info, file_id, internal_info, internal_information, file_id);
620 CHECK_VAL("SMB2_FIND_ID_BOTH_DIRECTORY_INFO", id_both_directory_info, file_id, internal_info, internal_information, file_id);
622 done:
623 smb2_util_close(tree, h);
624 smb2_util_unlink(tree, fname);
625 talloc_free(mem_ctx);
627 return ret;
631 struct multiple_result {
632 TALLOC_CTX *tctx;
633 int count;
634 union smb_search_data *list;
637 bool fill_result(void *private_data,
638 union smb_search_data *file,
639 int count,
640 uint8_t level,
641 enum smb_search_data_level data_level)
643 int i;
644 const char *sname;
645 struct multiple_result *data = (struct multiple_result *)private_data;
647 for (i=0; i<count; i++) {
648 sname = extract_name(&file[i], level, data_level);
649 if (!strcmp(sname, ".") || !(strcmp(sname, "..")))
650 continue;
651 data->count++;
652 data->list = talloc_realloc(data->tctx,
653 data->list,
654 union smb_search_data,
655 data->count);
656 data->list[data->count-1] = file[i];
658 return true;
661 enum continue_type {CONT_SINGLE, CONT_INDEX, CONT_RESTART};
663 static NTSTATUS multiple_smb2_search(struct smb2_tree *tree,
664 TALLOC_CTX *tctx,
665 const char *pattern,
666 uint8_t level,
667 enum smb_search_data_level data_level,
668 enum continue_type cont_type,
669 void *data,
670 struct smb2_handle *h)
672 struct smb2_find f;
673 bool ret = true;
674 unsigned int count = 0;
675 union smb_search_data *d;
676 NTSTATUS status;
677 struct multiple_result *result = (struct multiple_result *)data;
679 ZERO_STRUCT(f);
680 f.in.file.handle = *h;
681 f.in.pattern = pattern;
682 f.in.max_response_size = 0x1000;
683 f.in.level = level;
685 /* The search should start from the beginning everytime */
686 f.in.continue_flags = SMB2_CONTINUE_FLAG_RESTART;
688 do {
689 status = smb2_find_level(tree, tree, &f, &count, &d);
690 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
691 break;
692 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
693 if (!fill_result(result, d, count, level, data_level)) {
694 return NT_STATUS_UNSUCCESSFUL;
698 * After the first iteration is complete set the CONTINUE
699 * FLAGS appropriately
701 switch (cont_type) {
702 case CONT_INDEX:
703 f.in.continue_flags = SMB2_CONTINUE_FLAG_INDEX;
704 break;
705 case CONT_SINGLE:
706 f.in.continue_flags = SMB2_CONTINUE_FLAG_SINGLE;
707 break;
708 case CONT_RESTART:
709 default:
710 /* we should prevent staying in the loop
711 * forever */
712 f.in.continue_flags = 0;
713 break;
715 } while (count != 0);
716 done:
717 return status;
721 static enum smb_search_data_level compare_data_level;
722 uint8_t level_sort;
724 static int search_compare(union smb_search_data *d1,
725 union smb_search_data *d2)
727 const char *s1, *s2;
729 s1 = extract_name(d1, level_sort, compare_data_level);
730 s2 = extract_name(d2, level_sort, compare_data_level);
731 return strcmp_safe(s1, s2);
735 basic testing of search calls using many files
737 static bool test_many_files(struct torture_context *tctx,
738 struct smb2_tree *tree)
740 TALLOC_CTX *mem_ctx = talloc_new(tctx);
741 const int num_files = 700;
742 int i, t;
743 char *fname;
744 bool ret = true;
745 NTSTATUS status;
746 struct multiple_result result;
747 struct smb2_create create;
748 struct smb2_handle h;
749 struct {
750 const char *name;
751 const char *cont_name;
752 uint8_t level;
753 enum smb_search_data_level data_level;
754 enum continue_type cont_type;
755 } search_types[] = {
756 {"SMB2_FIND_BOTH_DIRECTORY_INFO", "SINGLE", SMB2_FIND_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO, CONT_SINGLE},
757 {"SMB2_FIND_BOTH_DIRECTORY_INFO", "INDEX", SMB2_FIND_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO, CONT_INDEX},
758 {"SMB2_FIND_BOTH_DIRECTORY_INFO", "RESTART", SMB2_FIND_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO, CONT_RESTART},
759 {"SMB2_FIND_DIRECTORY_INFO", "SINGLE", SMB2_FIND_DIRECTORY_INFO, RAW_SEARCH_DATA_DIRECTORY_INFO, CONT_SINGLE},
760 {"SMB2_FIND_DIRECTORY_INFO", "INDEX", SMB2_FIND_DIRECTORY_INFO, RAW_SEARCH_DATA_DIRECTORY_INFO, CONT_INDEX},
761 {"SMB2_FIND_DIRECTORY_INFO", "RESTART", SMB2_FIND_DIRECTORY_INFO, RAW_SEARCH_DATA_DIRECTORY_INFO, CONT_RESTART},
762 {"SMB2_FIND_FULL_DIRECTORY_INFO", "SINGLE", SMB2_FIND_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_FULL_DIRECTORY_INFO, CONT_SINGLE},
763 {"SMB2_FIND_FULL_DIRECTORY_INFO", "INDEX", SMB2_FIND_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_FULL_DIRECTORY_INFO, CONT_INDEX},
764 {"SMB2_FIND_FULL_DIRECTORY_INFO", "RESTART", SMB2_FIND_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_FULL_DIRECTORY_INFO, CONT_RESTART},
765 {"SMB2_FIND_ID_FULL_DIRECTORY_INFO", "SINGLE", SMB2_FIND_ID_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_SINGLE},
766 {"SMB2_FIND_ID_FULL_DIRECTORY_INFO", "INDEX", SMB2_FIND_ID_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_INDEX},
767 {"SMB2_FIND_ID_FULL_DIRECTORY_INFO", "RESTART", SMB2_FIND_ID_FULL_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_RESTART},
768 {"SMB2_FIND_ID_BOTH_DIRECTORY_INFO", "SINGLE", SMB2_FIND_ID_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_SINGLE},
769 {"SMB2_FIND_ID_BOTH_DIRECTORY_INFO", "INDEX", SMB2_FIND_ID_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_INDEX},
770 {"SMB2_FIND_ID_BOTH_DIRECTORY_INFO", "RESTART", SMB2_FIND_ID_BOTH_DIRECTORY_INFO, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_RESTART}
773 smb2_deltree(tree, DNAME);
774 status = torture_smb2_testdir(tree, DNAME, &h);
775 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
777 torture_comment(tctx, "Testing with %d files\n", num_files);
778 ZERO_STRUCT(create);
779 create.in.desired_access = SEC_RIGHTS_FILE_ALL;
780 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
781 create.in.create_disposition = NTCREATEX_DISP_CREATE;
783 for (i=num_files-1;i>=0;i--) {
784 fname = talloc_asprintf(mem_ctx, DNAME "\\t%03d-%d.txt", i, i);
785 create.in.fname = talloc_asprintf(mem_ctx, "%s", fname);
786 status = smb2_create(tree, mem_ctx, &create);
787 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
788 smb2_util_close(tree, create.out.file.handle);
789 talloc_free(fname);
792 for (t=0;t<ARRAY_SIZE(search_types);t++) {
793 ZERO_STRUCT(result);
794 result.tctx = talloc_new(tctx);
796 torture_comment(tctx,
797 "Continue %s via %s\n", search_types[t].name,
798 search_types[t].cont_name);
799 status = multiple_smb2_search(tree, tctx, "*",
800 search_types[t].level,
801 search_types[t].data_level,
802 search_types[t].cont_type,
803 &result, &h);
805 torture_assert_int_equal_goto(tctx, result.count, num_files,
806 ret, done, "");
808 compare_data_level = search_types[t].data_level;
809 level_sort = search_types[t].level;
811 qsort(result.list, result.count, sizeof(result.list[0]),
812 QSORT_CAST search_compare);
814 for (i=0;i<result.count;i++) {
815 const char *s;
816 enum smb_search_level level;
817 level = RAW_SEARCH_SMB2;
818 s = extract_name(&result.list[i],
819 search_types[t].level,
820 compare_data_level);
821 fname = talloc_asprintf(mem_ctx, "t%03d-%d.txt", i, i);
822 torture_assert_str_equal_goto(tctx, s, fname, ret,
823 done, "Incorrect name");
824 talloc_free(fname);
826 talloc_free(result.tctx);
829 done:
830 smb2_util_close(tree, h);
831 smb2_deltree(tree, DNAME);
832 talloc_free(mem_ctx);
834 return ret;
838 check an individual file result
840 static bool check_result(struct torture_context *tctx,
841 struct multiple_result *result,
842 const char *name,
843 bool exist,
844 uint32_t attrib)
846 int i;
847 for (i=0;i<result->count;i++) {
848 if (strcmp(name,
849 result->list[i].both_directory_info.name.s) == 0) {
850 break;
853 if (i == result->count) {
854 if (exist) {
855 torture_result(tctx, TORTURE_FAIL,
856 "failed: '%s' should exist with attribute %s\n",
857 name, attrib_string(result->list, attrib));
858 return false;
860 return true;
863 if (!exist) {
864 torture_result(tctx, TORTURE_FAIL,
865 "failed: '%s' should NOT exist (has attribute %s)\n",
866 name, attrib_string(result->list,
867 result->list[i].both_directory_info.attrib));
868 return false;
871 if ((result->list[i].both_directory_info.attrib&0xFFF) != attrib) {
872 torture_result(tctx, TORTURE_FAIL,
873 "failed: '%s' should have attribute 0x%x (has 0x%x)\n",
874 name, attrib, result->list[i].both_directory_info.attrib);
875 return false;
877 return true;
881 test what happens when the directory is modified during a search
883 static bool test_modify_search(struct torture_context *tctx,
884 struct smb2_tree *tree)
886 int num_files = 700;
887 struct multiple_result result;
888 union smb_setfileinfo sfinfo;
889 TALLOC_CTX *mem_ctx = talloc_new(tctx);
890 struct smb2_create create;
891 struct smb2_handle h;
892 struct smb2_find f;
893 union smb_search_data *d;
894 struct file_elem files[700] = {};
895 NTSTATUS status;
896 bool ret = true;
897 int i;
898 unsigned int count;
900 smb2_deltree(tree, DNAME);
902 status = torture_smb2_testdir(tree, DNAME, &h);
903 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
905 torture_comment(tctx, "Creating %d files\n", num_files);
907 ZERO_STRUCT(create);
908 create.in.desired_access = SEC_RIGHTS_FILE_ALL;
909 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
910 create.in.create_disposition = NTCREATEX_DISP_CREATE;
912 for (i = num_files-1; i >= 0; i--) {
913 files[i].name = talloc_asprintf(mem_ctx, "t%03d-%d.txt", i, i);
914 create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s",
915 DNAME, files[i].name);
916 status = smb2_create(tree, mem_ctx, &create);
917 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
918 smb2_util_close(tree, create.out.file.handle);
921 torture_comment(tctx, "pulling the first two files\n");
922 ZERO_STRUCT(result);
923 result.tctx = talloc_new(tctx);
925 ZERO_STRUCT(f);
926 f.in.file.handle = h;
927 f.in.pattern = "*";
928 f.in.continue_flags = SMB2_CONTINUE_FLAG_SINGLE;
929 f.in.max_response_size = 0x100;
930 f.in.level = SMB2_FIND_BOTH_DIRECTORY_INFO;
932 do {
933 status = smb2_find_level(tree, tree, &f, &count, &d);
934 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
935 break;
936 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
937 if (!fill_result(&result, d, count, f.in.level,
938 RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO)) {
939 ret = false;
940 goto done;
942 } while (result.count < 2);
944 torture_comment(tctx, "Changing attributes and deleting\n");
946 ZERO_STRUCT(create);
947 create.in.desired_access = SEC_RIGHTS_FILE_ALL;
948 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
949 create.in.create_disposition = NTCREATEX_DISP_CREATE;
951 files[num_files].name = talloc_asprintf(mem_ctx, "T003-03.txt.2");
952 create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s", DNAME,
953 files[num_files].name);
954 status = smb2_create(tree, mem_ctx, &create);
955 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
956 smb2_util_close(tree, create.out.file.handle);
958 ZERO_STRUCT(create);
959 create.in.desired_access = SEC_RIGHTS_FILE_ALL;
960 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
961 create.in.create_disposition = NTCREATEX_DISP_CREATE;
963 files[num_files + 1].name = talloc_asprintf(mem_ctx, "T013-13.txt.2");
964 create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s", DNAME,
965 files[num_files + 1].name);
966 status = smb2_create(tree, mem_ctx, &create);
967 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
968 smb2_util_close(tree, create.out.file.handle);
970 files[num_files + 2].name = talloc_asprintf(mem_ctx, "T013-13.txt.3");
971 status = smb2_create_complex_file(tree, DNAME "\\T013-13.txt.3", &h);
972 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
974 smb2_util_unlink(tree, DNAME "\\T014-14.txt");
975 smb2_util_setatr(tree, DNAME "\\T015-15.txt", FILE_ATTRIBUTE_HIDDEN);
976 smb2_util_setatr(tree, DNAME "\\T016-16.txt", FILE_ATTRIBUTE_NORMAL);
977 smb2_util_setatr(tree, DNAME "\\T017-17.txt", FILE_ATTRIBUTE_SYSTEM);
978 smb2_util_setatr(tree, DNAME "\\T018-18.txt", 0);
979 smb2_util_setatr(tree, DNAME "\\T039-39.txt", FILE_ATTRIBUTE_HIDDEN);
980 smb2_util_setatr(tree, DNAME "\\T000-0.txt", FILE_ATTRIBUTE_HIDDEN);
981 sfinfo.generic.level = RAW_SFILEINFO_DISPOSITION_INFORMATION;
982 sfinfo.generic.in.file.path = DNAME "\\T013-13.txt.3";
983 sfinfo.disposition_info.in.delete_on_close = 1;
984 status = smb2_composite_setpathinfo(tree, &sfinfo);
985 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
987 /* Reset the numfiles to include the new files and start the
988 * search from the beginning */
989 num_files = num_files + 2;
990 f.in.pattern = "*";
991 f.in.continue_flags = SMB2_CONTINUE_FLAG_RESTART;
992 result.count = 0;
994 do {
995 status = smb2_find_level(tree, tree, &f, &count, &d);
996 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
997 break;
998 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
999 if (!fill_result(&result, d, count, f.in.level,
1000 RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO)) {
1001 ret = false;
1002 goto done;
1004 f.in.continue_flags = 0;
1005 f.in.max_response_size = 4096;
1006 } while (count != 0);
1009 ret &= check_result(tctx, &result, "t039-39.txt", true, FILE_ATTRIBUTE_HIDDEN);
1010 ret &= check_result(tctx, &result, "t000-0.txt", true, FILE_ATTRIBUTE_HIDDEN);
1011 ret &= check_result(tctx, &result, "t014-14.txt", false, 0);
1012 ret &= check_result(tctx, &result, "t015-15.txt", true, FILE_ATTRIBUTE_HIDDEN);
1013 ret &= check_result(tctx, &result, "t016-16.txt", true, FILE_ATTRIBUTE_NORMAL);
1014 ret &= check_result(tctx, &result, "t017-17.txt", true, FILE_ATTRIBUTE_SYSTEM);
1015 ret &= check_result(tctx, &result, "t018-18.txt", true, FILE_ATTRIBUTE_ARCHIVE);
1016 ret &= check_result(tctx, &result, "t019-19.txt", true, FILE_ATTRIBUTE_ARCHIVE);
1017 ret &= check_result(tctx, &result, "T013-13.txt.2", true, FILE_ATTRIBUTE_ARCHIVE);
1018 ret &= check_result(tctx, &result, "T003-3.txt.2", false, 0);
1019 ret &= check_result(tctx, &result, "T013-13.txt.3", true, FILE_ATTRIBUTE_NORMAL);
1021 if (!ret) {
1022 for (i=0;i<result.count;i++) {
1023 torture_warning(tctx, "%s %s (0x%x)\n",
1024 result.list[i].both_directory_info.name.s,
1025 attrib_string(tctx,
1026 result.list[i].both_directory_info.attrib),
1027 result.list[i].both_directory_info.attrib);
1030 done:
1031 smb2_util_close(tree, h);
1032 smb2_deltree(tree, DNAME);
1033 talloc_free(mem_ctx);
1035 return ret;
1039 testing if directories always come back sorted
1041 static bool test_sorted(struct torture_context *tctx,
1042 struct smb2_tree *tree)
1044 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1045 const int num_files = 700;
1046 int i;
1047 struct file_elem files[700] = {};
1048 bool ret = true;
1049 NTSTATUS status;
1050 struct multiple_result result;
1051 struct smb2_handle h;
1053 torture_comment(tctx, "Testing if directories always come back "
1054 "sorted\n");
1055 status = populate_tree(tctx, mem_ctx, tree, files, num_files, &h);
1056 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1058 ZERO_STRUCT(result);
1059 result.tctx = tctx;
1061 status = multiple_smb2_search(tree, tctx, "*",
1062 SMB2_FIND_BOTH_DIRECTORY_INFO,
1063 RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
1064 SMB2_CONTINUE_FLAG_SINGLE,
1065 &result, &h);
1067 torture_assert_int_equal_goto(tctx, result.count, num_files, ret, done,
1068 "");
1070 for (i=0;i<num_files-1;i++) {
1071 const char *name1, *name2;
1072 name1 = result.list[i].both_directory_info.name.s;
1073 name2 = result.list[i+1].both_directory_info.name.s;
1074 if (strcasecmp_m(name1, name2) > 0) {
1075 torture_comment(tctx, "non-alphabetical order at entry "
1076 "%d '%s' '%s'\n", i, name1, name2);
1077 torture_comment(tctx,
1078 "Server does not produce sorted directory listings"
1079 "(not an error)\n");
1080 goto done;
1083 talloc_free(result.list);
1084 done:
1085 smb2_util_close(tree, h);
1086 smb2_deltree(tree, DNAME);
1087 talloc_free(mem_ctx);
1089 return ret;
1092 /* test the behavior of file_index field in the SMB2_FIND struct */
1093 static bool test_file_index(struct torture_context *tctx,
1094 struct smb2_tree *tree)
1096 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1097 const int num_files = 100;
1098 int resume_index = 4;
1099 int i;
1100 char *fname;
1101 bool ret = true;
1102 NTSTATUS status;
1103 struct multiple_result result;
1104 struct smb2_create create;
1105 struct smb2_find f;
1106 struct smb2_handle h;
1107 union smb_search_data *d;
1108 unsigned count;
1110 smb2_deltree(tree, DNAME);
1112 status = torture_smb2_testdir(tree, DNAME, &h);
1113 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1115 torture_comment(tctx, "Testing the behavior of file_index flag\n");
1117 ZERO_STRUCT(create);
1118 create.in.desired_access = SEC_RIGHTS_FILE_ALL;
1119 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1120 create.in.create_disposition = NTCREATEX_DISP_CREATE;
1121 for (i = num_files-1; i >= 0; i--) {
1122 fname = talloc_asprintf(mem_ctx, DNAME "\\file%u.txt", i);
1123 create.in.fname = fname;
1124 status = smb2_create(tree, mem_ctx, &create);
1125 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1126 talloc_free(fname);
1127 smb2_util_close(tree, create.out.file.handle);
1130 ZERO_STRUCT(result);
1131 result.tctx = tctx;
1133 ZERO_STRUCT(f);
1134 f.in.file.handle = h;
1135 f.in.pattern = "*";
1136 f.in.continue_flags = SMB2_CONTINUE_FLAG_SINGLE;
1137 f.in.max_response_size = 0x1000;
1138 f.in.level = SMB2_FIND_FULL_DIRECTORY_INFO;
1140 do {
1141 status = smb2_find_level(tree, tree, &f, &count, &d);
1142 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
1143 break;
1144 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1145 if (!fill_result(&result, d, count, f.in.level,
1146 RAW_SEARCH_DATA_FULL_DIRECTORY_INFO)) {
1147 ret = false;
1148 goto done;
1150 } while(result.count < 10);
1152 if (result.list[0].full_directory_info.file_index == 0) {
1153 torture_skip_goto(tctx, done,
1154 "Talking to a server that doesn't provide a "
1155 "file index.\nWindows servers using NTFS do "
1156 "not provide a file_index. Skipping test\n");
1157 } else {
1158 /* We are not talking to a Windows based server. Windows
1159 * servers using NTFS do not provide a file_index. Windows
1160 * servers using FAT do provide a file index, however in both
1161 * cases they do not honor a file index on a resume request.
1162 * See MS-FSCC <62> and MS-SMB2 <54> for more information. */
1164 /* Set the file_index flag to point to the fifth file from the
1165 * previous enumeration and try to start the subsequent
1166 * searches from that point */
1167 f.in.file_index =
1168 result.list[resume_index].full_directory_info.file_index;
1169 f.in.continue_flags = SMB2_CONTINUE_FLAG_INDEX;
1171 /* get the name of the next expected file */
1172 fname = talloc_asprintf(mem_ctx, DNAME "\\%s",
1173 result.list[resume_index].full_directory_info.name.s);
1175 ZERO_STRUCT(result);
1176 result.tctx = tctx;
1177 status = smb2_find_level(tree, tree, &f, &count, &d);
1178 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
1179 goto done;
1180 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1181 if (!fill_result(&result, d, count, f.in.level,
1182 RAW_SEARCH_DATA_FULL_DIRECTORY_INFO)) {
1183 ret = false;
1184 goto done;
1186 if (strcmp(fname,
1187 result.list[0].full_directory_info.name.s)) {
1188 torture_comment(tctx, "Next expected file: %s but the "
1189 "server returned %s\n", fname,
1190 result.list[0].full_directory_info.name.s);
1191 torture_comment(tctx,
1192 "Not an error. Resuming using a file "
1193 "index is an optional feature of the "
1194 "protocol.\n");
1195 goto done;
1198 done:
1199 smb2_util_close(tree, h);
1200 smb2_deltree(tree, DNAME);
1201 talloc_free(mem_ctx);
1203 return ret;
1207 * Tests directory enumeration in a directory containing >1000 files with
1208 * names of varying lengths.
1210 static bool test_large_files(struct torture_context *tctx,
1211 struct smb2_tree *tree)
1213 TALLOC_CTX *mem_ctx = talloc_new(tctx);
1214 const int num_files = 2000;
1215 int max_len = 200;
1216 /* These should be evenly divisible */
1217 int num_at_len = num_files / max_len;
1218 struct file_elem files[2000] = {};
1219 size_t len = 1;
1220 bool ret = true;
1221 NTSTATUS status;
1222 struct smb2_create create;
1223 struct smb2_find f;
1224 struct smb2_handle h;
1225 union smb_search_data *d;
1226 int i, j, file_count = 0;
1227 char **strs = NULL;
1228 unsigned count;
1230 torture_comment(tctx,
1231 "Testing directory enumeration in a directory with >1000 files\n");
1233 smb2_deltree(tree, DNAME);
1235 ZERO_STRUCT(create);
1236 create.in.desired_access = SEC_RIGHTS_DIR_ALL;
1237 create.in.create_options = NTCREATEX_OPTIONS_DIRECTORY;
1238 create.in.file_attributes = FILE_ATTRIBUTE_DIRECTORY;
1239 create.in.share_access = NTCREATEX_SHARE_ACCESS_READ |
1240 NTCREATEX_SHARE_ACCESS_WRITE |
1241 NTCREATEX_SHARE_ACCESS_DELETE;
1242 create.in.create_disposition = NTCREATEX_DISP_CREATE;
1243 create.in.fname = DNAME;
1245 status = smb2_create(tree, mem_ctx, &create);
1246 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1247 h = create.out.file.handle;
1249 ZERO_STRUCT(create);
1250 create.in.desired_access = SEC_RIGHTS_FILE_ALL;
1251 create.in.file_attributes = FILE_ATTRIBUTE_NORMAL;
1252 create.in.create_disposition = NTCREATEX_DISP_CREATE;
1254 for (i = 0; i < num_files; i++) {
1255 if (i % num_at_len == 0) {
1256 strs = generate_unique_strs(mem_ctx, len, num_at_len);
1257 len++;
1259 files[i].name = strs[i % num_at_len];
1260 create.in.fname = talloc_asprintf(mem_ctx, "%s\\%s",
1261 DNAME, files[i].name);
1262 status = smb2_create(tree, mem_ctx, &create);
1263 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1264 smb2_util_close(tree, create.out.file.handle);
1267 ZERO_STRUCT(f);
1268 f.in.file.handle = h;
1269 f.in.pattern = "*";
1270 f.in.max_response_size = 0x100;
1271 f.in.level = SMB2_FIND_BOTH_DIRECTORY_INFO;
1273 do {
1274 status = smb2_find_level(tree, tree, &f, &count, &d);
1275 if (NT_STATUS_EQUAL(status, STATUS_NO_MORE_FILES))
1276 break;
1277 torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1279 for (i = 0; i < count; i++) {
1280 bool expected;
1281 const char *found = d[i].both_directory_info.name.s;
1283 if (!strcmp(found, ".") || !strcmp(found, ".."))
1284 continue;
1286 expected = false;
1287 for (j = 0; j < 2000; j++) {
1288 if (!strcmp(files[j].name, found)) {
1289 files[j].found = true;
1290 expected = true;
1291 break;
1295 if (expected)
1296 continue;
1298 torture_result(tctx, TORTURE_FAIL,
1299 "(%s): didn't expect %s\n",
1300 __location__, found);
1301 ret = false;
1302 goto done;
1304 file_count = file_count + i;
1305 f.in.continue_flags = 0;
1306 f.in.max_response_size = 4096;
1307 } while (count != 0);
1309 torture_assert_int_equal_goto(tctx, file_count, num_files + 2, ret,
1310 done, "");
1312 for (i = 0; i < num_files; i++) {
1313 if (files[j].found)
1314 continue;
1316 torture_result(tctx, TORTURE_FAIL,
1317 "(%s): expected to find %s, but didn't\n",
1318 __location__, files[j].name);
1319 ret = false;
1320 goto done;
1322 done:
1323 smb2_util_close(tree, h);
1324 smb2_deltree(tree, DNAME);
1325 talloc_free(mem_ctx);
1327 return ret;
1330 struct torture_suite *torture_smb2_dir_init(void)
1332 struct torture_suite *suite =
1333 torture_suite_create(talloc_autofree_context(), "DIR");
1335 torture_suite_add_1smb2_test(suite, "FIND", test_find);
1336 torture_suite_add_1smb2_test(suite, "FIXED", test_fixed);
1337 torture_suite_add_1smb2_test(suite, "ONE", test_one_file);
1338 torture_suite_add_1smb2_test(suite, "MANY", test_many_files);
1339 torture_suite_add_1smb2_test(suite, "MODIFY", test_modify_search);
1340 torture_suite_add_1smb2_test(suite, "SORTED", test_sorted);
1341 torture_suite_add_1smb2_test(suite, "FILE-INDEX", test_file_index);
1342 torture_suite_add_1smb2_test(suite, "LARGE-FILES", test_large_files);
1343 suite->description = talloc_strdup(suite, "SMB2-DIR tests");
1345 return suite;