int dirlist_len;
int ff_searchcount; /* total received in 1 server trip */
int total_received; /* total received all together */
- enum smb_search_level info_level;
+ enum smb_search_data_level data_level;
const char *last_name; /* used to continue trans2 search */
struct smb_search_id id; /* used for old-style search */
};
/****************************************************************************
Interpret a long filename structure.
****************************************************************************/
-static BOOL interpret_long_filename(enum smb_search_level level,
+static BOOL interpret_long_filename(enum smb_search_data_level level,
union smb_search_data *info,
struct clilist_file_info *finfo)
{
ZERO_STRUCTP(finfo);
switch (level) {
- case RAW_SEARCH_STANDARD:
+ case RAW_SEARCH_DATA_STANDARD:
finfo->size = info->standard.size;
finfo->mtime = info->standard.write_time;
finfo->attrib = info->standard.attrib;
finfo->short_name = info->standard.name.s;
break;
- case RAW_SEARCH_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
finfo->size = info->both_directory_info.size;
finfo->mtime = nt_time_to_unix(info->both_directory_info.write_time);
finfo->attrib = info->both_directory_info.attrib;
state->dirlist = tdl;
state->dirlist_len++;
- interpret_long_filename(state->info_level, file, &state->dirlist[state->total_received]);
+ interpret_long_filename(state->data_level, file, &state->dirlist[state->total_received]);
state->last_name = state->dirlist[state->total_received].name;
state->total_received++;
}
int smbcli_list_new(struct smbcli_tree *tree, const char *Mask, uint16_t attribute,
- enum smb_search_level level,
+ enum smb_search_data_level level,
void (*fn)(struct clilist_file_info *, const char *, void *),
void *caller_state)
{
state.dirlist = talloc_new(state.mem_ctx);
mask = talloc_strdup(state.mem_ctx, Mask);
- if (level == RAW_SEARCH_GENERIC) {
+ if (level == RAW_SEARCH_DATA_GENERIC) {
if (tree->session->transport->negotiate.capabilities & CAP_NT_SMBS) {
- level = RAW_SEARCH_BOTH_DIRECTORY_INFO;
+ level = RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO;
} else {
- level = RAW_SEARCH_STANDARD;
+ level = RAW_SEARCH_DATA_STANDARD;
}
}
- state.info_level = level;
+ state.data_level = level;
while (1) {
state.ff_searchcount = 0;
if (first) {
NTSTATUS status;
- first_parms.t2ffirst.level = state.info_level;
+ first_parms.t2ffirst.level = RAW_SEARCH_TRANS2;
+ first_parms.t2ffirst.data_level = state.data_level;
first_parms.t2ffirst.in.max_count = max_matches;
first_parms.t2ffirst.in.search_attrib = attribute;
first_parms.t2ffirst.in.pattern = mask;
} else {
NTSTATUS status;
- next_parms.t2fnext.level = state.info_level;
+ next_parms.t2fnext.level = RAW_SEARCH_TRANS2;
+ next_parms.t2fnext.data_level = state.data_level;
next_parms.t2fnext.in.max_count = max_matches;
next_parms.t2fnext.in.last_name = state.last_name;
next_parms.t2fnext.in.handle = ff_dir_handle;
Interpret a short filename structure.
The length of the structure is returned.
****************************************************************************/
-static BOOL interpret_short_filename(int level,
- union smb_search_data *info,
- struct clilist_file_info *finfo)
+static BOOL interpret_short_filename(enum smb_search_data_level level,
+ union smb_search_data *info,
+ struct clilist_file_info *finfo)
{
struct clilist_file_info finfo2;
if (!finfo) finfo = &finfo2;
ZERO_STRUCTP(finfo);
+
+ switch (level) {
+ case RAW_SEARCH_DATA_SEARCH:
+ finfo->mtime = info->search.write_time;
+ finfo->size = info->search.size;
+ finfo->attrib = info->search.attrib;
+ finfo->name = info->search.name;
+ finfo->short_name = info->search.name;
+ break;
+
+ default:
+ DEBUG(0,("Unhandled level %d in interpret_short_filename\n", (int)level));
+ return False;
+ }
- finfo->mtime = info->search.write_time;
- finfo->size = info->search.size;
- finfo->attrib = info->search.attrib;
- finfo->name = info->search.name;
- finfo->short_name = info->search.name;
return True;
}
state->dirlist = tdl;
state->dirlist_len++;
- interpret_short_filename(state->info_level, file, &state->dirlist[state->total_received]);
+ interpret_short_filename(state->data_level, file, &state->dirlist[state->total_received]);
state->total_received++;
state->ff_searchcount++;
NTSTATUS status;
first_parms.search_first.level = RAW_SEARCH_SEARCH;
+ first_parms.search_first.data_level = RAW_SEARCH_DATA_SEARCH;
first_parms.search_first.in.max_count = num_asked;
first_parms.search_first.in.search_attrib = attribute;
first_parms.search_first.in.pattern = mask;
NTSTATUS status;
next_parms.search_next.level = RAW_SEARCH_SEARCH;
+ next_parms.search_next.data_level = RAW_SEARCH_DATA_SEARCH;
next_parms.search_next.in.max_count = num_asked;
next_parms.search_next.in.search_attrib = attribute;
next_parms.search_next.in.id = state.id;
{
if (tree->session->transport->negotiate.protocol <= PROTOCOL_LANMAN1)
return smbcli_list_old(tree, Mask, attribute, fn, state);
- return smbcli_list_new(tree, Mask, attribute, RAW_SEARCH_GENERIC, fn, state);
+ return smbcli_list_new(tree, Mask, attribute, RAW_SEARCH_DATA_GENERIC, fn, state);
}
} out;
};
-enum smb_search_level {RAW_SEARCH_GENERIC = 0xF000,
- RAW_SEARCH_SEARCH, /* SMBsearch */
- RAW_SEARCH_FFIRST, /* SMBffirst */
- RAW_SEARCH_FUNIQUE, /* SMBfunique */
- RAW_SEARCH_SMB2, /* SMB2 Find */
- RAW_SEARCH_STANDARD = SMB_FIND_STANDARD,
- RAW_SEARCH_EA_SIZE = SMB_FIND_EA_SIZE,
- RAW_SEARCH_EA_LIST = SMB_FIND_EA_LIST,
- RAW_SEARCH_DIRECTORY_INFO = SMB_FIND_DIRECTORY_INFO,
- RAW_SEARCH_FULL_DIRECTORY_INFO = SMB_FIND_FULL_DIRECTORY_INFO,
- RAW_SEARCH_NAME_INFO = SMB_FIND_NAME_INFO,
- RAW_SEARCH_BOTH_DIRECTORY_INFO = SMB_FIND_BOTH_DIRECTORY_INFO,
- RAW_SEARCH_ID_FULL_DIRECTORY_INFO = SMB_FIND_ID_FULL_DIRECTORY_INFO,
- RAW_SEARCH_ID_BOTH_DIRECTORY_INFO = SMB_FIND_ID_BOTH_DIRECTORY_INFO,
- RAW_SEARCH_UNIX_INFO = SMB_FIND_UNIX_INFO};
+enum smb_search_level {
+ RAW_SEARCH_SEARCH, /* SMBsearch */
+ RAW_SEARCH_FFIRST, /* SMBffirst */
+ RAW_SEARCH_FUNIQUE, /* SMBfunique */
+ RAW_SEARCH_TRANS2, /* SMBtrans2 */
+ RAW_SEARCH_SMB2 /* SMB2 Find */
+};
+enum smb_search_data_level {
+ RAW_SEARCH_DATA_GENERIC = 0x10000, /* only used in the smbcli_ code */
+ RAW_SEARCH_DATA_SEARCH,
+ RAW_SEARCH_DATA_STANDARD = SMB_FIND_STANDARD,
+ RAW_SEARCH_DATA_EA_SIZE = SMB_FIND_EA_SIZE,
+ RAW_SEARCH_DATA_EA_LIST = SMB_FIND_EA_LIST,
+ RAW_SEARCH_DATA_DIRECTORY_INFO = SMB_FIND_DIRECTORY_INFO,
+ RAW_SEARCH_DATA_FULL_DIRECTORY_INFO = SMB_FIND_FULL_DIRECTORY_INFO,
+ RAW_SEARCH_DATA_NAME_INFO = SMB_FIND_NAME_INFO,
+ RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO = SMB_FIND_BOTH_DIRECTORY_INFO,
+ RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO = SMB_FIND_ID_FULL_DIRECTORY_INFO,
+ RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO = SMB_FIND_ID_BOTH_DIRECTORY_INFO,
+ RAW_SEARCH_DATA_UNIX_INFO = SMB_FIND_UNIX_INFO
+};
/* union for file search */
union smb_search_first {
struct {
enum smb_search_level level;
+ enum smb_search_data_level data_level;
} generic;
/* search (old) findfirst interface.
Also used for ffirst and funique. */
struct {
enum smb_search_level level;
+ enum smb_search_data_level data_level;
struct {
uint16_t max_count;
/* trans2 findfirst interface */
struct {
enum smb_search_level level;
+ enum smb_search_data_level data_level;
struct {
uint16_t search_attrib;
} t2ffirst;
/*
- SMB2 uses different level numbers for the same old SMB search levels
+ SMB2 uses different level numbers for the same old SMB trans2 search levels
*/
#define SMB2_FIND_DIRECTORY_INFO 0x01
#define SMB2_FIND_FULL_DIRECTORY_INFO 0x02
/* SMB2 Find */
struct smb2_find {
enum smb_search_level level;
+ enum smb_search_data_level data_level;
struct {
union smb_handle file;
uint32_t unknown; /* perhaps a continue token? */
/* struct smb2_handle handle; */
/* uint16_t pattern_ofs; */
- /* uint32_t pattern_size; */
+ /* uint16_t pattern_size; */
uint32_t max_response_size;
/* dynamic body */
union smb_search_next {
struct {
enum smb_search_level level;
+ enum smb_search_data_level data_level;
} generic;
/* search (old) findnext interface. Also used
for ffirst when continuing */
struct {
enum smb_search_level level;
+ enum smb_search_data_level data_level;
struct {
uint16_t max_count;
/* trans2 findnext interface */
struct {
enum smb_search_level level;
+ enum smb_search_data_level data_level;
struct {
uint16_t handle;
/* union for search reply file data */
union smb_search_data {
- /* search (old) findfirst */
+ /*
+ * search (old) findfirst
+ * RAW_SEARCH_DATA_SEARCH
+ */
struct {
uint16_t attrib;
time_t write_time;
struct smb_search_id id;
const char *name;
} search;
-
- /* trans2 findfirst RAW_SEARCH_STANDARD level */
+
+ /* trans2 findfirst RAW_SEARCH_DATA_STANDARD level */
struct {
uint32_t resume_key;
time_t create_time;
struct smb_wire_string name;
} standard;
- /* trans2 findfirst RAW_SEARCH_EA_SIZE level */
+ /* trans2 findfirst RAW_SEARCH_DATA_EA_SIZE level */
struct {
uint32_t resume_key;
time_t create_time;
struct smb_wire_string name;
} ea_size;
- /* trans2 findfirst RAW_SEARCH_EA_LIST level */
+ /* trans2 findfirst RAW_SEARCH_DATA_EA_LIST level */
struct {
uint32_t resume_key;
time_t create_time;
struct smb_wire_string name;
} ea_list;
- /* RAW_SEARCH_DIRECTORY_INFO interface */
+ /* RAW_SEARCH_DATA_DIRECTORY_INFO interface */
struct {
uint32_t file_index;
NTTIME create_time;
struct smb_wire_string name;
} directory_info;
- /* RAW_SEARCH_FULL_DIRECTORY_INFO interface */
+ /* RAW_SEARCH_DATA_FULL_DIRECTORY_INFO interface */
struct {
uint32_t file_index;
NTTIME create_time;
struct smb_wire_string name;
} full_directory_info;
- /* RAW_SEARCH_NAME_INFO interface */
+ /* RAW_SEARCH_DATA_NAME_INFO interface */
struct {
uint32_t file_index;
struct smb_wire_string name;
} name_info;
- /* RAW_SEARCH_BOTH_DIRECTORY_INFO interface */
+ /* RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO interface */
struct {
uint32_t file_index;
NTTIME create_time;
struct smb_wire_string name;
} both_directory_info;
- /* RAW_SEARCH_ID_FULL_DIRECTORY_INFO interface */
+ /* RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO interface */
struct {
uint32_t file_index;
NTTIME create_time;
struct smb_wire_string name;
} id_full_directory_info;
- /* RAW_SEARCH_ID_BOTH_DIRECTORY_INFO interface */
+ /* RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO interface */
struct {
uint32_t file_index;
NTTIME create_time;
struct smb_wire_string name;
} id_both_directory_info;
- /* RAW_SEARCH_UNIX_INFO interface */
+ /* RAW_SEARCH_DATA_UNIX_INFO interface */
struct {
uint32_t file_index;
uint64_t size;
static NTSTATUS smb_raw_search_first_blob(struct smbcli_tree *tree,
TALLOC_CTX *mem_ctx, /* used to allocate output blobs */
union smb_search_first *io,
- uint16_t info_level,
DATA_BLOB *out_param_blob,
DATA_BLOB *out_data_blob)
{
tp.in.max_data = 0xFFFF;
tp.in.setup = &setup;
- if (info_level == RAW_SEARCH_EA_LIST) {
+ if (io->t2ffirst.level != RAW_SEARCH_TRANS2) {
+ return NT_STATUS_INVALID_LEVEL;
+ }
+
+ if (io->t2ffirst.data_level >= RAW_SEARCH_DATA_GENERIC) {
+ return NT_STATUS_INVALID_LEVEL;
+ }
+
+ if (io->t2ffirst.data_level == RAW_SEARCH_DATA_EA_LIST) {
if (!ea_push_name_list(mem_ctx,
&tp.in.data,
io->t2ffirst.in.num_names,
return NT_STATUS_NO_MEMORY;
}
}
-
+
tp.in.params = data_blob_talloc(mem_ctx, NULL, 12);
if (!tp.in.params.data) {
return NT_STATUS_NO_MEMORY;
SSVAL(tp.in.params.data, 0, io->t2ffirst.in.search_attrib);
SSVAL(tp.in.params.data, 2, io->t2ffirst.in.max_count);
SSVAL(tp.in.params.data, 4, io->t2ffirst.in.flags);
- SSVAL(tp.in.params.data, 6, info_level);
+ SSVAL(tp.in.params.data, 6, io->t2ffirst.data_level);
SIVAL(tp.in.params.data, 8, io->t2ffirst.in.storage_type);
smbcli_blob_append_string(tree->session, mem_ctx, &tp.in.params,
static NTSTATUS smb_raw_search_next_blob(struct smbcli_tree *tree,
TALLOC_CTX *mem_ctx,
union smb_search_next *io,
- uint16_t info_level,
DATA_BLOB *out_param_blob,
DATA_BLOB *out_data_blob)
{
tp.in.max_data = 0xFFFF;
tp.in.setup = &setup;
- if (info_level == RAW_SEARCH_EA_LIST) {
+ if (io->t2fnext.level != RAW_SEARCH_TRANS2) {
+ return NT_STATUS_INVALID_LEVEL;
+ }
+
+ if (io->t2fnext.data_level >= RAW_SEARCH_DATA_GENERIC) {
+ return NT_STATUS_INVALID_LEVEL;
+ }
+
+ if (io->t2fnext.data_level == RAW_SEARCH_DATA_EA_LIST) {
if (!ea_push_name_list(mem_ctx,
&tp.in.data,
io->t2fnext.in.num_names,
}
SSVAL(tp.in.params.data, 0, io->t2fnext.in.handle);
- SSVAL(tp.in.params.data, 2, io->t2fnext.in.max_count);
- SSVAL(tp.in.params.data, 4, info_level);
+ SSVAL(tp.in.params.data, 2, io->t2fnext.in.max_count);
+ SSVAL(tp.in.params.data, 4, io->t2fnext.data_level);
SIVAL(tp.in.params.data, 6, io->t2fnext.in.resume_key);
SSVAL(tp.in.params.data, 10, io->t2fnext.in.flags);
SMB2
*/
NTSTATUS smb_raw_search_common(TALLOC_CTX *mem_ctx,
- enum smb_search_level level,
+ enum smb_search_data_level level,
const DATA_BLOB *blob,
union smb_search_data *data,
uint_t *next_ofs,
}
switch (level) {
- case RAW_SEARCH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_DIRECTORY_INFO:
if (blen < 65) return NT_STATUS_INFO_LENGTH_MISMATCH;
data->directory_info.file_index = IVAL(blob->data, 4);
data->directory_info.create_time = smbcli_pull_nttime(blob->data, 8);
}
return NT_STATUS_OK;
- case RAW_SEARCH_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
if (blen < 69) return NT_STATUS_INFO_LENGTH_MISMATCH;
data->full_directory_info.file_index = IVAL(blob->data, 4);
data->full_directory_info.create_time = smbcli_pull_nttime(blob->data, 8);
}
return NT_STATUS_OK;
- case RAW_SEARCH_NAME_INFO:
+ case RAW_SEARCH_DATA_NAME_INFO:
if (blen < 13) return NT_STATUS_INFO_LENGTH_MISMATCH;
data->name_info.file_index = IVAL(blob->data, 4);
len = smbcli_blob_pull_string(NULL, mem_ctx, blob,
return NT_STATUS_OK;
- case RAW_SEARCH_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
if (blen < 95) return NT_STATUS_INFO_LENGTH_MISMATCH;
data->both_directory_info.file_index = IVAL(blob->data, 4);
data->both_directory_info.create_time = smbcli_pull_nttime(blob->data, 8);
return NT_STATUS_OK;
- case RAW_SEARCH_ID_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
if (blen < 81) return NT_STATUS_INFO_LENGTH_MISMATCH;
data->id_full_directory_info.file_index = IVAL(blob->data, 4);
data->id_full_directory_info.create_time = smbcli_pull_nttime(blob->data, 8);
}
return NT_STATUS_OK;
- case RAW_SEARCH_ID_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
if (blen < 105) return NT_STATUS_INFO_LENGTH_MISMATCH;
data->id_both_directory_info.file_index = IVAL(blob->data, 4);
data->id_both_directory_info.create_time = smbcli_pull_nttime(blob->data, 8);
*/
static int parse_trans2_search(struct smbcli_tree *tree,
TALLOC_CTX *mem_ctx,
- enum smb_search_level level,
+ enum smb_search_data_level level,
uint16_t flags,
DATA_BLOB *blob,
union smb_search_data *data)
NTSTATUS status;
switch (level) {
- case RAW_SEARCH_GENERIC:
- case RAW_SEARCH_SEARCH:
- case RAW_SEARCH_FFIRST:
- case RAW_SEARCH_FUNIQUE:
- case RAW_SEARCH_SMB2:
+ case RAW_SEARCH_DATA_GENERIC:
+ case RAW_SEARCH_DATA_SEARCH:
/* handled elsewhere */
return -1;
- case RAW_SEARCH_STANDARD:
+ case RAW_SEARCH_DATA_STANDARD:
if (flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
if (blob->length < 4) return -1;
data->standard.resume_key = IVAL(blob->data, 0);
22, 23, STR_LEN8BIT | STR_TERMINATE | STR_LEN_NOTERM);
return len + 23;
- case RAW_SEARCH_EA_SIZE:
+ case RAW_SEARCH_DATA_EA_SIZE:
if (flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
if (blob->length < 4) return -1;
data->ea_size.resume_key = IVAL(blob->data, 0);
26, 27, STR_LEN8BIT | STR_TERMINATE | STR_NOALIGN);
return len + 27 + 1;
- case RAW_SEARCH_EA_LIST:
+ case RAW_SEARCH_DATA_EA_LIST:
if (flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
if (blob->length < 4) return -1;
data->ea_list.resume_key = IVAL(blob->data, 0);
STR_LEN8BIT | STR_NOALIGN);
return len + ea_size + 23 + 1;
- case RAW_SEARCH_UNIX_INFO:
+ case RAW_SEARCH_DATA_UNIX_INFO:
if (blob->length < 109) return -1;
ofs = IVAL(blob->data, 0);
data->unix_info.file_index = IVAL(blob->data, 4);
}
return ofs;
- case RAW_SEARCH_DIRECTORY_INFO:
- case RAW_SEARCH_FULL_DIRECTORY_INFO:
- case RAW_SEARCH_NAME_INFO:
- case RAW_SEARCH_BOTH_DIRECTORY_INFO:
- case RAW_SEARCH_ID_FULL_DIRECTORY_INFO:
- case RAW_SEARCH_ID_BOTH_DIRECTORY_INFO: {
+ case RAW_SEARCH_DATA_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_NAME_INFO:
+ case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO: {
uint_t str_flags = STR_UNICODE;
if (!(tree->session->transport->negotiate.capabilities & CAP_UNICODE)) {
str_flags = STR_ASCII;
****************************************************************************/
static NTSTATUS smb_raw_t2search_backend(struct smbcli_tree *tree,
TALLOC_CTX *mem_ctx,
- enum smb_search_level level,
+ enum smb_search_data_level level,
uint16_t flags,
int16_t count,
DATA_BLOB *blob,
union smb_search_first *io, void *private,
BOOL (*callback)(void *private, union smb_search_data *file))
{
- uint16_t info_level = 0;
DATA_BLOB p_blob, d_blob;
NTSTATUS status;
-
- if (io->generic.level == RAW_SEARCH_SEARCH ||
- io->generic.level == RAW_SEARCH_FFIRST ||
- io->generic.level == RAW_SEARCH_FUNIQUE) {
+
+ switch (io->generic.level) {
+ case RAW_SEARCH_SEARCH:
+ case RAW_SEARCH_FFIRST:
+ case RAW_SEARCH_FUNIQUE:
return smb_raw_search_first_old(tree, mem_ctx, io, private, callback);
- }
- if (io->generic.level >= RAW_SEARCH_GENERIC) {
+
+ case RAW_SEARCH_TRANS2:
+ break;
+
+ case RAW_SEARCH_SMB2:
return NT_STATUS_INVALID_LEVEL;
}
- info_level = (uint16_t)io->generic.level;
status = smb_raw_search_first_blob(tree, mem_ctx,
- io, info_level, &p_blob, &d_blob);
+ io, &p_blob, &d_blob);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
io->t2ffirst.out.handle = SVAL(p_blob.data, 0);
io->t2ffirst.out.count = SVAL(p_blob.data, 2);
io->t2ffirst.out.end_of_search = SVAL(p_blob.data, 4);
-
+
status = smb_raw_t2search_backend(tree, mem_ctx,
- io->generic.level,
+ io->generic.data_level,
io->t2ffirst.in.flags, io->t2ffirst.out.count,
&d_blob, private, callback);
union smb_search_next *io, void *private,
BOOL (*callback)(void *private, union smb_search_data *file))
{
- uint16_t info_level = 0;
DATA_BLOB p_blob, d_blob;
NTSTATUS status;
- if (io->generic.level == RAW_SEARCH_SEARCH ||
- io->generic.level == RAW_SEARCH_FFIRST) {
+ switch (io->generic.level) {
+ case RAW_SEARCH_SEARCH:
+ case RAW_SEARCH_FFIRST:
return smb_raw_search_next_old(tree, mem_ctx, io, private, callback);
- }
- if (io->generic.level >= RAW_SEARCH_GENERIC) {
+
+ case RAW_SEARCH_FUNIQUE:
+ return NT_STATUS_INVALID_LEVEL;
+
+ case RAW_SEARCH_TRANS2:
+ break;
+
+ case RAW_SEARCH_SMB2:
return NT_STATUS_INVALID_LEVEL;
}
- info_level = (uint16_t)io->generic.level;
status = smb_raw_search_next_blob(tree, mem_ctx,
- io, info_level, &p_blob, &d_blob);
+ io, &p_blob, &d_blob);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
io->t2fnext.out.end_of_search = SVAL(p_blob.data, 2);
status = smb_raw_t2search_backend(tree, mem_ctx,
- io->generic.level,
+ io->generic.data_level,
io->t2fnext.in.flags, io->t2fnext.out.count,
&d_blob, private, callback);
struct smb2_find f;
NTSTATUS status;
DATA_BLOB b;
- enum smb_search_level smb_level;
+ enum smb_search_data_level smb_level;
uint_t next_ofs=0;
switch (level) {
case SMB2_FIND_DIRECTORY_INFO:
- smb_level = RAW_SEARCH_DIRECTORY_INFO;
+ smb_level = RAW_SEARCH_DATA_DIRECTORY_INFO;
break;
case SMB2_FIND_FULL_DIRECTORY_INFO:
- smb_level = RAW_SEARCH_FULL_DIRECTORY_INFO;
+ smb_level = RAW_SEARCH_DATA_FULL_DIRECTORY_INFO;
break;
case SMB2_FIND_BOTH_DIRECTORY_INFO:
- smb_level = RAW_SEARCH_BOTH_DIRECTORY_INFO;
+ smb_level = RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO;
break;
case SMB2_FIND_NAME_INFO:
- smb_level = RAW_SEARCH_NAME_INFO;
+ smb_level = RAW_SEARCH_DATA_NAME_INFO;
break;
case SMB2_FIND_ID_FULL_DIRECTORY_INFO:
- smb_level = RAW_SEARCH_ID_FULL_DIRECTORY_INFO;
+ smb_level = RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO;
break;
case SMB2_FIND_ID_BOTH_DIRECTORY_INFO:
- smb_level = RAW_SEARCH_ID_BOTH_DIRECTORY_INFO;
+ smb_level = RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO;
break;
default:
return NT_STATUS_INVALID_INFO_CLASS;
union smb_search_first *io = req->async_states->private_data;
switch (io->generic.level) {
- case RAW_SEARCH_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_TRANS2:
if (NT_STATUS_IS_ERR(req->async_states->status)) {
ZERO_STRUCT(io->t2ffirst.out);
}
nbench_log(req, "FIND_FIRST \"%s\" %d %d %d %s\n",
io->t2ffirst.in.pattern,
- io->generic.level,
+ io->t2ffirst.data_level,
io->t2ffirst.in.max_count,
io->t2ffirst.out.count,
get_nt_error_c_code(req->async_states->status));
fill in a single search result for a given info level
*/
static NTSTATUS fill_search_info(struct pvfs_state *pvfs,
- enum smb_search_level level,
+ enum smb_search_data_level level,
const char *unix_path,
const char *fname,
struct pvfs_search_state *search,
}
switch (level) {
- case RAW_SEARCH_SEARCH:
- case RAW_SEARCH_FFIRST:
- case RAW_SEARCH_FUNIQUE:
+ case RAW_SEARCH_DATA_SEARCH:
shortname = pvfs_short_name(pvfs, name, name);
file->search.attrib = name->dos.attrib;
file->search.write_time = nt_time_to_unix(name->dos.write_time);
file->search.id.client_cookie = 0;
return NT_STATUS_OK;
- case RAW_SEARCH_STANDARD:
+ case RAW_SEARCH_DATA_STANDARD:
file->standard.resume_key = dir_index;
file->standard.create_time = nt_time_to_unix(name->dos.create_time);
file->standard.access_time = nt_time_to_unix(name->dos.access_time);
file->standard.name.s = fname;
return NT_STATUS_OK;
- case RAW_SEARCH_EA_SIZE:
+ case RAW_SEARCH_DATA_EA_SIZE:
file->ea_size.resume_key = dir_index;
file->ea_size.create_time = nt_time_to_unix(name->dos.create_time);
file->ea_size.access_time = nt_time_to_unix(name->dos.access_time);
file->ea_size.name.s = fname;
return NT_STATUS_OK;
- case RAW_SEARCH_EA_LIST:
+ case RAW_SEARCH_DATA_EA_LIST:
file->ea_list.resume_key = dir_index;
file->ea_list.create_time = nt_time_to_unix(name->dos.create_time);
file->ea_list.access_time = nt_time_to_unix(name->dos.access_time);
search->ea_names,
&file->ea_list.eas);
- case RAW_SEARCH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_DIRECTORY_INFO:
file->directory_info.file_index = dir_index;
file->directory_info.create_time = name->dos.create_time;
file->directory_info.access_time = name->dos.access_time;
file->directory_info.name.s = fname;
return NT_STATUS_OK;
- case RAW_SEARCH_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
file->full_directory_info.file_index = dir_index;
file->full_directory_info.create_time = name->dos.create_time;
file->full_directory_info.access_time = name->dos.access_time;
file->full_directory_info.name.s = fname;
return NT_STATUS_OK;
- case RAW_SEARCH_NAME_INFO:
+ case RAW_SEARCH_DATA_NAME_INFO:
file->name_info.file_index = dir_index;
file->name_info.name.s = fname;
return NT_STATUS_OK;
- case RAW_SEARCH_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
file->both_directory_info.file_index = dir_index;
file->both_directory_info.create_time = name->dos.create_time;
file->both_directory_info.access_time = name->dos.access_time;
file->both_directory_info.name.s = fname;
return NT_STATUS_OK;
- case RAW_SEARCH_ID_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
file->id_full_directory_info.file_index = dir_index;
file->id_full_directory_info.create_time = name->dos.create_time;
file->id_full_directory_info.access_time = name->dos.access_time;
file->id_full_directory_info.name.s = fname;
return NT_STATUS_OK;
- case RAW_SEARCH_ID_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
file->id_both_directory_info.file_index = dir_index;
file->id_both_directory_info.create_time = name->dos.create_time;
file->id_both_directory_info.access_time = name->dos.access_time;
file->id_both_directory_info.name.s = fname;
return NT_STATUS_OK;
- case RAW_SEARCH_GENERIC:
+ case RAW_SEARCH_DATA_GENERIC:
break;
}
static NTSTATUS pvfs_search_fill(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
uint_t max_count,
struct pvfs_search_state *search,
- enum smb_search_level level,
+ enum smb_search_data_level level,
uint_t *reply_count,
void *search_private,
BOOL (*callback)(void *, union smb_search_data *))
talloc_set_destructor(search, pvfs_search_destructor);
- status = pvfs_search_fill(pvfs, req, io->search_first.in.max_count, search, io->generic.level,
+ status = pvfs_search_fill(pvfs, req, io->search_first.in.max_count, search, io->generic.data_level,
&reply_count, search_private, callback);
if (!NT_STATUS_IS_OK(status)) {
return status;
search->last_used = time(NULL);
dir = search->dir;
- status = pvfs_search_fill(pvfs, req, max_count, search, io->generic.level,
+ status = pvfs_search_fill(pvfs, req, max_count, search, io->generic.data_level,
&reply_count, search_private, callback);
if (!NT_STATUS_IS_OK(status)) {
return status;
/*
list files in a directory matching a wildcard pattern
*/
-NTSTATUS pvfs_search_first(struct ntvfs_module_context *ntvfs,
- struct ntvfs_request *req, union smb_search_first *io,
- void *search_private,
- BOOL (*callback)(void *, union smb_search_data *))
+static NTSTATUS pvfs_search_first_trans2(struct ntvfs_module_context *ntvfs,
+ struct ntvfs_request *req, union smb_search_first *io,
+ void *search_private,
+ BOOL (*callback)(void *, union smb_search_data *))
{
struct pvfs_dir *dir;
struct pvfs_state *pvfs = ntvfs->private_data;
struct pvfs_filename *name;
int id;
- if (io->generic.level >= RAW_SEARCH_SEARCH) {
- return pvfs_search_first_old(ntvfs, req, io, search_private, callback);
- }
-
search_attrib = io->t2ffirst.in.search_attrib;
pattern = io->t2ffirst.in.pattern;
max_count = io->t2ffirst.in.max_count;
DLIST_ADD(pvfs->search.list, search);
talloc_set_destructor(search, pvfs_search_destructor);
- status = pvfs_search_fill(pvfs, req, max_count, search, io->generic.level,
+ status = pvfs_search_fill(pvfs, req, max_count, search, io->generic.data_level,
&reply_count, search_private, callback);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
/* continue a search */
-NTSTATUS pvfs_search_next(struct ntvfs_module_context *ntvfs,
- struct ntvfs_request *req, union smb_search_next *io,
- void *search_private,
- BOOL (*callback)(void *, union smb_search_data *))
+static NTSTATUS pvfs_search_next_trans2(struct ntvfs_module_context *ntvfs,
+ struct ntvfs_request *req, union smb_search_next *io,
+ void *search_private,
+ BOOL (*callback)(void *, union smb_search_data *))
{
struct pvfs_state *pvfs = ntvfs->private_data;
struct pvfs_search_state *search;
uint16_t handle;
NTSTATUS status;
- if (io->generic.level >= RAW_SEARCH_SEARCH) {
- return pvfs_search_next_old(ntvfs, req, io, search_private, callback);
- }
-
handle = io->t2fnext.in.handle;
search = idr_find(pvfs->search.idtree, handle);
search->num_ea_names = io->t2fnext.in.num_names;
search->ea_names = io->t2fnext.in.ea_names;
- status = pvfs_search_fill(pvfs, req, io->t2fnext.in.max_count, search, io->generic.level,
+ status = pvfs_search_fill(pvfs, req, io->t2fnext.in.max_count, search, io->generic.data_level,
&reply_count, search_private, callback);
if (!NT_STATUS_IS_OK(status)) {
return status;
return NT_STATUS_OK;
}
+/*
+ list files in a directory matching a wildcard pattern
+*/
+NTSTATUS pvfs_search_first(struct ntvfs_module_context *ntvfs,
+ struct ntvfs_request *req, union smb_search_first *io,
+ void *search_private,
+ BOOL (*callback)(void *, union smb_search_data *))
+{
+ switch (io->generic.level) {
+ case RAW_SEARCH_SEARCH:
+ case RAW_SEARCH_FFIRST:
+ case RAW_SEARCH_FUNIQUE:
+ return pvfs_search_first_old(ntvfs, req, io, search_private, callback);
+
+ case RAW_SEARCH_TRANS2:
+ return pvfs_search_first_trans2(ntvfs, req, io, search_private, callback);
+ }
+
+ return NT_STATUS_INVALID_LEVEL;
+}
+
+/* continue a search */
+NTSTATUS pvfs_search_next(struct ntvfs_module_context *ntvfs,
+ struct ntvfs_request *req, union smb_search_next *io,
+ void *search_private,
+ BOOL (*callback)(void *, union smb_search_data *))
+{
+ switch (io->generic.level) {
+ case RAW_SEARCH_SEARCH:
+ case RAW_SEARCH_FFIRST:
+ return pvfs_search_next_old(ntvfs, req, io, search_private, callback);
+
+ case RAW_SEARCH_FUNIQUE:
+ return NT_STATUS_INVALID_LEVEL;
+
+ case RAW_SEARCH_TRANS2:
+ return pvfs_search_next_trans2(ntvfs, req, io, search_private, callback);
+ }
+
+ return NT_STATUS_INVALID_LEVEL;
+}
+
+
/* close a search */
NTSTATUS pvfs_search_close(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req, union smb_search_close *io)
{
struct pvfs_state *pvfs = ntvfs->private_data;
struct pvfs_search_state *search;
- uint16_t handle;
+ uint16_t handle = 0;
- if (io->generic.level == RAW_FINDCLOSE_FCLOSE) {
+ switch (io->generic.level) {
+ case RAW_FINDCLOSE_GENERIC:
+ return NT_STATUS_INVALID_LEVEL;
+
+ case RAW_FINDCLOSE_FCLOSE:
handle = io->fclose.in.id.handle;
- } else {
+ break;
+
+ case RAW_FINDCLOSE_FINDCLOSE:
handle = io->findclose.in.handle;
+ break;
}
search = idr_find(pvfs->search.idtree, handle);
union smb_search_data file;
uint_t max_count;
- if (io->generic.level != RAW_SEARCH_BOTH_DIRECTORY_INFO) {
+ if (io->generic.level != RAW_SEARCH_TRANS2) {
+ return NT_STATUS_NOT_SUPPORTED;
+ }
+
+ if (io->generic.data_level != RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO) {
return NT_STATUS_NOT_SUPPORTED;
}
union smb_search_data file;
uint_t max_count;
- if (io->generic.level != RAW_SEARCH_BOTH_DIRECTORY_INFO) {
+ if (io->generic.level != RAW_SEARCH_TRANS2) {
+ return NT_STATUS_NOT_SUPPORTED;
+ }
+
+ if (io->generic.data_level != RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO) {
return NT_STATUS_NOT_SUPPORTED;
}
*/
NTSTATUS smbsrv_push_passthru_search(TALLOC_CTX *mem_ctx,
DATA_BLOB *blob,
- enum smb_search_level level,
+ enum smb_search_data_level level,
union smb_search_data *file,
int default_str_flags)
{
uint_t ofs = blob->length;
switch (level) {
- case RAW_SEARCH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_DIRECTORY_INFO:
BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 64));
data = blob->data + ofs;
SIVAL(data, 4, file->directory_info.file_index);
SIVAL(data, 0, blob->length - ofs);
return NT_STATUS_OK;
- case RAW_SEARCH_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 68));
data = blob->data + ofs;
SIVAL(data, 4, file->full_directory_info.file_index);
SIVAL(data, 0, blob->length - ofs);
return NT_STATUS_OK;
- case RAW_SEARCH_NAME_INFO:
+ case RAW_SEARCH_DATA_NAME_INFO:
BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 12));
data = blob->data + ofs;
SIVAL(data, 4, file->name_info.file_index);
SIVAL(data, 0, blob->length - ofs);
return NT_STATUS_OK;
- case RAW_SEARCH_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 94));
data = blob->data + ofs;
SIVAL(data, 4, file->both_directory_info.file_index);
SIVAL(data, 0, blob->length - ofs);
return NT_STATUS_OK;
- case RAW_SEARCH_ID_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 80));
data = blob->data + ofs;
SIVAL(data, 4, file->id_full_directory_info.file_index);
SIVAL(data, 0, blob->length - ofs);
return NT_STATUS_OK;
- case RAW_SEARCH_ID_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
BLOB_CHECK(smbsrv_blob_grow_data(mem_ctx, blob, ofs + 104));
data = blob->data + ofs;
SIVAL(data, 4, file->id_both_directory_info.file_index);
sn->search_next.in.id.client_cookie = IVAL(p, 17);
sn->search_next.level = level;
+ sn->search_next.data_level = RAW_SEARCH_DATA_SEARCH;
sn->search_next.in.max_count = SVAL(req->in.vwv, VWV(0));
sn->search_next.in.search_attrib = SVAL(req->in.vwv, VWV(1));
/* do a search first operation */
sf->search_first.level = level;
+ sf->search_first.data_level = RAW_SEARCH_DATA_SEARCH;
sf->search_first.in.search_attrib = SVAL(req->in.vwv, VWV(1));
sf->search_first.in.max_count = SVAL(req->in.vwv, VWV(0));
struct find_state {
struct trans_op *op;
void *search;
- enum smb_search_level level;
+ enum smb_search_data_level data_level;
uint16_t last_entry_offset;
uint16_t flags;
};
uint_t ofs = trans->out.data.length;
uint32_t ea_size;
- switch (state->level) {
- case RAW_SEARCH_SEARCH:
- case RAW_SEARCH_FFIRST:
- case RAW_SEARCH_FUNIQUE:
- case RAW_SEARCH_GENERIC:
- case RAW_SEARCH_SMB2:
+ switch (state->data_level) {
+ case RAW_SEARCH_DATA_GENERIC:
+ case RAW_SEARCH_DATA_SEARCH:
/* handled elsewhere */
return NT_STATUS_INVALID_LEVEL;
- case RAW_SEARCH_STANDARD:
+ case RAW_SEARCH_DATA_STANDARD:
if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 27));
SIVAL(trans->out.data.data, ofs, file->standard.resume_key);
STR_LEN8BIT | STR_TERMINATE | STR_LEN_NOTERM));
break;
- case RAW_SEARCH_EA_SIZE:
+ case RAW_SEARCH_DATA_EA_SIZE:
if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 31));
SIVAL(trans->out.data.data, ofs, file->ea_size.resume_key);
TRANS2_CHECK(smbsrv_blob_fill_data(trans, &trans->out.data, trans->out.data.length + 1));
break;
- case RAW_SEARCH_EA_LIST:
+ case RAW_SEARCH_DATA_EA_LIST:
ea_size = ea_list_size(file->ea_list.eas.num_eas, file->ea_list.eas.eas);
if (state->flags & FLAG_TRANS2_FIND_REQUIRE_RESUME) {
TRANS2_CHECK(smbsrv_blob_grow_data(trans, &trans->out.data, ofs + 27 + ea_size));
TRANS2_CHECK(smbsrv_blob_fill_data(trans, &trans->out.data, trans->out.data.length + 1));
break;
- case RAW_SEARCH_DIRECTORY_INFO:
- case RAW_SEARCH_FULL_DIRECTORY_INFO:
- case RAW_SEARCH_NAME_INFO:
- case RAW_SEARCH_BOTH_DIRECTORY_INFO:
- case RAW_SEARCH_ID_FULL_DIRECTORY_INFO:
- case RAW_SEARCH_ID_BOTH_DIRECTORY_INFO:
- return smbsrv_push_passthru_search(trans, &trans->out.data, state->level, file,
+ case RAW_SEARCH_DATA_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_NAME_INFO:
+ case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
+ case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
+ return smbsrv_push_passthru_search(trans, &trans->out.data, state->data_level, file,
SMBSRV_REQ_DEFAULT_STR_FLAGS(req));
+
+ case RAW_SEARCH_DATA_UNIX_INFO:
+ return NT_STATUS_INVALID_LEVEL;
}
return NT_STATUS_OK;
return NT_STATUS_FOOBAR;
}
- search->t2ffirst.level = (enum smb_search_level)level;
- if (search->t2ffirst.level >= RAW_SEARCH_GENERIC) {
+ search->t2ffirst.level = RAW_SEARCH_TRANS2;
+ search->t2ffirst.data_level = (enum smb_search_data_level)level;
+ if (search->t2ffirst.data_level >= RAW_SEARCH_DATA_GENERIC) {
return NT_STATUS_INVALID_LEVEL;
}
- if (search->t2ffirst.level == RAW_SEARCH_EA_LIST) {
+ if (search->t2ffirst.data_level == RAW_SEARCH_DATA_EA_LIST) {
TRANS2_CHECK(ea_pull_name_list(&trans->in.data, req,
&search->t2ffirst.in.num_names,
&search->t2ffirst.in.ea_names));
NT_STATUS_HAVE_NO_MEMORY(state);
state->op = op;
state->search = search;
- state->level = search->t2ffirst.level;
+ state->data_level = search->t2ffirst.data_level;
state->last_entry_offset= 0;
state->flags = search->t2ffirst.in.flags;
return NT_STATUS_FOOBAR;
}
- search->t2fnext.level = (enum smb_search_level)level;
- if (search->t2fnext.level >= RAW_SEARCH_GENERIC) {
+ search->t2fnext.level = RAW_SEARCH_TRANS2;
+ search->t2fnext.data_level = (enum smb_search_data_level)level;
+ if (search->t2fnext.data_level >= RAW_SEARCH_DATA_GENERIC) {
return NT_STATUS_INVALID_LEVEL;
}
- if (search->t2fnext.level == RAW_SEARCH_EA_LIST) {
+ if (search->t2fnext.data_level == RAW_SEARCH_DATA_EA_LIST) {
TRANS2_CHECK(ea_pull_name_list(&trans->in.data, req,
&search->t2fnext.in.num_names,
&search->t2fnext.in.ea_names));
NT_STATUS_HAVE_NO_MEMORY(state);
state->op = op;
state->search = search;
- state->level = search->t2fnext.level;
+ state->data_level = search->t2fnext.data_level;
state->last_entry_offset= 0;
state->flags = search->t2fnext.in.flags;
BOOL res = True;
status = torture_single_search(cli, mem_ctx,
- fname, RAW_SEARCH_FULL_DIRECTORY_INFO,
+ fname,
+ RAW_SEARCH_TRANS2,
+ RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,
FILE_ATTRIBUTE_DIRECTORY,
&data);
if (!NT_STATUS_IS_OK(status)) {
smbcli_list_new(cli->tree, mask,
FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,
- RAW_SEARCH_BOTH_DIRECTORY_INFO,
+ RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
listfn, NULL);
if (f_info_hit) {
fstrcpy(res1, "---");
smbcli_list_new(cli->tree, mask,
FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,
- RAW_SEARCH_BOTH_DIRECTORY_INFO,
+ RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
listfn, NULL);
res2 = reg_test(cli, mask, long_name, short_name);
static NTSTATUS single_search(struct smbcli_state *cli,
TALLOC_CTX *mem_ctx, const char *pattern)
{
- union smb_search_first io;
- NTSTATUS status;
-
- io.generic.level = RAW_SEARCH_STANDARD;
+ union smb_search_first io;
+ NTSTATUS status;
+
+ io.t2ffirst.level = RAW_SEARCH_TRANS2;
+ io.t2ffirst.data_level = RAW_SEARCH_DATA_STANDARD;
io.t2ffirst.in.search_attrib = 0;
io.t2ffirst.in.max_count = 1;
io.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE;
io.t2ffirst.in.pattern = pattern;
status = smb_raw_search_first(cli->tree, mem_ctx,
- &io, NULL, NULL);
-
- return status;
+ &io, NULL, NULL);
+
+ return status;
}
static BOOL test_path(struct smbcli_state *cli, const char *path, NTSTATUS expected, NTSTATUS dos_expected)
TALLOC_CTX *mem_ctx,
const char *pattern,
enum smb_search_level level,
+ enum smb_search_data_level data_level,
uint16_t attrib,
union smb_search_data *data)
{
union smb_search_close c;
NTSTATUS status;
- io.generic.level = level;
- if (level == RAW_SEARCH_SEARCH ||
- level == RAW_SEARCH_FFIRST ||
- level == RAW_SEARCH_FUNIQUE) {
+ switch (level) {
+ case RAW_SEARCH_SEARCH:
+ case RAW_SEARCH_FFIRST:
+ case RAW_SEARCH_FUNIQUE:
+ io.search_first.level = level;
+ io.search_first.data_level = RAW_SEARCH_DATA_SEARCH;
io.search_first.in.max_count = 1;
io.search_first.in.search_attrib = attrib;
io.search_first.in.pattern = pattern;
- } else {
+ break;
+
+ case RAW_SEARCH_TRANS2:
+ io.t2ffirst.level = RAW_SEARCH_TRANS2;
+ io.t2ffirst.data_level = data_level;
io.t2ffirst.in.search_attrib = attrib;
io.t2ffirst.in.max_count = 1;
io.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE;
io.t2ffirst.in.storage_type = 0;
io.t2ffirst.in.pattern = pattern;
+ break;
+
+ case RAW_SEARCH_SMB2:
+ return NT_STATUS_INVALID_LEVEL;
}
status = smb_raw_search_first(cli->tree, mem_ctx,
static struct {
const char *name;
enum smb_search_level level;
+ enum smb_search_data_level data_level;
int name_offset;
int resume_key_offset;
uint32_t capability_mask;
NTSTATUS status;
union smb_search_data data;
} levels[] = {
- {"FFIRST", RAW_SEARCH_FFIRST,
+ {"FFIRST",
+ RAW_SEARCH_FFIRST, RAW_SEARCH_DATA_SEARCH,
offsetof(union smb_search_data, search.name),
-1,
},
- {"FUNIQUE", RAW_SEARCH_FUNIQUE,
+ {"FUNIQUE",
+ RAW_SEARCH_FUNIQUE, RAW_SEARCH_DATA_SEARCH,
offsetof(union smb_search_data, search.name),
-1,
},
- {"SEARCH", RAW_SEARCH_SEARCH,
+ {"SEARCH",
+ RAW_SEARCH_SEARCH, RAW_SEARCH_DATA_SEARCH,
offsetof(union smb_search_data, search.name),
-1,
},
- {"STANDARD", RAW_SEARCH_STANDARD,
+ {"STANDARD",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_STANDARD,
offsetof(union smb_search_data, standard.name.s),
offsetof(union smb_search_data, standard.resume_key),
},
- {"EA_SIZE", RAW_SEARCH_EA_SIZE,
+ {"EA_SIZE",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_EA_SIZE,
offsetof(union smb_search_data, ea_size.name.s),
offsetof(union smb_search_data, ea_size.resume_key),
},
- {"DIRECTORY_INFO", RAW_SEARCH_DIRECTORY_INFO,
+ {"DIRECTORY_INFO",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_DIRECTORY_INFO,
offsetof(union smb_search_data, directory_info.name.s),
offsetof(union smb_search_data, directory_info.file_index),
},
- {"FULL_DIRECTORY_INFO", RAW_SEARCH_FULL_DIRECTORY_INFO,
+ {"FULL_DIRECTORY_INFO",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_FULL_DIRECTORY_INFO,
offsetof(union smb_search_data, full_directory_info.name.s),
offsetof(union smb_search_data, full_directory_info.file_index),
},
- {"NAME_INFO", RAW_SEARCH_NAME_INFO,
+ {"NAME_INFO",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_NAME_INFO,
offsetof(union smb_search_data, name_info.name.s),
offsetof(union smb_search_data, name_info.file_index),
},
- {"BOTH_DIRECTORY_INFO", RAW_SEARCH_BOTH_DIRECTORY_INFO,
+ {"BOTH_DIRECTORY_INFO",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
offsetof(union smb_search_data, both_directory_info.name.s),
offsetof(union smb_search_data, both_directory_info.file_index),
},
- {"ID_FULL_DIRECTORY_INFO", RAW_SEARCH_ID_FULL_DIRECTORY_INFO,
+ {"ID_FULL_DIRECTORY_INFO",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO,
offsetof(union smb_search_data, id_full_directory_info.name.s),
offsetof(union smb_search_data, id_full_directory_info.file_index),
},
- {"ID_BOTH_DIRECTORY_INFO", RAW_SEARCH_ID_BOTH_DIRECTORY_INFO,
+ {"ID_BOTH_DIRECTORY_INFO",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO,
offsetof(union smb_search_data, id_both_directory_info.name.s),
offsetof(union smb_search_data, id_both_directory_info.file_index),
},
- {"UNIX_INFO", RAW_SEARCH_UNIX_INFO,
+ {"UNIX_INFO",
+ RAW_SEARCH_TRANS2, RAW_SEARCH_DATA_UNIX_INFO,
offsetof(union smb_search_data, unix_info.name),
offsetof(union smb_search_data, unix_info.file_index),
CAP_UNIX}
/*
return level name
*/
-static const char *level_name(enum smb_search_level level)
+static const char *level_name(enum smb_search_level level,
+ enum smb_search_data_level data_level)
{
int i;
for (i=0;i<ARRAY_SIZE(levels);i++) {
- if (level == levels[i].level) {
+ if (level == levels[i].level &&
+ data_level == levels[i].data_level) {
return levels[i].name;
}
}
/*
extract the name from a smb_data structure and level
*/
-static const char *extract_name(void *data, enum smb_search_level level)
+static const char *extract_name(void *data, enum smb_search_level level,
+ enum smb_search_data_level data_level)
{
int i;
for (i=0;i<ARRAY_SIZE(levels);i++) {
- if (level == levels[i].level) {
+ if (level == levels[i].level &&
+ data_level == levels[i].data_level) {
return *(const char **)(levels[i].name_offset + (char *)data);
}
}
/*
extract the name from a smb_data structure and level
*/
-static int extract_resume_key(void *data, enum smb_search_level level)
+static int extract_resume_key(void *data, enum smb_search_level level,
+ enum smb_search_data_level data_level)
{
int i;
for (i=0;i<ARRAY_SIZE(levels);i++) {
- if (level == levels[i].level) {
+ if (level == levels[i].level &&
+ data_level == levels[i].data_level) {
return (int)*(uint32_t *)(levels[i].resume_key_offset + (char *)data);
}
}
printf("testing %s\n", levels[i].name);
levels[i].status = torture_single_search(cli, mem_ctx, fname,
- levels[i].level, 0,
+ levels[i].level,
+ levels[i].data_level,
+ 0,
&levels[i].data);
/* see if this server claims to support this level */
}
status = torture_single_search(cli, mem_ctx, fname2,
- levels[i].level, 0,
+ levels[i].level,
+ levels[i].data_level,
+ 0,
&levels[i].data);
expected_status = NT_STATUS_NO_SUCH_FILE;
static NTSTATUS multiple_search(struct smbcli_state *cli,
TALLOC_CTX *mem_ctx,
const char *pattern,
- enum smb_search_level level,
+ enum smb_search_data_level data_level,
enum continue_type cont_type,
void *data)
{
const int per_search = 100;
struct multiple_result *result = data;
- io.generic.level = level;
- if (level == RAW_SEARCH_SEARCH) {
+ if (data_level == RAW_SEARCH_DATA_SEARCH) {
+ io.search_first.level = RAW_SEARCH_SEARCH;
+ io.search_first.data_level = RAW_SEARCH_DATA_SEARCH;
io.search_first.in.max_count = per_search;
io.search_first.in.search_attrib = 0;
io.search_first.in.pattern = pattern;
} else {
+ io.t2ffirst.level = RAW_SEARCH_TRANS2;
+ io.t2ffirst.data_level = data_level;
io.t2ffirst.in.search_attrib = 0;
io.t2ffirst.in.max_count = per_search;
io.t2ffirst.in.flags = FLAG_TRANS2_FIND_CLOSE_IF_END;
while (NT_STATUS_IS_OK(status)) {
- io2.generic.level = level;
- if (level == RAW_SEARCH_SEARCH) {
+ if (data_level == RAW_SEARCH_DATA_SEARCH) {
+ io2.search_next.level = RAW_SEARCH_SEARCH;
+ io2.search_next.data_level = RAW_SEARCH_DATA_SEARCH;
io2.search_next.in.max_count = per_search;
io2.search_next.in.search_attrib = 0;
io2.search_next.in.id = result->list[result->count-1].search.id;
} else {
+ io2.t2fnext.level = RAW_SEARCH_TRANS2;
+ io2.t2fnext.data_level = data_level;
io2.t2fnext.in.handle = io.t2ffirst.out.handle;
io2.t2fnext.in.max_count = per_search;
io2.t2fnext.in.resume_key = 0;
io2.t2fnext.in.last_name = "";
switch (cont_type) {
case CONT_RESUME_KEY:
- io2.t2fnext.in.resume_key = extract_resume_key(&result->list[result->count-1], level);
+ io2.t2fnext.in.resume_key = extract_resume_key(&result->list[result->count-1],
+ io2.t2fnext.level, io2.t2fnext.data_level);
if (io2.t2fnext.in.resume_key <= 0) {
printf("Server does not support resume by key for level %s\n",
- level_name(level));
+ level_name(io2.t2fnext.level, io2.t2fnext.data_level));
return NT_STATUS_NOT_SUPPORTED;
}
io2.t2fnext.in.flags |= FLAG_TRANS2_FIND_REQUIRE_RESUME |
FLAG_TRANS2_FIND_BACKUP_INTENT;
break;
case CONT_NAME:
- io2.t2fnext.in.last_name = extract_name(&result->list[result->count-1], level);
+ io2.t2fnext.in.last_name = extract_name(&result->list[result->count-1],
+ io2.t2fnext.level, io2.t2fnext.data_level);
break;
case CONT_FLAGS:
io2.t2fnext.in.flags |= FLAG_TRANS2_FIND_CONTINUE;
if (!NT_STATUS_IS_OK(status)) {
break;
}
- if (level == RAW_SEARCH_SEARCH) {
+ if (data_level == RAW_SEARCH_DATA_SEARCH) {
if (io2.search_next.out.count == 0) {
break;
}
}} while (0)
-static enum smb_search_level compare_level;
+static enum smb_search_data_level compare_data_level;
static int search_compare(union smb_search_data *d1, union smb_search_data *d2)
{
const char *s1, *s2;
- s1 = extract_name(d1, compare_level);
- s2 = extract_name(d2, compare_level);
+ enum smb_search_level level;
+
+ if (compare_data_level == RAW_SEARCH_DATA_SEARCH) {
+ level = RAW_SEARCH_SEARCH;
+ } else {
+ level = RAW_SEARCH_TRANS2;
+ }
+
+ s1 = extract_name(d1, level, compare_data_level);
+ s2 = extract_name(d2, level, compare_data_level);
return strcmp_safe(s1, s2);
}
struct {
const char *name;
const char *cont_name;
- enum smb_search_level level;
+ enum smb_search_data_level data_level;
enum continue_type cont_type;
} search_types[] = {
- {"SEARCH", "ID", RAW_SEARCH_SEARCH, CONT_RESUME_KEY},
- {"BOTH_DIRECTORY_INFO", "NAME", RAW_SEARCH_BOTH_DIRECTORY_INFO, CONT_NAME},
- {"BOTH_DIRECTORY_INFO", "FLAGS", RAW_SEARCH_BOTH_DIRECTORY_INFO, CONT_FLAGS},
- {"BOTH_DIRECTORY_INFO", "KEY", RAW_SEARCH_BOTH_DIRECTORY_INFO, CONT_RESUME_KEY},
- {"STANDARD", "FLAGS", RAW_SEARCH_STANDARD, CONT_FLAGS},
- {"STANDARD", "KEY", RAW_SEARCH_STANDARD, CONT_RESUME_KEY},
- {"STANDARD", "NAME", RAW_SEARCH_STANDARD, CONT_NAME},
- {"EA_SIZE", "FLAGS", RAW_SEARCH_EA_SIZE, CONT_FLAGS},
- {"EA_SIZE", "KEY", RAW_SEARCH_EA_SIZE, CONT_RESUME_KEY},
- {"EA_SIZE", "NAME", RAW_SEARCH_EA_SIZE, CONT_NAME},
- {"DIRECTORY_INFO", "FLAGS", RAW_SEARCH_DIRECTORY_INFO, CONT_FLAGS},
- {"DIRECTORY_INFO", "KEY", RAW_SEARCH_DIRECTORY_INFO, CONT_RESUME_KEY},
- {"DIRECTORY_INFO", "NAME", RAW_SEARCH_DIRECTORY_INFO, CONT_NAME},
- {"FULL_DIRECTORY_INFO", "FLAGS", RAW_SEARCH_FULL_DIRECTORY_INFO, CONT_FLAGS},
- {"FULL_DIRECTORY_INFO", "KEY", RAW_SEARCH_FULL_DIRECTORY_INFO, CONT_RESUME_KEY},
- {"FULL_DIRECTORY_INFO", "NAME", RAW_SEARCH_FULL_DIRECTORY_INFO, CONT_NAME},
- {"ID_FULL_DIRECTORY_INFO", "FLAGS", RAW_SEARCH_ID_FULL_DIRECTORY_INFO, CONT_FLAGS},
- {"ID_FULL_DIRECTORY_INFO", "KEY", RAW_SEARCH_ID_FULL_DIRECTORY_INFO, CONT_RESUME_KEY},
- {"ID_FULL_DIRECTORY_INFO", "NAME", RAW_SEARCH_ID_FULL_DIRECTORY_INFO, CONT_NAME},
- {"ID_BOTH_DIRECTORY_INFO", "NAME", RAW_SEARCH_ID_BOTH_DIRECTORY_INFO, CONT_NAME},
- {"ID_BOTH_DIRECTORY_INFO", "FLAGS", RAW_SEARCH_ID_BOTH_DIRECTORY_INFO, CONT_FLAGS},
- {"ID_BOTH_DIRECTORY_INFO", "KEY", RAW_SEARCH_ID_BOTH_DIRECTORY_INFO, CONT_RESUME_KEY}
+ {"SEARCH", "ID", RAW_SEARCH_DATA_SEARCH, CONT_RESUME_KEY},
+ {"BOTH_DIRECTORY_INFO", "NAME", RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO, CONT_NAME},
+ {"BOTH_DIRECTORY_INFO", "FLAGS", RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO, CONT_FLAGS},
+ {"BOTH_DIRECTORY_INFO", "KEY", RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO, CONT_RESUME_KEY},
+ {"STANDARD", "FLAGS", RAW_SEARCH_DATA_STANDARD, CONT_FLAGS},
+ {"STANDARD", "KEY", RAW_SEARCH_DATA_STANDARD, CONT_RESUME_KEY},
+ {"STANDARD", "NAME", RAW_SEARCH_DATA_STANDARD, CONT_NAME},
+ {"EA_SIZE", "FLAGS", RAW_SEARCH_DATA_EA_SIZE, CONT_FLAGS},
+ {"EA_SIZE", "KEY", RAW_SEARCH_DATA_EA_SIZE, CONT_RESUME_KEY},
+ {"EA_SIZE", "NAME", RAW_SEARCH_DATA_EA_SIZE, CONT_NAME},
+ {"DIRECTORY_INFO", "FLAGS", RAW_SEARCH_DATA_DIRECTORY_INFO, CONT_FLAGS},
+ {"DIRECTORY_INFO", "KEY", RAW_SEARCH_DATA_DIRECTORY_INFO, CONT_RESUME_KEY},
+ {"DIRECTORY_INFO", "NAME", RAW_SEARCH_DATA_DIRECTORY_INFO, CONT_NAME},
+ {"FULL_DIRECTORY_INFO", "FLAGS", RAW_SEARCH_DATA_FULL_DIRECTORY_INFO, CONT_FLAGS},
+ {"FULL_DIRECTORY_INFO", "KEY", RAW_SEARCH_DATA_FULL_DIRECTORY_INFO, CONT_RESUME_KEY},
+ {"FULL_DIRECTORY_INFO", "NAME", RAW_SEARCH_DATA_FULL_DIRECTORY_INFO, CONT_NAME},
+ {"ID_FULL_DIRECTORY_INFO", "FLAGS", RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_FLAGS},
+ {"ID_FULL_DIRECTORY_INFO", "KEY", RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_RESUME_KEY},
+ {"ID_FULL_DIRECTORY_INFO", "NAME", RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO, CONT_NAME},
+ {"ID_BOTH_DIRECTORY_INFO", "NAME", RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_NAME},
+ {"ID_BOTH_DIRECTORY_INFO", "FLAGS", RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_FLAGS},
+ {"ID_BOTH_DIRECTORY_INFO", "KEY", RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO, CONT_RESUME_KEY}
};
if (!torture_setup_dir(cli, BASEDIR)) {
printf("Continue %s via %s\n", search_types[t].name, search_types[t].cont_name);
status = multiple_search(cli, mem_ctx, BASEDIR "\\*.*",
- search_types[t].level,
+ search_types[t].data_level,
search_types[t].cont_type,
&result);
}
CHECK_VALUE(result.count, num_files);
- compare_level = search_types[t].level;
+ compare_data_level = search_types[t].data_level;
qsort(result.list, result.count, sizeof(result.list[0]),
QSORT_CAST search_compare);
for (i=0;i<result.count;i++) {
const char *s;
- s = extract_name(&result.list[i], compare_level);
+ enum smb_search_level level;
+ if (compare_data_level == RAW_SEARCH_DATA_SEARCH) {
+ level = RAW_SEARCH_SEARCH;
+ } else {
+ level = RAW_SEARCH_TRANS2;
+ }
+ s = extract_name(&result.list[i], level, compare_data_level);
fname = talloc_asprintf(cli, "t%03d-%d.txt", i, i);
if (strcmp(fname, s)) {
printf("Incorrect name %s at entry %d\n", s, i);
ZERO_STRUCT(result);
result.mem_ctx = talloc_new(mem_ctx);
- io.generic.level = RAW_SEARCH_BOTH_DIRECTORY_INFO;
+ io.t2ffirst.level = RAW_SEARCH_TRANS2;
+ io.t2ffirst.data_level = RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO;
io.t2ffirst.in.search_attrib = 0;
io.t2ffirst.in.max_count = 0;
io.t2ffirst.in.flags = 0;
CHECK_VALUE(result.count, 1);
printf("pulling the second file\n");
- io2.generic.level = RAW_SEARCH_BOTH_DIRECTORY_INFO;
+ io2.t2fnext.level = RAW_SEARCH_TRANS2;
+ io2.t2fnext.data_level = RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO;
io2.t2fnext.in.handle = io.t2ffirst.out.handle;
io2.t2fnext.in.max_count = 1;
io2.t2fnext.in.resume_key = 0;
status = smb_raw_setfileinfo(cli->tree, &sfinfo);
CHECK_STATUS(status, NT_STATUS_OK);
- io2.generic.level = RAW_SEARCH_BOTH_DIRECTORY_INFO;
+ io2.t2fnext.level = RAW_SEARCH_TRANS2;
+ io2.t2fnext.data_level = RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO;
io2.t2fnext.in.handle = io.t2ffirst.out.handle;
io2.t2fnext.in.max_count = num_files + 3;
io2.t2fnext.in.resume_key = 0;
result.mem_ctx = mem_ctx;
status = multiple_search(cli, mem_ctx, BASEDIR "\\*.*",
- RAW_SEARCH_BOTH_DIRECTORY_INFO,
+ RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
CONT_NAME, &result);
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(result.count, num_files);
for (i=0;i<num_dirs;i++) {
union smb_search_first io;
- io.generic.level = RAW_SEARCH_SEARCH;
+ io.search_first.level = RAW_SEARCH_SEARCH;
+ io.search_first.data_level = RAW_SEARCH_DATA_SEARCH;
io.search_first.in.max_count = 1;
io.search_first.in.search_attrib = 0;
io.search_first.in.pattern = talloc_asprintf(mem_ctx, BASEDIR "\\d%d\\*.txt", i);
for (i=0;i<num_dirs;i++) {
union smb_search_next io2;
- io2.generic.level = RAW_SEARCH_SEARCH;
+ io2.search_next.level = RAW_SEARCH_SEARCH;
+ io2.search_next.data_level = RAW_SEARCH_DATA_SEARCH;
io2.search_next.in.max_count = 1;
io2.search_next.in.search_attrib = 0;
io2.search_next.in.id = file[i].search.id;
for (i=0;i<num_dirs;i++) {
union smb_search_next io2;
- io2.generic.level = RAW_SEARCH_SEARCH;
+ io2.search_next.level = RAW_SEARCH_SEARCH;
+ io2.search_next.data_level = RAW_SEARCH_DATA_SEARCH;
io2.search_next.in.max_count = 1;
io2.search_next.in.search_attrib = 0;
io2.search_next.in.id = file[i].search.id;
ZERO_STRUCT(result);
result.mem_ctx = mem_ctx;
- io.t2ffirst.level = RAW_SEARCH_EA_SIZE;
+ io.t2ffirst.level = RAW_SEARCH_TRANS2;
+ io.t2ffirst.data_level = RAW_SEARCH_DATA_EA_SIZE;
io.t2ffirst.in.search_attrib = 0;
io.t2ffirst.in.max_count = 100;
io.t2ffirst.in.flags = FLAG_TRANS2_FIND_REQUIRE_RESUME;
talloc_free(fname);
}
- io2.t2fnext.level = RAW_SEARCH_EA_SIZE;
+ io2.t2fnext.level = RAW_SEARCH_TRANS2;
+ io2.t2fnext.data_level = RAW_SEARCH_DATA_EA_SIZE;
io2.t2fnext.in.handle = io.t2ffirst.out.handle;
io2.t2fnext.in.max_count = 100;
io2.t2fnext.in.resume_key = result.list[i-1].ea_size.resume_key;
ZERO_STRUCT(result);
result.mem_ctx = mem_ctx;
- io.t2ffirst.level = RAW_SEARCH_EA_LIST;
+ io.t2ffirst.level = RAW_SEARCH_TRANS2;
+ io.t2ffirst.data_level = RAW_SEARCH_DATA_EA_LIST;
io.t2ffirst.in.search_attrib = 0;
io.t2ffirst.in.max_count = 2;
io.t2ffirst.in.flags = FLAG_TRANS2_FIND_REQUIRE_RESUME;
CHECK_STATUS(status, NT_STATUS_OK);
CHECK_VALUE(result.count, 2);
- nxt.t2fnext.level = RAW_SEARCH_EA_LIST;
+ nxt.t2fnext.level = RAW_SEARCH_TRANS2;
+ nxt.t2fnext.data_level = RAW_SEARCH_DATA_EA_LIST;
nxt.t2fnext.in.handle = io.t2ffirst.out.handle;
nxt.t2fnext.in.max_count = 2;
nxt.t2fnext.in.resume_key = result.list[1].ea_list.resume_key;