?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4-dsdb: Remove support for per-partition sequence numbers
[Samba.git] / source4 / ntvfs / posix / pvfs_search.c
blob8cba72da43979b8514ed6abec0302a30604b4ff8
1 /*
2 Unix SMB/CIFS implementation.
3
4 POSIX NTVFS backend - directory search functions
5
6 Copyright (C) Andrew Tridgell 2004
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "vfs_posix.h"
24 #include "system/time.h"
25 #include "librpc/gen_ndr/security.h"
26 #include "smbd/service_stream.h"
27 #include "lib/events/events.h"
28 #include "../lib/util/dlinklist.h"
29
30 /* place a reasonable limit on old-style searches as clients tend to
31 not send search close requests */
32 #define MAX_OLD_SEARCHES 2000
33 #define MAX_SEARCH_HANDLES (UINT16_MAX - 1)
34 #define INVALID_SEARCH_HANDLE UINT16_MAX
35
36 /*
37 destroy an open search
38 */
39 static int pvfs_search_destructor(struct pvfs_search_state *search)
40 {
41 DLIST_REMOVE(search->pvfs->search.list, search);
42 idr_remove(search->pvfs->search.idtree, search->handle);
43 return 0;
44 }
45
46 /*
47 called when a search timer goes off
48 */
49 static void pvfs_search_timer(struct tevent_context *ev, struct tevent_timer *te,
50 struct timeval t, void *ptr)
51 {
52 struct pvfs_search_state *search = talloc_get_type(ptr, struct pvfs_search_state);
53 talloc_free(search);
54 }
55
56 /*
57 setup a timer to destroy a open search after a inactivity period
58 */
59 static void pvfs_search_setup_timer(struct pvfs_search_state *search)
60 {
61 struct tevent_context *ev = search->pvfs->ntvfs->ctx->event_ctx;
62 if (search->handle == INVALID_SEARCH_HANDLE) return;
63 talloc_free(search->te);
64 search->te = tevent_add_timer(ev, search,
65 timeval_current_ofs(search->pvfs->search.inactivity_time, 0),
66 pvfs_search_timer, search);
67 }
68
69 /*
70 fill in a single search result for a given info level
71 */
72 static NTSTATUS fill_search_info(struct pvfs_state *pvfs,
73 enum smb_search_data_level level,
74 const char *unix_path,
75 const char *fname,
76 struct pvfs_search_state *search,
77 off_t dir_offset,
78 union smb_search_data *file)
79 {
80 struct pvfs_filename *name;
81 NTSTATUS status;
82 const char *shortname;
83 uint32_t dir_index = (uint32_t)dir_offset; /* truncated - see the code
84 in pvfs_list_seek_ofs() for
85 how we cope with this */
86
87 status = pvfs_resolve_partial(pvfs, file, unix_path, fname, 0, &name);
88 if (!NT_STATUS_IS_OK(status)) {
89 return status;
90 }
91
92 status = pvfs_match_attrib(pvfs, name, search->search_attrib, search->must_attrib);
93 if (!NT_STATUS_IS_OK(status)) {
94 return status;
95 }
96
97 switch (level) {
98 case RAW_SEARCH_DATA_SEARCH:
99 shortname = pvfs_short_name(pvfs, name, name);
100 file->search.attrib = name->dos.attrib;
101 file->search.write_time = nt_time_to_unix(name->dos.write_time);
102 file->search.size = name->st.st_size;
103 file->search.name = shortname;
104 file->search.id.reserved = search->handle >> 8;
105 memset(file->search.id.name, ' ', sizeof(file->search.id.name));
106 memcpy(file->search.id.name, shortname,
107 MIN(strlen(shortname)+1, sizeof(file->search.id.name)));
108 file->search.id.handle = search->handle & 0xFF;
109 file->search.id.server_cookie = dir_index;
110 file->search.id.client_cookie = 0;
111 return NT_STATUS_OK;
112
113 case RAW_SEARCH_DATA_STANDARD:
114 file->standard.resume_key = dir_index;
115 file->standard.create_time = nt_time_to_unix(name->dos.create_time);
116 file->standard.access_time = nt_time_to_unix(name->dos.access_time);
117 file->standard.write_time = nt_time_to_unix(name->dos.write_time);
118 file->standard.size = name->st.st_size;
119 file->standard.alloc_size = name->dos.alloc_size;
120 file->standard.attrib = name->dos.attrib;
121 file->standard.name.s = fname;
122 return NT_STATUS_OK;
123
124 case RAW_SEARCH_DATA_EA_SIZE:
125 file->ea_size.resume_key = dir_index;
126 file->ea_size.create_time = nt_time_to_unix(name->dos.create_time);
127 file->ea_size.access_time = nt_time_to_unix(name->dos.access_time);
128 file->ea_size.write_time = nt_time_to_unix(name->dos.write_time);
129 file->ea_size.size = name->st.st_size;
130 file->ea_size.alloc_size = name->dos.alloc_size;
131 file->ea_size.attrib = name->dos.attrib;
132 file->ea_size.ea_size = name->dos.ea_size;
133 file->ea_size.name.s = fname;
134 return NT_STATUS_OK;
135
136 case RAW_SEARCH_DATA_EA_LIST:
137 file->ea_list.resume_key = dir_index;
138 file->ea_list.create_time = nt_time_to_unix(name->dos.create_time);
139 file->ea_list.access_time = nt_time_to_unix(name->dos.access_time);
140 file->ea_list.write_time = nt_time_to_unix(name->dos.write_time);
141 file->ea_list.size = name->st.st_size;
142 file->ea_list.alloc_size = name->dos.alloc_size;
143 file->ea_list.attrib = name->dos.attrib;
144 file->ea_list.name.s = fname;
145 return pvfs_query_ea_list(pvfs, file, name, -1,
146 search->num_ea_names,
147 search->ea_names,
148 &file->ea_list.eas);
149
150 case RAW_SEARCH_DATA_DIRECTORY_INFO:
151 file->directory_info.file_index = dir_index;
152 file->directory_info.create_time = name->dos.create_time;
153 file->directory_info.access_time = name->dos.access_time;
154 file->directory_info.write_time = name->dos.write_time;
155 file->directory_info.change_time = name->dos.change_time;
156 file->directory_info.size = name->st.st_size;
157 file->directory_info.alloc_size = name->dos.alloc_size;
158 file->directory_info.attrib = name->dos.attrib;
159 file->directory_info.name.s = fname;
160 return NT_STATUS_OK;
161
162 case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
163 file->full_directory_info.file_index = dir_index;
164 file->full_directory_info.create_time = name->dos.create_time;
165 file->full_directory_info.access_time = name->dos.access_time;
166 file->full_directory_info.write_time = name->dos.write_time;
167 file->full_directory_info.change_time = name->dos.change_time;
168 file->full_directory_info.size = name->st.st_size;
169 file->full_directory_info.alloc_size = name->dos.alloc_size;
170 file->full_directory_info.attrib = name->dos.attrib;
171 file->full_directory_info.ea_size = name->dos.ea_size;
172 file->full_directory_info.name.s = fname;
173 return NT_STATUS_OK;
174
175 case RAW_SEARCH_DATA_NAME_INFO:
176 file->name_info.file_index = dir_index;
177 file->name_info.name.s = fname;
178 return NT_STATUS_OK;
179
180 case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
181 file->both_directory_info.file_index = dir_index;
182 file->both_directory_info.create_time = name->dos.create_time;
183 file->both_directory_info.access_time = name->dos.access_time;
184 file->both_directory_info.write_time = name->dos.write_time;
185 file->both_directory_info.change_time = name->dos.change_time;
186 file->both_directory_info.size = name->st.st_size;
187 file->both_directory_info.alloc_size = name->dos.alloc_size;
188 file->both_directory_info.attrib = name->dos.attrib;
189 file->both_directory_info.ea_size = name->dos.ea_size;
190 file->both_directory_info.short_name.s = pvfs_short_name(pvfs, file, name);
191 file->both_directory_info.name.s = fname;
192 return NT_STATUS_OK;
193
194 case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
195 file->id_full_directory_info.file_index = dir_index;
196 file->id_full_directory_info.create_time = name->dos.create_time;
197 file->id_full_directory_info.access_time = name->dos.access_time;
198 file->id_full_directory_info.write_time = name->dos.write_time;
199 file->id_full_directory_info.change_time = name->dos.change_time;
200 file->id_full_directory_info.size = name->st.st_size;
201 file->id_full_directory_info.alloc_size = name->dos.alloc_size;
202 file->id_full_directory_info.attrib = name->dos.attrib;
203 file->id_full_directory_info.ea_size = name->dos.ea_size;
204 file->id_full_directory_info.file_id = name->dos.file_id;
205 file->id_full_directory_info.name.s = fname;
206 return NT_STATUS_OK;
207
208 case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
209 file->id_both_directory_info.file_index = dir_index;
210 file->id_both_directory_info.create_time = name->dos.create_time;
211 file->id_both_directory_info.access_time = name->dos.access_time;
212 file->id_both_directory_info.write_time = name->dos.write_time;
213 file->id_both_directory_info.change_time = name->dos.change_time;
214 file->id_both_directory_info.size = name->st.st_size;
215 file->id_both_directory_info.alloc_size = name->dos.alloc_size;
216 file->id_both_directory_info.attrib = name->dos.attrib;
217 file->id_both_directory_info.ea_size = name->dos.ea_size;
218 file->id_both_directory_info.file_id = name->dos.file_id;
219 file->id_both_directory_info.short_name.s = pvfs_short_name(pvfs, file, name);
220 file->id_both_directory_info.name.s = fname;
221 return NT_STATUS_OK;
222
223 case RAW_SEARCH_DATA_GENERIC:
224 case RAW_SEARCH_DATA_UNIX_INFO:
225 case RAW_SEARCH_DATA_UNIX_INFO2:
226 return NT_STATUS_INVALID_LEVEL;
227 }
228
229 return NT_STATUS_INVALID_LEVEL;
230 }
231
232
233 /*
234 the search fill loop
235 */
236 static NTSTATUS pvfs_search_fill(struct pvfs_state *pvfs, TALLOC_CTX *mem_ctx,
237 unsigned int max_count,
238 struct pvfs_search_state *search,
239 enum smb_search_data_level level,
240 unsigned int *reply_count,
241 void *search_private,
242 bool (*callback)(void *, const union smb_search_data *))
243 {
244 struct pvfs_dir *dir = search->dir;
245 NTSTATUS status;
246
247 *reply_count = 0;
248
249 if (max_count == 0) {
250 max_count = 1;
251 }
252
253 while ((*reply_count) < max_count) {
254 union smb_search_data *file;
255 const char *name;
256 off_t ofs = search->current_index;
257
258 name = pvfs_list_next(dir, &search->current_index);
259 if (name == NULL) break;
260
261 file = talloc(mem_ctx, union smb_search_data);
262 if (!file) {
263 return NT_STATUS_NO_MEMORY;
264 }
265
266 status = fill_search_info(pvfs, level,
267 pvfs_list_unix_path(dir), name,
268 search, search->current_index, file);
269 if (!NT_STATUS_IS_OK(status)) {
270 talloc_free(file);
271 continue;
272 }
273
274 if (!callback(search_private, file)) {
275 talloc_free(file);
276 search->current_index = ofs;
277 break;
278 }
279
280 (*reply_count)++;
281 talloc_free(file);
282 }
283
284 pvfs_search_setup_timer(search);
285
286 return NT_STATUS_OK;
287 }
288
289 /*
290 we've run out of search handles - cleanup those that the client forgot
291 to close
292 */
293 static void pvfs_search_cleanup(struct pvfs_state *pvfs)
294 {
295 int i;
296 time_t t = time_mono(NULL);
297
298 for (i=0;i<MAX_OLD_SEARCHES;i++) {
299 struct pvfs_search_state *search;
300 void *p = idr_find(pvfs->search.idtree, i);
301
302 if (p == NULL) return;
303
304 search = talloc_get_type(p, struct pvfs_search_state);
305 if (pvfs_list_eos(search->dir, search->current_index) &&
306 search->last_used != 0 &&
307 t > search->last_used + 30) {
308 /* its almost certainly been forgotten
309 about */
310 talloc_free(search);
311 }
312 }
313 }
314
315
316 /*
317 list files in a directory matching a wildcard pattern - old SMBsearch interface
318 */
319 static NTSTATUS pvfs_search_first_old(struct ntvfs_module_context *ntvfs,
320 struct ntvfs_request *req, union smb_search_first *io,
321 void *search_private,
322 bool (*callback)(void *, const union smb_search_data *))
323 {
324 struct pvfs_dir *dir;
325 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
326 struct pvfs_state);
327 struct pvfs_search_state *search;
328 unsigned int reply_count;
329 uint16_t search_attrib;
330 const char *pattern;
331 NTSTATUS status;
332 struct pvfs_filename *name;
333 int id;
334
335 search_attrib = io->search_first.in.search_attrib;
336 pattern = io->search_first.in.pattern;
337
338 /* resolve the cifs name to a posix name */
339 status = pvfs_resolve_name(pvfs, req, pattern, PVFS_RESOLVE_WILDCARD, &name);
340 if (!NT_STATUS_IS_OK(status)) {
341 return status;
342 }
343
344 if (!name->has_wildcard && !name->exists) {
345 return STATUS_NO_MORE_FILES;
346 }
347
348 status = pvfs_access_check_parent(pvfs, req, name, SEC_DIR_TRAVERSE | SEC_DIR_LIST);
349 if (!NT_STATUS_IS_OK(status)) {
350 return status;
351 }
352
353 /* we initially make search a child of the request, then if we
354 need to keep it long term we steal it for the private
355 structure */
356 search = talloc(req, struct pvfs_search_state);
357 if (!search) {
358 return NT_STATUS_NO_MEMORY;
359 }
360
361 /* do the actual directory listing */
362 status = pvfs_list_start(pvfs, name, search, &dir);
363 if (!NT_STATUS_IS_OK(status)) {
364 return status;
365 }
366
367 /* we need to give a handle back to the client so it
368 can continue a search */
369 id = idr_get_new(pvfs->search.idtree, search, MAX_OLD_SEARCHES);
370 if (id == -1) {
371 pvfs_search_cleanup(pvfs);
372 id = idr_get_new(pvfs->search.idtree, search, MAX_OLD_SEARCHES);
373 }
374 if (id == -1) {
375 return NT_STATUS_INSUFFICIENT_RESOURCES;
376 }
377
378 search->pvfs = pvfs;
379 search->handle = id;
380 search->dir = dir;
381 search->current_index = 0;
382 search->search_attrib = search_attrib & 0xFF;
383 search->must_attrib = (search_attrib>>8) & 0xFF;
384 search->last_used = time_mono(NULL);
385 search->te = NULL;
386
387 DLIST_ADD(pvfs->search.list, search);
388
389 talloc_set_destructor(search, pvfs_search_destructor);
390
391 status = pvfs_search_fill(pvfs, req, io->search_first.in.max_count, search, io->generic.data_level,
392 &reply_count, search_private, callback);
393 if (!NT_STATUS_IS_OK(status)) {
394 return status;
395 }
396
397 io->search_first.out.count = reply_count;
398
399 /* not matching any entries is an error */
400 if (reply_count == 0) {
401 return STATUS_NO_MORE_FILES;
402 }
403
404 talloc_steal(pvfs, search);
405
406 return NT_STATUS_OK;
407 }
408
409 /* continue a old style search */
410 static NTSTATUS pvfs_search_next_old(struct ntvfs_module_context *ntvfs,
411 struct ntvfs_request *req, union smb_search_next *io,
412 void *search_private,
413 bool (*callback)(void *, const union smb_search_data *))
414 {
415 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
416 struct pvfs_state);
417 void *p;
418 struct pvfs_search_state *search;
419 struct pvfs_dir *dir;
420 unsigned int reply_count, max_count;
421 uint16_t handle;
422 NTSTATUS status;
423
424 handle = io->search_next.in.id.handle | (io->search_next.in.id.reserved<<8);
425 max_count = io->search_next.in.max_count;
426
427 p = idr_find(pvfs->search.idtree, handle);
428 if (p == NULL) {
429 /* we didn't find the search handle */
430 return NT_STATUS_INVALID_HANDLE;
431 }
432
433 search = talloc_get_type(p, struct pvfs_search_state);
434
435 dir = search->dir;
436
437 status = pvfs_list_seek_ofs(dir, io->search_next.in.id.server_cookie,
438 &search->current_index);
439 if (!NT_STATUS_IS_OK(status)) {
440 return status;
441 }
442 search->last_used = time_mono(NULL);
443
444 status = pvfs_search_fill(pvfs, req, max_count, search, io->generic.data_level,
445 &reply_count, search_private, callback);
446 if (!NT_STATUS_IS_OK(status)) {
447 return status;
448 }
449
450 io->search_next.out.count = reply_count;
451
452 /* not matching any entries means end of search */
453 if (reply_count == 0) {
454 talloc_free(search);
455 }
456
457 return NT_STATUS_OK;
458 }
459
460 /*
461 list files in a directory matching a wildcard pattern
462 */
463 static NTSTATUS pvfs_search_first_trans2(struct ntvfs_module_context *ntvfs,
464 struct ntvfs_request *req, union smb_search_first *io,
465 void *search_private,
466 bool (*callback)(void *, const union smb_search_data *))
467 {
468 struct pvfs_dir *dir;
469 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
470 struct pvfs_state);
471 struct pvfs_search_state *search;
472 unsigned int reply_count;
473 uint16_t search_attrib, max_count;
474 const char *pattern;
475 NTSTATUS status;
476 struct pvfs_filename *name;
477 int id;
478
479 search_attrib = io->t2ffirst.in.search_attrib;
480 pattern = io->t2ffirst.in.pattern;
481 max_count = io->t2ffirst.in.max_count;
482
483 /* resolve the cifs name to a posix name */
484 status = pvfs_resolve_name(pvfs, req, pattern, PVFS_RESOLVE_WILDCARD, &name);
485 if (!NT_STATUS_IS_OK(status)) {
486 return status;
487 }
488
489 if (!name->has_wildcard && !name->exists) {
490 return NT_STATUS_NO_SUCH_FILE;
491 }
492
493 status = pvfs_access_check_parent(pvfs, req, name, SEC_DIR_TRAVERSE | SEC_DIR_LIST);
494 if (!NT_STATUS_IS_OK(status)) {
495 return status;
496 }
497
498 /* we initially make search a child of the request, then if we
499 need to keep it long term we steal it for the private
500 structure */
501 search = talloc(req, struct pvfs_search_state);
502 if (!search) {
503 return NT_STATUS_NO_MEMORY;
504 }
505
506 /* do the actual directory listing */
507 status = pvfs_list_start(pvfs, name, search, &dir);
508 if (!NT_STATUS_IS_OK(status)) {
509 return status;
510 }
511
512 id = idr_get_new(pvfs->search.idtree, search, MAX_SEARCH_HANDLES);
513 if (id == -1) {
514 return NT_STATUS_INSUFFICIENT_RESOURCES;
515 }
516
517 search->pvfs = pvfs;
518 search->handle = id;
519 search->dir = dir;
520 search->current_index = 0;
521 search->search_attrib = search_attrib;
522 search->must_attrib = 0;
523 search->last_used = 0;
524 search->num_ea_names = io->t2ffirst.in.num_names;
525 search->ea_names = io->t2ffirst.in.ea_names;
526 search->te = NULL;
527
528 DLIST_ADD(pvfs->search.list, search);
529 talloc_set_destructor(search, pvfs_search_destructor);
530
531 status = pvfs_search_fill(pvfs, req, max_count, search, io->generic.data_level,
532 &reply_count, search_private, callback);
533 if (!NT_STATUS_IS_OK(status)) {
534 return status;
535 }
536
537 /* not matching any entries is an error */
538 if (reply_count == 0) {
539 return NT_STATUS_NO_SUCH_FILE;
540 }
541
542 io->t2ffirst.out.count = reply_count;
543 io->t2ffirst.out.handle = search->handle;
544 io->t2ffirst.out.end_of_search = pvfs_list_eos(dir, search->current_index) ? 1 : 0;
545
546 /* work out if we are going to keep the search state
547 and allow for a search continue */
548 if ((io->t2ffirst.in.flags & FLAG_TRANS2_FIND_CLOSE) ||
549 ((io->t2ffirst.in.flags & FLAG_TRANS2_FIND_CLOSE_IF_END) &&
550 io->t2ffirst.out.end_of_search)) {
551 talloc_free(search);
552 } else {
553 talloc_steal(pvfs, search);
554 }
555
556 return NT_STATUS_OK;
557 }
558
559 /* continue a search */
560 static NTSTATUS pvfs_search_next_trans2(struct ntvfs_module_context *ntvfs,
561 struct ntvfs_request *req, union smb_search_next *io,
562 void *search_private,
563 bool (*callback)(void *, const union smb_search_data *))
564 {
565 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
566 struct pvfs_state);
567 void *p;
568 struct pvfs_search_state *search;
569 struct pvfs_dir *dir;
570 unsigned int reply_count;
571 uint16_t handle;
572 NTSTATUS status;
573
574 handle = io->t2fnext.in.handle;
575
576 p = idr_find(pvfs->search.idtree, handle);
577 if (p == NULL) {
578 /* we didn't find the search handle */
579 return NT_STATUS_INVALID_HANDLE;
580 }
581
582 search = talloc_get_type(p, struct pvfs_search_state);
583
584 dir = search->dir;
585
586 status = NT_STATUS_OK;
587
588 /* work out what type of continuation is being used */
589 if (io->t2fnext.in.last_name && *io->t2fnext.in.last_name) {
590 status = pvfs_list_seek(dir, io->t2fnext.in.last_name, &search->current_index);
591 if (!NT_STATUS_IS_OK(status) && io->t2fnext.in.resume_key) {
592 status = pvfs_list_seek_ofs(dir, io->t2fnext.in.resume_key,
593 &search->current_index);
594 }
595 } else if (!(io->t2fnext.in.flags & FLAG_TRANS2_FIND_CONTINUE)) {
596 status = pvfs_list_seek_ofs(dir, io->t2fnext.in.resume_key,
597 &search->current_index);
598 }
599 if (!NT_STATUS_IS_OK(status)) {
600 return status;
601 }
602
603 search->num_ea_names = io->t2fnext.in.num_names;
604 search->ea_names = io->t2fnext.in.ea_names;
605
606 status = pvfs_search_fill(pvfs, req, io->t2fnext.in.max_count, search, io->generic.data_level,
607 &reply_count, search_private, callback);
608 if (!NT_STATUS_IS_OK(status)) {
609 return status;
610 }
611
612 io->t2fnext.out.count = reply_count;
613 io->t2fnext.out.end_of_search = pvfs_list_eos(dir, search->current_index) ? 1 : 0;
614
615 /* work out if we are going to keep the search state */
616 if ((io->t2fnext.in.flags & FLAG_TRANS2_FIND_CLOSE) ||
617 ((io->t2fnext.in.flags & FLAG_TRANS2_FIND_CLOSE_IF_END) &&
618 io->t2fnext.out.end_of_search)) {
619 talloc_free(search);
620 }
621
622 return NT_STATUS_OK;
623 }
624
625 static NTSTATUS pvfs_search_first_smb2(struct ntvfs_module_context *ntvfs,
626 struct ntvfs_request *req, const struct smb2_find *io,
627 void *search_private,
628 bool (*callback)(void *, const union smb_search_data *))
629 {
630 struct pvfs_dir *dir;
631 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
632 struct pvfs_state);
633 struct pvfs_search_state *search;
634 unsigned int reply_count;
635 uint16_t max_count;
636 const char *pattern;
637 NTSTATUS status;
638 struct pvfs_filename *name;
639 struct pvfs_file *f;
640
641 f = pvfs_find_fd(pvfs, req, io->in.file.ntvfs);
642 if (!f) {
643 return NT_STATUS_FILE_CLOSED;
644 }
645
646 /* its only valid for directories */
647 if (f->handle->fd != -1) {
648 return NT_STATUS_INVALID_PARAMETER;
649 }
650
651 if (!(f->access_mask & SEC_DIR_LIST)) {
652 return NT_STATUS_ACCESS_DENIED;
653 }
654
655 if (f->search) {
656 talloc_free(f->search);
657 f->search = NULL;
658 }
659
660 if (strequal(io->in.pattern, "")) {
661 return NT_STATUS_OBJECT_NAME_INVALID;
662 }
663 if (strchr_m(io->in.pattern, '\\')) {
664 return NT_STATUS_OBJECT_NAME_INVALID;
665 }
666 if (strchr_m(io->in.pattern, '/')) {
667 return NT_STATUS_OBJECT_NAME_INVALID;
668 }
669
670 if (strequal("", f->handle->name->original_name)) {
671 pattern = talloc_asprintf(req, "%s", io->in.pattern);
672 NT_STATUS_HAVE_NO_MEMORY(pattern);
673 } else {
674 pattern = talloc_asprintf(req, "%s\\%s",
675 f->handle->name->original_name,
676 io->in.pattern);
677 NT_STATUS_HAVE_NO_MEMORY(pattern);
678 }
679
680 /* resolve the cifs name to a posix name */
681 status = pvfs_resolve_name(pvfs, req, pattern, PVFS_RESOLVE_WILDCARD, &name);
682 NT_STATUS_NOT_OK_RETURN(status);
683
684 if (!name->has_wildcard && !name->exists) {
685 return NT_STATUS_NO_SUCH_FILE;
686 }
687
688 /* we initially make search a child of the request, then if we
689 need to keep it long term we steal it for the private
690 structure */
691 search = talloc(req, struct pvfs_search_state);
692 NT_STATUS_HAVE_NO_MEMORY(search);
693
694 /* do the actual directory listing */
695 status = pvfs_list_start(pvfs, name, search, &dir);
696 NT_STATUS_NOT_OK_RETURN(status);
697
698 search->pvfs = pvfs;
699 search->handle = INVALID_SEARCH_HANDLE;
700 search->dir = dir;
701 search->current_index = 0;
702 search->search_attrib = 0x0000FFFF;
703 search->must_attrib = 0;
704 search->last_used = 0;
705 search->num_ea_names = 0;
706 search->ea_names = NULL;
707 search->te = NULL;
708
709 if (io->in.continue_flags & SMB2_CONTINUE_FLAG_SINGLE) {
710 max_count = 1;
711 } else {
712 max_count = UINT16_MAX;
713 }
714
715 status = pvfs_search_fill(pvfs, req, max_count, search, io->data_level,
716 &reply_count, search_private, callback);
717 NT_STATUS_NOT_OK_RETURN(status);
718
719 /* not matching any entries is an error */
720 if (reply_count == 0) {
721 return NT_STATUS_NO_SUCH_FILE;
722 }
723
724 f->search = talloc_steal(f, search);
725
726 return NT_STATUS_OK;
727 }
728
729 static NTSTATUS pvfs_search_next_smb2(struct ntvfs_module_context *ntvfs,
730 struct ntvfs_request *req, const struct smb2_find *io,
731 void *search_private,
732 bool (*callback)(void *, const union smb_search_data *))
733 {
734 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
735 struct pvfs_state);
736 struct pvfs_search_state *search;
737 unsigned int reply_count;
738 uint16_t max_count;
739 NTSTATUS status;
740 struct pvfs_file *f;
741
742 f = pvfs_find_fd(pvfs, req, io->in.file.ntvfs);
743 if (!f) {
744 return NT_STATUS_FILE_CLOSED;
745 }
746
747 /* its only valid for directories */
748 if (f->handle->fd != -1) {
749 return NT_STATUS_INVALID_PARAMETER;
750 }
751
752 /* if there's no search started on the dir handle, it's like a search_first */
753 search = f->search;
754 if (!search) {
755 return pvfs_search_first_smb2(ntvfs, req, io, search_private, callback);
756 }
757
758 if (io->in.continue_flags & SMB2_CONTINUE_FLAG_RESTART) {
759 search->current_index = 0;
760 }
761
762 if (io->in.continue_flags & SMB2_CONTINUE_FLAG_SINGLE) {
763 max_count = 1;
764 } else {
765 max_count = UINT16_MAX;
766 }
767
768 status = pvfs_search_fill(pvfs, req, max_count, search, io->data_level,
769 &reply_count, search_private, callback);
770 NT_STATUS_NOT_OK_RETURN(status);
771
772 /* not matching any entries is an error */
773 if (reply_count == 0) {
774 return STATUS_NO_MORE_FILES;
775 }
776
777 return NT_STATUS_OK;
778 }
779
780 /*
781 list files in a directory matching a wildcard pattern
782 */
783 NTSTATUS pvfs_search_first(struct ntvfs_module_context *ntvfs,
784 struct ntvfs_request *req, union smb_search_first *io,
785 void *search_private,
786 bool (*callback)(void *, const union smb_search_data *))
787 {
788 switch (io->generic.level) {
789 case RAW_SEARCH_SEARCH:
790 case RAW_SEARCH_FFIRST:
791 case RAW_SEARCH_FUNIQUE:
792 return pvfs_search_first_old(ntvfs, req, io, search_private, callback);
793
794 case RAW_SEARCH_TRANS2:
795 return pvfs_search_first_trans2(ntvfs, req, io, search_private, callback);
796
797 case RAW_SEARCH_SMB2:
798 return pvfs_search_first_smb2(ntvfs, req, &io->smb2, search_private, callback);
799 }
800
801 return NT_STATUS_INVALID_LEVEL;
802 }
803
804 /* continue a search */
805 NTSTATUS pvfs_search_next(struct ntvfs_module_context *ntvfs,
806 struct ntvfs_request *req, union smb_search_next *io,
807 void *search_private,
808 bool (*callback)(void *, const union smb_search_data *))
809 {
810 switch (io->generic.level) {
811 case RAW_SEARCH_SEARCH:
812 case RAW_SEARCH_FFIRST:
813 return pvfs_search_next_old(ntvfs, req, io, search_private, callback);
814
815 case RAW_SEARCH_FUNIQUE:
816 return NT_STATUS_INVALID_LEVEL;
817
818 case RAW_SEARCH_TRANS2:
819 return pvfs_search_next_trans2(ntvfs, req, io, search_private, callback);
820
821 case RAW_SEARCH_SMB2:
822 return pvfs_search_next_smb2(ntvfs, req, &io->smb2, search_private, callback);
823 }
824
825 return NT_STATUS_INVALID_LEVEL;
826 }
827
828
829 /* close a search */
830 NTSTATUS pvfs_search_close(struct ntvfs_module_context *ntvfs,
831 struct ntvfs_request *req, union smb_search_close *io)
832 {
833 struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
834 struct pvfs_state);
835 void *p;
836 struct pvfs_search_state *search;
837 uint16_t handle = INVALID_SEARCH_HANDLE;
838
839 switch (io->generic.level) {
840 case RAW_FINDCLOSE_GENERIC:
841 return NT_STATUS_INVALID_LEVEL;
842
843 case RAW_FINDCLOSE_FCLOSE:
844 handle = io->fclose.in.id.handle;
845 break;
846
847 case RAW_FINDCLOSE_FINDCLOSE:
848 handle = io->findclose.in.handle;
849 break;
850 }
851
852 p = idr_find(pvfs->search.idtree, handle);
853 if (p == NULL) {
854 /* we didn't find the search handle */
855 return NT_STATUS_INVALID_HANDLE;
856 }
857
858 search = talloc_get_type(p, struct pvfs_search_state);
859
860 talloc_free(search);
861
862 return NT_STATUS_OK;
863 }
864
Samba GIT mirror