?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:smbd: add generic smbd_dirptr_get_entry()
[Samba/aatanasov.git] / source3 / smbd / dir.c
blob4c802ab893f9f0ab9186a515240d02792d87f440
1 /*
2 Unix SMB/CIFS implementation.
3 Directory handling routines
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2007
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "smbd/globals.h"
23
24 /*
25 This module implements directory related functions for Samba.
26 */
27
28 /* "Special" directory offsets. */
29 #define END_OF_DIRECTORY_OFFSET ((long)-1)
30 #define START_OF_DIRECTORY_OFFSET ((long)0)
31 #define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
32
33 /* Make directory handle internals available. */
34
35 struct name_cache_entry {
36 char *name;
37 long offset;
38 };
39
40 struct smb_Dir {
41 connection_struct *conn;
42 SMB_STRUCT_DIR *dir;
43 long offset;
44 char *dir_path;
45 size_t name_cache_size;
46 struct name_cache_entry *name_cache;
47 unsigned int name_cache_index;
48 unsigned int file_number;
49 };
50
51 struct dptr_struct {
52 struct dptr_struct *next, *prev;
53 int dnum;
54 uint16 spid;
55 struct connection_struct *conn;
56 struct smb_Dir *dir_hnd;
57 bool expect_close;
58 char *wcard;
59 uint32 attr;
60 char *path;
61 bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
62 bool did_stat; /* Optimisation for non-wcard searches. */
63 };
64
65
66 #define INVALID_DPTR_KEY (-3)
67
68 /****************************************************************************
69 Make a dir struct.
70 ****************************************************************************/
71
72 bool make_dir_struct(TALLOC_CTX *ctx,
73 char *buf,
74 const char *mask,
75 const char *fname,
76 SMB_OFF_T size,
77 uint32 mode,
78 time_t date,
79 bool uc)
80 {
81 char *p;
82 char *mask2 = talloc_strdup(ctx, mask);
83
84 if (!mask2) {
85 return False;
86 }
87
88 if ((mode & aDIR) != 0) {
89 size = 0;
90 }
91
92 memset(buf+1,' ',11);
93 if ((p = strchr_m(mask2,'.')) != NULL) {
94 *p = 0;
95 push_ascii(buf+1,mask2,8, 0);
96 push_ascii(buf+9,p+1,3, 0);
97 *p = '.';
98 } else {
99 push_ascii(buf+1,mask2,11, 0);
100 }
101
102 memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
103 SCVAL(buf,21,mode);
104 srv_put_dos_date(buf,22,date);
105 SSVAL(buf,26,size & 0xFFFF);
106 SSVAL(buf,28,(size >> 16)&0xFFFF);
107 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
108 Strange, but verified on W2K3. Needed for OS/2. JRA. */
109 push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
110 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
111 return True;
112 }
113
114 /****************************************************************************
115 Initialise the dir bitmap.
116 ****************************************************************************/
117
118 void init_dptrs(void)
119 {
120 if (dptr_bmap)
121 return;
122
123 dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
124
125 if (!dptr_bmap)
126 exit_server("out of memory in init_dptrs");
127 }
128
129 /****************************************************************************
130 Idle a dptr - the directory is closed but the control info is kept.
131 ****************************************************************************/
132
133 static void dptr_idle(struct dptr_struct *dptr)
134 {
135 if (dptr->dir_hnd) {
136 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
137 TALLOC_FREE(dptr->dir_hnd);
138 }
139 }
140
141 /****************************************************************************
142 Idle the oldest dptr.
143 ****************************************************************************/
144
145 static void dptr_idleoldest(void)
146 {
147 struct dptr_struct *dptr;
148
149 /*
150 * Go to the end of the list.
151 */
152 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
153 ;
154
155 if(!dptr) {
156 DEBUG(0,("No dptrs available to idle ?\n"));
157 return;
158 }
159
160 /*
161 * Idle the oldest pointer.
162 */
163
164 for(; dptr; dptr = dptr->prev) {
165 if (dptr->dir_hnd) {
166 dptr_idle(dptr);
167 return;
168 }
169 }
170 }
171
172 /****************************************************************************
173 Get the struct dptr_struct for a dir index.
174 ****************************************************************************/
175
176 static struct dptr_struct *dptr_get(int key, bool forclose)
177 {
178 struct dptr_struct *dptr;
179
180 for(dptr = dirptrs; dptr; dptr = dptr->next) {
181 if(dptr->dnum == key) {
182 if (!forclose && !dptr->dir_hnd) {
183 if (dirhandles_open >= MAX_OPEN_DIRECTORIES)
184 dptr_idleoldest();
185 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
186 if (!(dptr->dir_hnd = OpenDir(
187 NULL, dptr->conn, dptr->path,
188 dptr->wcard, dptr->attr))) {
189 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
190 strerror(errno)));
191 return False;
192 }
193 }
194 DLIST_PROMOTE(dirptrs,dptr);
195 return dptr;
196 }
197 }
198 return(NULL);
199 }
200
201 /****************************************************************************
202 Get the dir path for a dir index.
203 ****************************************************************************/
204
205 char *dptr_path(int key)
206 {
207 struct dptr_struct *dptr = dptr_get(key, False);
208 if (dptr)
209 return(dptr->path);
210 return(NULL);
211 }
212
213 /****************************************************************************
214 Get the dir wcard for a dir index.
215 ****************************************************************************/
216
217 char *dptr_wcard(int key)
218 {
219 struct dptr_struct *dptr = dptr_get(key, False);
220 if (dptr)
221 return(dptr->wcard);
222 return(NULL);
223 }
224
225 /****************************************************************************
226 Get the dir attrib for a dir index.
227 ****************************************************************************/
228
229 uint16 dptr_attr(int key)
230 {
231 struct dptr_struct *dptr = dptr_get(key, False);
232 if (dptr)
233 return(dptr->attr);
234 return(0);
235 }
236
237 /****************************************************************************
238 Close a dptr (internal func).
239 ****************************************************************************/
240
241 static void dptr_close_internal(struct dptr_struct *dptr)
242 {
243 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
244
245 DLIST_REMOVE(dirptrs, dptr);
246
247 /*
248 * Free the dnum in the bitmap. Remember the dnum value is always
249 * biased by one with respect to the bitmap.
250 */
251
252 if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
253 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
254 dptr->dnum ));
255 }
256
257 bitmap_clear(dptr_bmap, dptr->dnum - 1);
258
259 TALLOC_FREE(dptr->dir_hnd);
260
261 /* Lanman 2 specific code */
262 SAFE_FREE(dptr->wcard);
263 string_set(&dptr->path,"");
264 SAFE_FREE(dptr);
265 }
266
267 /****************************************************************************
268 Close a dptr given a key.
269 ****************************************************************************/
270
271 void dptr_close(int *key)
272 {
273 struct dptr_struct *dptr;
274
275 if(*key == INVALID_DPTR_KEY)
276 return;
277
278 /* OS/2 seems to use -1 to indicate "close all directories" */
279 if (*key == -1) {
280 struct dptr_struct *next;
281 for(dptr = dirptrs; dptr; dptr = next) {
282 next = dptr->next;
283 dptr_close_internal(dptr);
284 }
285 *key = INVALID_DPTR_KEY;
286 return;
287 }
288
289 dptr = dptr_get(*key, True);
290
291 if (!dptr) {
292 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
293 return;
294 }
295
296 dptr_close_internal(dptr);
297
298 *key = INVALID_DPTR_KEY;
299 }
300
301 /****************************************************************************
302 Close all dptrs for a cnum.
303 ****************************************************************************/
304
305 void dptr_closecnum(connection_struct *conn)
306 {
307 struct dptr_struct *dptr, *next;
308 for(dptr = dirptrs; dptr; dptr = next) {
309 next = dptr->next;
310 if (dptr->conn == conn)
311 dptr_close_internal(dptr);
312 }
313 }
314
315 /****************************************************************************
316 Idle all dptrs for a cnum.
317 ****************************************************************************/
318
319 void dptr_idlecnum(connection_struct *conn)
320 {
321 struct dptr_struct *dptr;
322 for(dptr = dirptrs; dptr; dptr = dptr->next) {
323 if (dptr->conn == conn && dptr->dir_hnd)
324 dptr_idle(dptr);
325 }
326 }
327
328 /****************************************************************************
329 Close a dptr that matches a given path, only if it matches the spid also.
330 ****************************************************************************/
331
332 void dptr_closepath(char *path,uint16 spid)
333 {
334 struct dptr_struct *dptr, *next;
335 for(dptr = dirptrs; dptr; dptr = next) {
336 next = dptr->next;
337 if (spid == dptr->spid && strequal(dptr->path,path))
338 dptr_close_internal(dptr);
339 }
340 }
341
342 /****************************************************************************
343 Try and close the oldest handle not marked for
344 expect close in the hope that the client has
345 finished with that one.
346 ****************************************************************************/
347
348 static void dptr_close_oldest(bool old)
349 {
350 struct dptr_struct *dptr;
351
352 /*
353 * Go to the end of the list.
354 */
355 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
356 ;
357
358 if(!dptr) {
359 DEBUG(0,("No old dptrs available to close oldest ?\n"));
360 return;
361 }
362
363 /*
364 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
365 * does not have expect_close set. If 'old' is false, close
366 * one of the new dnum handles.
367 */
368
369 for(; dptr; dptr = dptr->prev) {
370 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
371 (!old && (dptr->dnum > 255))) {
372 dptr_close_internal(dptr);
373 return;
374 }
375 }
376 }
377
378 /****************************************************************************
379 Create a new dir ptr. If the flag old_handle is true then we must allocate
380 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
381 one byte long. If old_handle is false we allocate from the range
382 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
383 a directory handle is never zero.
384 wcard must not be zero.
385 ****************************************************************************/
386
387 NTSTATUS dptr_create(connection_struct *conn, const char *path, bool old_handle, bool expect_close,uint16 spid,
388 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
389 {
390 struct dptr_struct *dptr = NULL;
391 struct smb_Dir *dir_hnd;
392 NTSTATUS status;
393
394 DEBUG(5,("dptr_create dir=%s\n", path));
395
396 if (!wcard) {
397 return NT_STATUS_INVALID_PARAMETER;
398 }
399
400 status = check_name(conn,path);
401 if (!NT_STATUS_IS_OK(status)) {
402 return status;
403 }
404
405 dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
406 if (!dir_hnd) {
407 return map_nt_error_from_unix(errno);
408 }
409
410 string_set(&conn->dirpath,path);
411
412 if (dirhandles_open >= MAX_OPEN_DIRECTORIES) {
413 dptr_idleoldest();
414 }
415
416 dptr = SMB_MALLOC_P(struct dptr_struct);
417 if(!dptr) {
418 DEBUG(0,("malloc fail in dptr_create.\n"));
419 TALLOC_FREE(dir_hnd);
420 return NT_STATUS_NO_MEMORY;
421 }
422
423 ZERO_STRUCTP(dptr);
424
425 if(old_handle) {
426
427 /*
428 * This is an old-style SMBsearch request. Ensure the
429 * value we return will fit in the range 1-255.
430 */
431
432 dptr->dnum = bitmap_find(dptr_bmap, 0);
433
434 if(dptr->dnum == -1 || dptr->dnum > 254) {
435
436 /*
437 * Try and close the oldest handle not marked for
438 * expect close in the hope that the client has
439 * finished with that one.
440 */
441
442 dptr_close_oldest(True);
443
444 /* Now try again... */
445 dptr->dnum = bitmap_find(dptr_bmap, 0);
446 if(dptr->dnum == -1 || dptr->dnum > 254) {
447 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
448 SAFE_FREE(dptr);
449 TALLOC_FREE(dir_hnd);
450 return NT_STATUS_TOO_MANY_OPENED_FILES;
451 }
452 }
453 } else {
454
455 /*
456 * This is a new-style trans2 request. Allocate from
457 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
458 */
459
460 dptr->dnum = bitmap_find(dptr_bmap, 255);
461
462 if(dptr->dnum == -1 || dptr->dnum < 255) {
463
464 /*
465 * Try and close the oldest handle close in the hope that
466 * the client has finished with that one. This will only
467 * happen in the case of the Win98 client bug where it leaks
468 * directory handles.
469 */
470
471 dptr_close_oldest(False);
472
473 /* Now try again... */
474 dptr->dnum = bitmap_find(dptr_bmap, 255);
475
476 if(dptr->dnum == -1 || dptr->dnum < 255) {
477 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
478 SAFE_FREE(dptr);
479 TALLOC_FREE(dir_hnd);
480 return NT_STATUS_TOO_MANY_OPENED_FILES;
481 }
482 }
483 }
484
485 bitmap_set(dptr_bmap, dptr->dnum);
486
487 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
488
489 string_set(&dptr->path,path);
490 dptr->conn = conn;
491 dptr->dir_hnd = dir_hnd;
492 dptr->spid = spid;
493 dptr->expect_close = expect_close;
494 dptr->wcard = SMB_STRDUP(wcard);
495 if (!dptr->wcard) {
496 bitmap_clear(dptr_bmap, dptr->dnum - 1);
497 SAFE_FREE(dptr);
498 TALLOC_FREE(dir_hnd);
499 return NT_STATUS_NO_MEMORY;
500 }
501 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
502 dptr->has_wild = True;
503 } else {
504 dptr->has_wild = wcard_has_wild;
505 }
506
507 dptr->attr = attr;
508
509 DLIST_ADD(dirptrs, dptr);
510
511 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
512 dptr->dnum,path,expect_close));
513
514 *dptr_ret = dptr;
515
516 return NT_STATUS_OK;
517 }
518
519
520 /****************************************************************************
521 Wrapper functions to access the lower level directory handles.
522 ****************************************************************************/
523
524 int dptr_CloseDir(struct dptr_struct *dptr)
525 {
526 DLIST_REMOVE(dirptrs, dptr);
527 TALLOC_FREE(dptr->dir_hnd);
528 return 0;
529 }
530
531 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
532 {
533 SeekDir(dptr->dir_hnd, offset);
534 }
535
536 long dptr_TellDir(struct dptr_struct *dptr)
537 {
538 return TellDir(dptr->dir_hnd);
539 }
540
541 bool dptr_has_wild(struct dptr_struct *dptr)
542 {
543 return dptr->has_wild;
544 }
545
546 int dptr_dnum(struct dptr_struct *dptr)
547 {
548 return dptr->dnum;
549 }
550
551 /****************************************************************************
552 Return the next visible file name, skipping veto'd and invisible files.
553 ****************************************************************************/
554
555 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
556 long *poffset, SMB_STRUCT_STAT *pst)
557 {
558 /* Normal search for the next file. */
559 const char *name;
560 while ((name = ReadDirName(dptr->dir_hnd, poffset, pst)) != NULL) {
561 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
562 return name;
563 }
564 }
565 return NULL;
566 }
567
568 /****************************************************************************
569 Return the next visible file name, skipping veto'd and invisible files.
570 ****************************************************************************/
571
572 char *dptr_ReadDirName(TALLOC_CTX *ctx,
573 struct dptr_struct *dptr,
574 long *poffset,
575 SMB_STRUCT_STAT *pst)
576 {
577 struct smb_filename *smb_fname_base = NULL;
578 char *name = NULL;
579 char *pathreal = NULL;
580 char *found_name = NULL;
581 int ret;
582 const char *name_temp = NULL;
583 NTSTATUS status;
584
585 SET_STAT_INVALID(*pst);
586
587 if (dptr->has_wild || dptr->did_stat) {
588 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
589 name = talloc_strdup(ctx, name_temp);
590 return name;
591 }
592
593 /* If poffset is -1 then we know we returned this name before and we
594 * have no wildcards. We're at the end of the directory. */
595 if (*poffset == END_OF_DIRECTORY_OFFSET) {
596 return NULL;
597 }
598
599 /* We know the stored wcard contains no wildcard characters.
600 * See if we can match with a stat call. If we can't, then set
601 * did_stat to true to ensure we only do this once and keep
602 * searching. */
603
604 dptr->did_stat = true;
605
606 /* First check if it should be visible. */
607 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
608 pst, true))
609 {
610 /* This only returns false if the file was found, but
611 is explicitly not visible. Set us to end of
612 directory, but return NULL as we know we can't ever
613 find it. */
614 goto ret;
615 }
616
617 if (VALID_STAT(*pst)) {
618 name = talloc_strdup(ctx, dptr->wcard);
619 goto ret;
620 }
621
622 pathreal = talloc_asprintf(ctx,
623 "%s/%s",
624 dptr->path,
625 dptr->wcard);
626 if (!pathreal)
627 return NULL;
628
629 /* Create an smb_filename with stream_name == NULL. */
630 status = create_synthetic_smb_fname(ctx, pathreal, NULL, NULL,
631 &smb_fname_base);
632 if (!NT_STATUS_IS_OK(status)) {
633 return NULL;
634 }
635
636 if (SMB_VFS_STAT(dptr->conn, smb_fname_base) == 0) {
637 *pst = smb_fname_base->st;
638 TALLOC_FREE(smb_fname_base);
639 name = talloc_strdup(ctx, dptr->wcard);
640 goto clean;
641 } else {
642 TALLOC_FREE(smb_fname_base);
643 /* If we get any other error than ENOENT or ENOTDIR
644 then the file exists we just can't stat it. */
645 if (errno != ENOENT && errno != ENOTDIR) {
646 name = talloc_strdup(ctx, dptr->wcard);
647 goto clean;
648 }
649 }
650
651 /* Stat failed. We know this is authoratiative if we are
652 * providing case sensitive semantics or the underlying
653 * filesystem is case sensitive.
654 */
655 if (dptr->conn->case_sensitive ||
656 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
657 {
658 goto clean;
659 }
660
661 /*
662 * Try case-insensitive stat if the fs has the ability. This avoids
663 * scanning the whole directory.
664 */
665 ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
666 ctx, &found_name);
667 if (ret == 0) {
668 name = found_name;
669 goto clean;
670 } else if (errno == ENOENT) {
671 /* The case-insensitive lookup was authoritative. */
672 goto clean;
673 }
674
675 TALLOC_FREE(pathreal);
676
677 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst);
678 name = talloc_strdup(ctx, name_temp);
679 return name;
680
681 clean:
682 TALLOC_FREE(pathreal);
683 ret:
684 /* We need to set the underlying dir_hnd offset to -1
685 * also as this function is usually called with the
686 * output from TellDir. */
687 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
688 return name;
689 }
690
691 /****************************************************************************
692 Search for a file by name, skipping veto'ed and not visible files.
693 ****************************************************************************/
694
695 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
696 {
697 SET_STAT_INVALID(*pst);
698
699 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
700 /* This is a singleton directory and we're already at the end. */
701 *poffset = END_OF_DIRECTORY_OFFSET;
702 return False;
703 }
704
705 return SearchDir(dptr->dir_hnd, name, poffset);
706 }
707
708 /****************************************************************************
709 Add the name we're returning into the underlying cache.
710 ****************************************************************************/
711
712 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
713 {
714 DirCacheAdd(dptr->dir_hnd, name, offset);
715 }
716
717 /****************************************************************************
718 Initialize variables & state data at the beginning of all search SMB requests.
719 ****************************************************************************/
720 void dptr_init_search_op(struct dptr_struct *dptr)
721 {
722 SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
723 }
724
725 /****************************************************************************
726 Fill the 5 byte server reserved dptr field.
727 ****************************************************************************/
728
729 bool dptr_fill(char *buf1,unsigned int key)
730 {
731 unsigned char *buf = (unsigned char *)buf1;
732 struct dptr_struct *dptr = dptr_get(key, False);
733 uint32 offset;
734 if (!dptr) {
735 DEBUG(1,("filling null dirptr %d\n",key));
736 return(False);
737 }
738 offset = (uint32)TellDir(dptr->dir_hnd);
739 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
740 (long)dptr->dir_hnd,(int)offset));
741 buf[0] = key;
742 SIVAL(buf,1,offset);
743 return(True);
744 }
745
746 /****************************************************************************
747 Fetch the dir ptr and seek it given the 5 byte server field.
748 ****************************************************************************/
749
750 struct dptr_struct *dptr_fetch(char *buf,int *num)
751 {
752 unsigned int key = *(unsigned char *)buf;
753 struct dptr_struct *dptr = dptr_get(key, False);
754 uint32 offset;
755 long seekoff;
756
757 if (!dptr) {
758 DEBUG(3,("fetched null dirptr %d\n",key));
759 return(NULL);
760 }
761 *num = key;
762 offset = IVAL(buf,1);
763 if (offset == (uint32)-1) {
764 seekoff = END_OF_DIRECTORY_OFFSET;
765 } else {
766 seekoff = (long)offset;
767 }
768 SeekDir(dptr->dir_hnd,seekoff);
769 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
770 key,dptr_path(key),(int)seekoff));
771 return(dptr);
772 }
773
774 /****************************************************************************
775 Fetch the dir ptr.
776 ****************************************************************************/
777
778 struct dptr_struct *dptr_fetch_lanman2(int dptr_num)
779 {
780 struct dptr_struct *dptr = dptr_get(dptr_num, False);
781
782 if (!dptr) {
783 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
784 return(NULL);
785 }
786 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
787 return(dptr);
788 }
789
790 /****************************************************************************
791 Check that a file matches a particular file type.
792 ****************************************************************************/
793
794 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
795 {
796 uint32 mask;
797
798 /* Check the "may have" search bits. */
799 if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
800 return False;
801
802 /* Check the "must have" bits, which are the may have bits shifted eight */
803 /* If must have bit is set, the file/dir can not be returned in search unless the matching
804 file attribute is set */
805 mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
806 if(mask) {
807 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask) /* check if matching attribute present */
808 return True;
809 else
810 return False;
811 }
812
813 return True;
814 }
815
816 static bool mangle_mask_match(connection_struct *conn,
817 const char *filename,
818 const char *mask)
819 {
820 char mname[13];
821
822 if (!name_to_8_3(filename,mname,False,conn->params)) {
823 return False;
824 }
825 return mask_match_search(mname,mask,False);
826 }
827
828 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
829 struct dptr_struct *dirptr,
830 const char *mask,
831 uint32_t dirtype,
832 bool dont_descend,
833 bool ask_sharemode,
834 bool (*match_fn)(TALLOC_CTX *ctx,
835 void *private_data,
836 const char *dname,
837 const char *mask,
838 char **_fname),
839 bool (*mode_fn)(TALLOC_CTX *ctx,
840 void *private_data,
841 struct smb_filename *smb_fname,
842 uint32_t *_mode),
843 void *private_data,
844 char **_fname,
845 struct smb_filename **_smb_fname,
846 uint32_t *_mode,
847 long *_prev_offset)
848 {
849 connection_struct *conn = dirptr->conn;
850 bool needslash;
851
852 *_smb_fname = NULL;
853 *_mode = 0;
854
855 needslash = ( dirptr->path[strlen(dirptr->path) -1] != '/');
856
857 while (true) {
858 long cur_offset;
859 long prev_offset;
860 SMB_STRUCT_STAT sbuf;
861 char *dname = NULL;
862 bool isdots;
863 char *fname = NULL;
864 char *pathreal = NULL;
865 struct smb_filename *smb_fname = NULL;
866 uint32_t mode = 0;
867 bool ok;
868 NTSTATUS status;
869
870 cur_offset = dptr_TellDir(dirptr);
871 prev_offset = cur_offset;
872 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
873
874 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
875 (long)dirptr, cur_offset));
876
877 if (dname == NULL) {
878 return false;
879 }
880
881 isdots = (ISDOT(dname) || ISDOTDOT(dname));
882 if (dont_descend && !isdots) {
883 TALLOC_FREE(dname);
884 continue;
885 }
886
887 /*
888 * fname may get mangled, dname is never mangled.
889 * Whenever we're accessing the filesystem we use
890 * pathreal which is composed from dname.
891 */
892
893 ok = match_fn(ctx, private_data, dname, mask, &fname);
894 if (!ok) {
895 TALLOC_FREE(dname);
896 continue;
897 }
898
899 pathreal = talloc_asprintf(ctx, "%s%s%s",
900 dirptr->path,
901 needslash?"/":"",
902 dname);
903 if (!pathreal) {
904 TALLOC_FREE(dname);
905 TALLOC_FREE(fname);
906 return false;
907 }
908
909 /* Create smb_fname with NULL stream_name. */
910 status = create_synthetic_smb_fname(ctx, pathreal,
911 NULL, &sbuf,
912 &smb_fname);
913 TALLOC_FREE(pathreal);
914 if (!NT_STATUS_IS_OK(status)) {
915 TALLOC_FREE(dname);
916 TALLOC_FREE(fname);
917 return false;
918 }
919
920 ok = mode_fn(ctx, private_data, smb_fname, &mode);
921 if (!ok) {
922 TALLOC_FREE(dname);
923 TALLOC_FREE(fname);
924 TALLOC_FREE(smb_fname);
925 continue;
926 }
927
928 if (!dir_check_ftype(conn, mode, dirtype)) {
929 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
930 fname, (unsigned int)mode, (unsigned int)dirtype));
931 TALLOC_FREE(dname);
932 TALLOC_FREE(fname);
933 TALLOC_FREE(smb_fname);
934 continue;
935 }
936
937 if (ask_sharemode) {
938 struct timespec write_time_ts;
939 struct file_id fileid;
940
941 fileid = vfs_file_id_from_sbuf(conn,
942 &smb_fname->st);
943 get_file_infos(fileid, NULL, &write_time_ts);
944 if (!null_timespec(write_time_ts)) {
945 update_stat_ex_mtime(&smb_fname->st,
946 write_time_ts);
947 }
948 }
949
950 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
951 "fname=%s (%s)\n",
952 mask, smb_fname_str_dbg(smb_fname),
953 dname, fname));
954
955 DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
956
957 TALLOC_FREE(dname);
958
959 *_fname = fname;
960 *_smb_fname = smb_fname;
961 *_mode = mode;
962 *_prev_offset = prev_offset;
963
964 return true;
965 }
966
967 return false;
968 }
969
970 /****************************************************************************
971 Get an 8.3 directory entry.
972 ****************************************************************************/
973
974 bool get_dir_entry(TALLOC_CTX *ctx,
975 connection_struct *conn,
976 const char *mask,
977 uint32 dirtype,
978 char **pp_fname_out,
979 SMB_OFF_T *size,
980 uint32 *mode,
981 struct timespec *date,
982 bool check_descend,
983 bool ask_sharemode)
984 {
985 char *dname = NULL;
986 bool found = False;
987 SMB_STRUCT_STAT sbuf;
988 char *pathreal = NULL;
989 char *filename = NULL;
990 bool needslash;
991
992 *pp_fname_out = NULL;
993
994 needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
995
996 if (!conn->dirptr) {
997 return(False);
998 }
999
1000 while (!found) {
1001 long curoff = dptr_TellDir(conn->dirptr);
1002 dname = dptr_ReadDirName(ctx, conn->dirptr, &curoff, &sbuf);
1003
1004 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
1005 (long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
1006
1007 if (dname == NULL) {
1008 return(False);
1009 }
1010
1011 filename = dname;
1012
1013 /* notice the special *.* handling. This appears to be the only difference
1014 between the wildcard handling in this routine and in the trans2 routines.
1015 see masktest for a demo
1016 */
1017 if ((strcmp(mask,"*.*") == 0) ||
1018 mask_match_search(filename,mask,False) ||
1019 mangle_mask_match(conn,filename,mask)) {
1020 bool isdots = (ISDOT(dname) || ISDOTDOT(dname));
1021 char mname[13];
1022 struct smb_filename *smb_fname = NULL;
1023 NTSTATUS status;
1024
1025 if (!mangle_is_8_3(filename, False, conn->params)) {
1026 if (!name_to_8_3(filename,mname,False,
1027 conn->params)) {
1028 TALLOC_FREE(filename);
1029 continue;
1030 }
1031 filename = talloc_strdup(ctx, mname);
1032 if (!filename) {
1033 return False;
1034 }
1035 }
1036
1037 if (check_descend && !isdots) {
1038 TALLOC_FREE(filename);
1039 continue;
1040 }
1041
1042 if (needslash) {
1043 pathreal = talloc_asprintf(ctx,
1044 "%s/%s",
1045 conn->dirpath,
1046 dname);
1047 } else {
1048 pathreal = talloc_asprintf(ctx,
1049 "%s%s",
1050 conn->dirpath,
1051 dname);
1052 }
1053 if (!pathreal) {
1054 TALLOC_FREE(filename);
1055 return False;
1056 }
1057
1058 /* Create smb_fname with NULL stream_name. */
1059 status = create_synthetic_smb_fname(ctx, pathreal,
1060 NULL, &sbuf,
1061 &smb_fname);
1062
1063 TALLOC_FREE(pathreal);
1064 if (!NT_STATUS_IS_OK(status)) {
1065 TALLOC_FREE(filename);
1066 return false;
1067 }
1068
1069 if (!VALID_STAT(smb_fname->st)) {
1070 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1071 DEBUG(5,("Couldn't stat 1 [%s]. Error "
1072 "= %s\n",
1073 smb_fname_str_dbg(smb_fname),
1074 strerror(errno)));
1075 TALLOC_FREE(smb_fname);
1076 TALLOC_FREE(filename);
1077 continue;
1078 }
1079 }
1080
1081 *mode = dos_mode(conn, smb_fname);
1082
1083 if (!dir_check_ftype(conn,*mode,dirtype)) {
1084 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
1085 TALLOC_FREE(smb_fname);
1086 TALLOC_FREE(filename);
1087 continue;
1088 }
1089
1090 *size = smb_fname->st.st_ex_size;
1091 *date = smb_fname->st.st_ex_mtime;
1092
1093 if (ask_sharemode) {
1094 struct timespec write_time_ts;
1095 struct file_id fileid;
1096
1097 fileid = vfs_file_id_from_sbuf(conn,
1098 &smb_fname->st);
1099 get_file_infos(fileid, NULL, &write_time_ts);
1100 if (!null_timespec(write_time_ts)) {
1101 *date = write_time_ts;
1102 }
1103 }
1104
1105 DEBUG(3,("get_dir_entry mask=[%s] found %s "
1106 "fname=%s (%s)\n",
1107 mask,
1108 smb_fname_str_dbg(smb_fname),
1109 dname,
1110 filename));
1111
1112 found = True;
1113
1114 SMB_ASSERT(filename != NULL);
1115 *pp_fname_out = filename;
1116
1117 DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
1118 TALLOC_FREE(smb_fname);
1119 }
1120
1121 if (!found)
1122 TALLOC_FREE(filename);
1123 }
1124
1125 return(found);
1126 }
1127
1128 /*******************************************************************
1129 Check to see if a user can read a file. This is only approximate,
1130 it is used as part of the "hide unreadable" option. Don't
1131 use it for anything security sensitive.
1132 ********************************************************************/
1133
1134 static bool user_can_read_file(connection_struct *conn,
1135 struct smb_filename *smb_fname)
1136 {
1137 /*
1138 * If user is a member of the Admin group
1139 * we never hide files from them.
1140 */
1141
1142 if (conn->admin_user) {
1143 return True;
1144 }
1145
1146 return can_access_file_acl(conn, smb_fname, FILE_READ_DATA);
1147 }
1148
1149 /*******************************************************************
1150 Check to see if a user can write a file (and only files, we do not
1151 check dirs on this one). This is only approximate,
1152 it is used as part of the "hide unwriteable" option. Don't
1153 use it for anything security sensitive.
1154 ********************************************************************/
1155
1156 static bool user_can_write_file(connection_struct *conn,
1157 const struct smb_filename *smb_fname)
1158 {
1159 /*
1160 * If user is a member of the Admin group
1161 * we never hide files from them.
1162 */
1163
1164 if (conn->admin_user) {
1165 return True;
1166 }
1167
1168 SMB_ASSERT(VALID_STAT(smb_fname->st));
1169
1170 /* Pseudo-open the file */
1171
1172 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1173 return True;
1174 }
1175
1176 return can_write_to_file(conn, smb_fname);
1177 }
1178
1179 /*******************************************************************
1180 Is a file a "special" type ?
1181 ********************************************************************/
1182
1183 static bool file_is_special(connection_struct *conn,
1184 const struct smb_filename *smb_fname)
1185 {
1186 /*
1187 * If user is a member of the Admin group
1188 * we never hide files from them.
1189 */
1190
1191 if (conn->admin_user)
1192 return False;
1193
1194 SMB_ASSERT(VALID_STAT(smb_fname->st));
1195
1196 if (S_ISREG(smb_fname->st.st_ex_mode) ||
1197 S_ISDIR(smb_fname->st.st_ex_mode) ||
1198 S_ISLNK(smb_fname->st.st_ex_mode))
1199 return False;
1200
1201 return True;
1202 }
1203
1204 /*******************************************************************
1205 Should the file be seen by the client?
1206 NOTE: A successful return is no guarantee of the file's existence.
1207 ********************************************************************/
1208
1209 bool is_visible_file(connection_struct *conn, const char *dir_path,
1210 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1211 {
1212 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1213 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1214 bool hide_special = lp_hide_special_files(SNUM(conn));
1215 char *entry = NULL;
1216 struct smb_filename *smb_fname_base = NULL;
1217 NTSTATUS status;
1218 bool ret = false;
1219
1220 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1221 return True; /* . and .. are always visible. */
1222 }
1223
1224 /* If it's a vetoed file, pretend it doesn't even exist */
1225 if (use_veto && IS_VETO_PATH(conn, name)) {
1226 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1227 return False;
1228 }
1229
1230 if (hide_unreadable || hide_unwriteable || hide_special) {
1231 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1232 if (!entry) {
1233 ret = false;
1234 goto out;
1235 }
1236
1237 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1238 if (lp_host_msdfs() &&
1239 lp_msdfs_root(SNUM(conn)) &&
1240 is_msdfs_link(conn, entry, NULL)) {
1241 ret = true;
1242 goto out;
1243 }
1244
1245 /* Create an smb_filename with stream_name == NULL. */
1246 status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1247 pst, &smb_fname_base);
1248 if (!NT_STATUS_IS_OK(status)) {
1249 ret = false;
1250 goto out;
1251 }
1252
1253 /* If the file name does not exist, there's no point checking
1254 * the configuration options. We succeed, on the basis that the
1255 * checks *might* have passed if the file was present.
1256 */
1257 if (!VALID_STAT(*pst)) {
1258 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1259 ret = true;
1260 goto out;
1261 } else {
1262 *pst = smb_fname_base->st;
1263 }
1264 }
1265
1266 /* Honour _hide unreadable_ option */
1267 if (hide_unreadable &&
1268 !user_can_read_file(conn, smb_fname_base)) {
1269 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1270 entry ));
1271 ret = false;
1272 goto out;
1273 }
1274 /* Honour _hide unwriteable_ option */
1275 if (hide_unwriteable && !user_can_write_file(conn,
1276 smb_fname_base)) {
1277 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1278 entry ));
1279 ret = false;
1280 goto out;
1281 }
1282 /* Honour _hide_special_ option */
1283 if (hide_special && file_is_special(conn, smb_fname_base)) {
1284 DEBUG(10,("is_visible_file: file %s is special.\n",
1285 entry ));
1286 ret = false;
1287 goto out;
1288 }
1289 }
1290
1291 ret = true;
1292 out:
1293 TALLOC_FREE(smb_fname_base);
1294 TALLOC_FREE(entry);
1295 return ret;
1296 }
1297
1298 static int smb_Dir_destructor(struct smb_Dir *dirp)
1299 {
1300 if (dirp->dir) {
1301 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1302 }
1303 dirhandles_open--;
1304 return 0;
1305 }
1306
1307 /*******************************************************************
1308 Open a directory.
1309 ********************************************************************/
1310
1311 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1312 const char *name, const char *mask, uint32 attr)
1313 {
1314 struct smb_Dir *dirp = TALLOC_ZERO_P(mem_ctx, struct smb_Dir);
1315
1316 if (!dirp) {
1317 return NULL;
1318 }
1319
1320 dirp->conn = conn;
1321 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1322
1323 dirp->dir_path = talloc_strdup(dirp, name);
1324 if (!dirp->dir_path) {
1325 errno = ENOMEM;
1326 goto fail;
1327 }
1328
1329 dirhandles_open++;
1330 talloc_set_destructor(dirp, smb_Dir_destructor);
1331
1332 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1333 if (!dirp->dir) {
1334 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1335 strerror(errno) ));
1336 goto fail;
1337 }
1338
1339 return dirp;
1340
1341 fail:
1342 TALLOC_FREE(dirp);
1343 return NULL;
1344 }
1345
1346 /*******************************************************************
1347 Read from a directory.
1348 Return directory entry, current offset, and optional stat information.
1349 Don't check for veto or invisible files.
1350 ********************************************************************/
1351
1352 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1353 SMB_STRUCT_STAT *sbuf)
1354 {
1355 const char *n;
1356 connection_struct *conn = dirp->conn;
1357
1358 /* Cheat to allow . and .. to be the first entries returned. */
1359 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1360 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1361 {
1362 if (dirp->file_number == 0) {
1363 n = ".";
1364 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1365 } else {
1366 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1367 n = "..";
1368 }
1369 dirp->file_number++;
1370 return n;
1371 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1372 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1373 return NULL;
1374 } else {
1375 /* A real offset, seek to it. */
1376 SeekDir(dirp, *poffset);
1377 }
1378
1379 while ((n = vfs_readdirname(conn, dirp->dir, sbuf))) {
1380 /* Ignore . and .. - we've already returned them. */
1381 if (*n == '.') {
1382 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1383 continue;
1384 }
1385 }
1386 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1387 dirp->file_number++;
1388 return n;
1389 }
1390 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1391 return NULL;
1392 }
1393
1394 /*******************************************************************
1395 Rewind to the start.
1396 ********************************************************************/
1397
1398 void RewindDir(struct smb_Dir *dirp, long *poffset)
1399 {
1400 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1401 dirp->file_number = 0;
1402 dirp->offset = START_OF_DIRECTORY_OFFSET;
1403 *poffset = START_OF_DIRECTORY_OFFSET;
1404 }
1405
1406 /*******************************************************************
1407 Seek a dir.
1408 ********************************************************************/
1409
1410 void SeekDir(struct smb_Dir *dirp, long offset)
1411 {
1412 if (offset != dirp->offset) {
1413 if (offset == START_OF_DIRECTORY_OFFSET) {
1414 RewindDir(dirp, &offset);
1415 /*
1416 * Ok we should really set the file number here
1417 * to 1 to enable ".." to be returned next. Trouble
1418 * is I'm worried about callers using SeekDir(dirp,0)
1419 * as equivalent to RewindDir(). So leave this alone
1420 * for now.
1421 */
1422 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1423 RewindDir(dirp, &offset);
1424 /*
1425 * Set the file number to 2 - we want to get the first
1426 * real file entry (the one we return after "..")
1427 * on the next ReadDir.
1428 */
1429 dirp->file_number = 2;
1430 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1431 ; /* Don't seek in this case. */
1432 } else {
1433 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1434 }
1435 dirp->offset = offset;
1436 }
1437 }
1438
1439 /*******************************************************************
1440 Tell a dir position.
1441 ********************************************************************/
1442
1443 long TellDir(struct smb_Dir *dirp)
1444 {
1445 return(dirp->offset);
1446 }
1447
1448 /*******************************************************************
1449 Add an entry into the dcache.
1450 ********************************************************************/
1451
1452 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1453 {
1454 struct name_cache_entry *e;
1455
1456 if (dirp->name_cache_size == 0) {
1457 return;
1458 }
1459
1460 if (dirp->name_cache == NULL) {
1461 dirp->name_cache = TALLOC_ZERO_ARRAY(
1462 dirp, struct name_cache_entry, dirp->name_cache_size);
1463
1464 if (dirp->name_cache == NULL) {
1465 return;
1466 }
1467 }
1468
1469 dirp->name_cache_index = (dirp->name_cache_index+1) %
1470 dirp->name_cache_size;
1471 e = &dirp->name_cache[dirp->name_cache_index];
1472 TALLOC_FREE(e->name);
1473 e->name = talloc_strdup(dirp, name);
1474 e->offset = offset;
1475 }
1476
1477 /*******************************************************************
1478 Find an entry by name. Leave us at the offset after it.
1479 Don't check for veto or invisible files.
1480 ********************************************************************/
1481
1482 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1483 {
1484 int i;
1485 const char *entry;
1486 connection_struct *conn = dirp->conn;
1487
1488 /* Search back in the name cache. */
1489 if (dirp->name_cache_size && dirp->name_cache) {
1490 for (i = dirp->name_cache_index; i >= 0; i--) {
1491 struct name_cache_entry *e = &dirp->name_cache[i];
1492 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1493 *poffset = e->offset;
1494 SeekDir(dirp, e->offset);
1495 return True;
1496 }
1497 }
1498 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1499 struct name_cache_entry *e = &dirp->name_cache[i];
1500 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1501 *poffset = e->offset;
1502 SeekDir(dirp, e->offset);
1503 return True;
1504 }
1505 }
1506 }
1507
1508 /* Not found in the name cache. Rewind directory and start from scratch. */
1509 SMB_VFS_REWINDDIR(conn, dirp->dir);
1510 dirp->file_number = 0;
1511 *poffset = START_OF_DIRECTORY_OFFSET;
1512 while ((entry = ReadDirName(dirp, poffset, NULL))) {
1513 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1514 return True;
1515 }
1516 }
1517 return False;
1518 }
1519
1520 /*****************************************************************
1521 Is this directory empty ?
1522 *****************************************************************/
1523
1524 NTSTATUS can_delete_directory(struct connection_struct *conn,
1525 const char *dirname)
1526 {
1527 NTSTATUS status = NT_STATUS_OK;
1528 long dirpos = 0;
1529 const char *dname;
1530 SMB_STRUCT_STAT st;
1531 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn, dirname,
1532 NULL, 0);
1533
1534 if (!dir_hnd) {
1535 return map_nt_error_from_unix(errno);
1536 }
1537
1538 while ((dname = ReadDirName(dir_hnd, &dirpos, &st))) {
1539 /* Quick check for "." and ".." */
1540 if (dname[0] == '.') {
1541 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1542 continue;
1543 }
1544 }
1545
1546 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1547 continue;
1548 }
1549
1550 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1551 dname ));
1552 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1553 break;
1554 }
1555 TALLOC_FREE(dir_hnd);
1556
1557 return status;
1558 }
aatanasov's samba4 branch