Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

source: branches/samba-3.5.x/source4/torture/smb2/dir.c

Visit:

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago
Samba 3.5.0: Initial import
File size: 43.5 KB

Line
1	/*
2	Unix SMB/CIFS implementation.
3
4	SMB2 dir list test suite
5
6	Copyright (C) Andrew Tridgell 2005
7	Copyright (C) Zachary Loafman 2009
8	Copyright (C) Aravind Srinivasan 2009
9
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.
14
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.
19
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/>.
22	*/
23
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"
31
32	#include "torture/torture.h"
33	#include "torture/smb2/proto.h"
34	#include "torture/util.h"
35
36	#include "system/filesys.h"
37
38	#define DNAME "smb2_dir"
39	#define NFILES 100
40
41	struct file_elem {
42	char *name;
43	bool found;
44	};
45
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)
52	{
53	struct smb2_create create;
54	char **strs = NULL;
55	NTSTATUS status;
56	bool ret;
57	int i;
58
59	smb2_deltree(tree, DNAME);
60
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;
70
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;
74
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;
79
80	strs = generate_unique_strs(mem_ctx, 8, nfiles);
81	if (strs == NULL) {
82	status = NT_STATUS_OBJECT_NAME_COLLISION;
83	goto done;
84	}
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);
92	}
93	done:
94	return status;
95	}
96
97	/*
98	test find continue
99	*/
100
101	static bool test_find(struct torture_context *tctx,
102	struct smb2_tree *tree)
103	{
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	uint_t count;
112	int i, j, file_count = 0;
113
114	status = populate_tree(tctx, mem_ctx, tree, files, NFILES, &h);
115
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;
122
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, "");
128
129	for (i = 0; i < count; i++) {
130	bool expected;
131	const char *found = d[i].both_directory_info.name.s;
132
133	if (!strcmp(found, ".") \|\| !strcmp(found, ".."))
134	continue;
135
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;
142	}
143	}
144
145	if (expected)
146	continue;
147
148	torture_result(tctx, TORTURE_FAIL,
149	"(%s): didn't expect %s\n",
150	__location__, found);
151	ret = false;
152	goto done;
153	}
154
155	file_count = file_count + i;
156	f.in.continue_flags = 0;
157	f.in.max_response_size = 4096;
158	} while (count != 0);
159
160	torture_assert_int_equal_goto(tctx, file_count, NFILES + 2, ret, done,
161	"");
162
163	for (i = 0; i < NFILES; i++) {
164	if (files[j].found)
165	continue;
166
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;
172	}
173
174	done:
175	smb2_deltree(tree, DNAME);
176	talloc_free(mem_ctx);
177
178	return ret;
179	}
180
181	/*
182	test fixed enumeration
183	*/
184
185	static bool test_fixed(struct torture_context *tctx,
186	struct smb2_tree *tree)
187	{
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	uint_t count;
197	int i;
198
199	status = populate_tree(tctx, mem_ctx, tree, files, NFILES, &h);
200
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;
210
211	status = smb2_create(tree, mem_ctx, &create);
212	torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
213	h2 = create.out.file.handle;
214
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;
221
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, "");
225
226	f.in.file.handle = h2;
227
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, "");
233
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);
238
239	if (!strcmp(found, ".") \|\| !strcmp(found, ".."))
240	continue;
241
242	status = smb2_util_unlink(tree, path);
243	torture_assert_ntstatus_ok_goto(tctx, status, ret, done,
244	"");
245
246	talloc_free(path);
247	}
248
249	f.in.continue_flags = 0;
250	f.in.max_response_size = 4096;
251	} while (count != 0);
252
253	/* Now finish h enumeration. */
254	f.in.file.handle = h;
255
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, "");
261
262	for (i = 0; i < count; i++) {
263	const char *found = d[i].both_directory_info.name.s;
264
265	if (!strcmp(found, ".") \|\| !strcmp(found, ".."))
266	continue;
267
268	torture_result(tctx, TORTURE_FAIL,
269	"(%s): didn't expect %s\n",
270	__location__, found);
271	ret = false;
272	goto done;
273	}
274
275	f.in.continue_flags = 0;
276	f.in.max_response_size = 4096;
277	} while (count != 0);
278
279	done:
280	smb2_util_close(tree, h);
281	smb2_util_close(tree, h2);
282	smb2_deltree(tree, DNAME);
283	talloc_free(mem_ctx);
284
285	return ret;
286	}
287
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),
302	},
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),
307	},
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),
312	},
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),
317	},
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),
322	},
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),
327	}
328	};
329
330	/*
331	extract the name from a smb_data structure and level
332	*/
333	static const char extract_name(union smb_search_data data,
334	uint8_t level,
335	enum smb_search_data_level data_level)
336	{
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);
342	}
343	}
344	return NULL;
345	}
346
347	/* find a level in the table by name */
348	static union smb_search_data find(const char name)
349	{
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;
355	}
356	}
357	return NULL;
358	}
359
360	static bool fill_level_data(TALLOC_CTX *mem_ctx,
361	union smb_search_data *data,
362	union smb_search_data *d,
363	uint_t count,
364	uint8_t level,
365	enum smb_search_data_level data_level)
366	{
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];
376	}
377	return true;
378	}
379
380
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	uint_t *count,
389	struct smb2_handle *h)
390	{
391	struct smb2_find f;
392	NTSTATUS status;
393
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;
400
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;
406	}
407
408	/*
409	basic testing of all File Information Classes using a single file
410	*/
411	static bool test_one_file(struct torture_context *tctx,
412	struct smb2_tree *tree)
413	{
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	uint_t 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;
424
425	status = torture_smb2_testdir(tree, DNAME, &h);
426	torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
427
428	status = smb2_create_complex_file(tree, DNAME "\\torture_search.txt",
429	&h2);
430	torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
431
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);
436
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, "");
442	}
443
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");
450
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");
456
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");
463
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; \
474	} \
475	}} while (0)
476
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; \
490	} \
491	}} while (0)
492
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; \
505	} \
506	}} while (0)
507
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; \
519	} \
520	}} while (0)
521
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; \
533	} \
534	}} while (0)
535
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; \
546	} \
547	}} while (0)
548
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; \
559	} \
560	}} while (0)
561
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);
568
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);
574
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);
580
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);
586
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);
592
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);
598
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);
604
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);
609
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);
616
617	CHECK_WSTR("SMB2_FIND_BOTH_DIRECTORY_INFO", both_directory_info, short_name, alt_info, alt_name_info, fname, STR_UNICODE);
618
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);
621
622	done:
623	smb2_util_close(tree, h);
624	smb2_util_unlink(tree, fname);
625	talloc_free(mem_ctx);
626
627	return ret;
628	}
629
630
631	struct multiple_result {
632	TALLOC_CTX *tctx;
633	int count;
634	union smb_search_data *list;
635	};
636
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)
642	{
643	int i;
644	const char *sname;
645	struct multiple_result data = (struct multiple_result )private_data;
646
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];
657	}
658	return true;
659	}
660
661	enum continue_type {CONT_SINGLE, CONT_INDEX, CONT_RESTART};
662
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)
671	{
672	struct smb2_find f;
673	bool ret = true;
674	uint_t count = 0;
675	union smb_search_data *d;
676	NTSTATUS status;
677	struct multiple_result result = (struct multiple_result )data;
678
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;
684
685	/* The search should start from the beginning everytime */
686	f.in.continue_flags = SMB2_CONTINUE_FLAG_RESTART;
687
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;
695	}
696
697	/*
698	* After the first iteration is complete set the CONTINUE
699	* FLAGS appropriately
700	*/
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;
714	}
715	} while (count != 0);
716	done:
717	return status;
718	}
719
720
721	static enum smb_search_data_level compare_data_level;
722	uint8_t level_sort;
723
724	static int search_compare(union smb_search_data *d1,
725	union smb_search_data *d2)
726	{
727	const char s1, s2;
728
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);
732	}
733
734	/*
735	basic testing of search calls using many files
736	*/
737	static bool test_many_files(struct torture_context *tctx,
738	struct smb2_tree *tree)
739	{
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}
771	};
772
773	smb2_deltree(tree, DNAME);
774	status = torture_smb2_testdir(tree, DNAME, &h);
775	torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
776
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;
782
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);
790	}
791
792	for (t=0;t<ARRAY_SIZE(search_types);t++) {
793	ZERO_STRUCT(result);
794	result.tctx = talloc_new(tctx);
795
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);
804
805	torture_assert_int_equal_goto(tctx, result.count, num_files,
806	ret, done, "");
807
808	compare_data_level = search_types[t].data_level;
809	level_sort = search_types[t].level;
810
811	qsort(result.list, result.count, sizeof(result.list[0]),
812	QSORT_CAST search_compare);
813
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);
825	}
826	talloc_free(result.tctx);
827	}
828
829	done:
830	smb2_util_close(tree, h);
831	smb2_deltree(tree, DNAME);
832	talloc_free(mem_ctx);
833
834	return ret;
835	}
836
837	/*
838	check an individual file result
839	*/
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)
845	{
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;
851	}
852	}
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;
859	}
860	return true;
861	}
862
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;
869	}
870
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;
876	}
877	return true;
878	}
879
880	/*
881	test what happens when the directory is modified during a search
882	*/
883	static bool test_modify_search(struct torture_context *tctx,
884	struct smb2_tree *tree)
885	{
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	uint_t count;
899
900	smb2_deltree(tree, DNAME);
901
902	status = torture_smb2_testdir(tree, DNAME, &h);
903	torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
904
905	torture_comment(tctx, "Creating %d files\n", num_files);
906
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;
911
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);
919	}
920
921	torture_comment(tctx, "pulling the first two files\n");
922	ZERO_STRUCT(result);
923	result.tctx = talloc_new(tctx);
924
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;
931
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;
941	}
942	} while (result.count < 2);
943
944	torture_comment(tctx, "Changing attributes and deleting\n");
945
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;
950
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);
957
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;
962
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);
969
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, "");
973
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, "");
986
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;
993
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;
1003	}
1004	f.in.continue_flags = 0;
1005	f.in.max_response_size = 4096;
1006	} while (count != 0);
1007
1008
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);
1020
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);
1028	}
1029	}
1030	done:
1031	smb2_util_close(tree, h);
1032	smb2_deltree(tree, DNAME);
1033	talloc_free(mem_ctx);
1034
1035	return ret;
1036	}
1037
1038	/*
1039	testing if directories always come back sorted
1040	*/
1041	static bool test_sorted(struct torture_context *tctx,
1042	struct smb2_tree *tree)
1043	{
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;
1052
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, "");
1057
1058	ZERO_STRUCT(result);
1059	result.tctx = tctx;
1060
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);
1066
1067	torture_assert_int_equal_goto(tctx, result.count, num_files, ret, done,
1068	"");
1069
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;
1081	}
1082	}
1083	talloc_free(result.list);
1084	done:
1085	smb2_util_close(tree, h);
1086	smb2_deltree(tree, DNAME);
1087	talloc_free(mem_ctx);
1088
1089	return ret;
1090	}
1091
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)
1095	{
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	int count;
1109
1110	smb2_deltree(tree, DNAME);
1111
1112	status = torture_smb2_testdir(tree, DNAME, &h);
1113	torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1114
1115	torture_comment(tctx, "Testing the behavior of file_index flag\n");
1116
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);
1128	}
1129
1130	ZERO_STRUCT(result);
1131	result.tctx = tctx;
1132
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;
1139
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;
1149	}
1150	} while(result.count < 10);
1151
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. */
1163
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;
1170
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);
1174
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;
1185	}
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;
1196	}
1197	}
1198	done:
1199	smb2_util_close(tree, h);
1200	smb2_deltree(tree, DNAME);
1201	talloc_free(mem_ctx);
1202
1203	return ret;
1204	}
1205
1206	/*
1207	* Tests directory enumeration in a directory containing >1000 files with
1208	* names of varying lengths.
1209	*/
1210	static bool test_large_files(struct torture_context *tctx,
1211	struct smb2_tree *tree)
1212	{
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 count, file_count = 0;
1227	char **strs = NULL;
1228	int i, j;
1229
1230	torture_comment(tctx,
1231	"Testing directory enumeration in a directory with >1000 files\n");
1232
1233	smb2_deltree(tree, DNAME);
1234
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;
1244
1245	status = smb2_create(tree, mem_ctx, &create);
1246	torture_assert_ntstatus_ok_goto(tctx, status, ret, done, "");
1247	h = create.out.file.handle;
1248
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;
1253
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++;
1258	}
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);
1265	}
1266
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;
1272
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, "");
1278
1279	for (i = 0; i < count; i++) {
1280	bool expected;
1281	const char *found = d[i].both_directory_info.name.s;
1282
1283	if (!strcmp(found, ".") \|\| !strcmp(found, ".."))
1284	continue;
1285
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;
1292	}
1293	}
1294
1295	if (expected)
1296	continue;
1297
1298	torture_result(tctx, TORTURE_FAIL,
1299	"(%s): didn't expect %s\n",
1300	__location__, found);
1301	ret = false;
1302	goto done;
1303	}
1304	file_count = file_count + i;
1305	f.in.continue_flags = 0;
1306	f.in.max_response_size = 4096;
1307	} while (count != 0);
1308
1309	torture_assert_int_equal_goto(tctx, file_count, num_files + 2, ret,
1310	done, "");
1311
1312	for (i = 0; i < num_files; i++) {
1313	if (files[j].found)
1314	continue;
1315
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;
1321	}
1322	done:
1323	smb2_util_close(tree, h);
1324	smb2_deltree(tree, DNAME);
1325	talloc_free(mem_ctx);
1326
1327	return ret;
1328	}
1329
1330	struct torture_suite *torture_smb2_dir_init(void)
1331	{
1332	struct torture_suite *suite =
1333	torture_suite_create(talloc_autofree_context(), "DIR");
1334
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");
1344
1345	return suite;
1346	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: