2 Unix SMB/CIFS implementation.
3 Directory handling routines
4 Copyright (C) Andrew Tridgell 1992-1998
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 This module implements directory related functions for Samba.
27 typedef struct _dptr_struct {
28 struct _dptr_struct *next, *prev;
31 connection_struct *conn;
34 char *wcard; /* Field only used for trans2_ searches */
35 uint16 attr; /* Field only used for trans2_ searches */
39 static struct bitmap *dptr_bmap;
40 static dptr_struct *dirptrs;
42 static int dptrs_open = 0;
44 #define INVALID_DPTR_KEY (-3)
46 /****************************************************************************
47 Initialise the dir bitmap.
48 ****************************************************************************/
52 static BOOL dptrs_init=False;
57 dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
60 exit_server("out of memory in init_dptrs");
65 /****************************************************************************
66 Idle a dptr - the directory is closed but the control info is kept.
67 ****************************************************************************/
69 static void dptr_idle(dptr_struct *dptr)
72 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
79 /****************************************************************************
81 ****************************************************************************/
83 static void dptr_idleoldest(void)
88 * Go to the end of the list.
90 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
94 DEBUG(0,("No dptrs available to idle ?\n"));
99 * Idle the oldest pointer.
102 for(; dptr; dptr = dptr->prev) {
110 /****************************************************************************
111 Get the dptr_struct for a dir index.
112 ****************************************************************************/
114 static dptr_struct *dptr_get(int key, BOOL forclose)
118 for(dptr = dirptrs; dptr; dptr = dptr->next) {
119 if(dptr->dnum == key) {
120 if (!forclose && !dptr->ptr) {
121 if (dptrs_open >= MAX_OPEN_DIRECTORIES)
123 DEBUG(4,("Reopening dptr key %d\n",key));
124 if ((dptr->ptr = OpenDir(dptr->conn, dptr->path, True)))
127 DLIST_PROMOTE(dirptrs,dptr);
134 /****************************************************************************
135 Get the dptr ptr for a dir index.
136 ****************************************************************************/
138 static void *dptr_ptr(int key)
140 dptr_struct *dptr = dptr_get(key, False);
147 /****************************************************************************
148 Get the dir path for a dir index.
149 ****************************************************************************/
151 char *dptr_path(int key)
153 dptr_struct *dptr = dptr_get(key, False);
160 /****************************************************************************
161 Get the dir wcard for a dir index (lanman2 specific).
162 ****************************************************************************/
164 char *dptr_wcard(int key)
166 dptr_struct *dptr = dptr_get(key, False);
173 /****************************************************************************
174 Set the dir wcard for a dir index (lanman2 specific).
175 Returns 0 on ok, 1 on fail.
176 ****************************************************************************/
178 BOOL dptr_set_wcard(int key, char *wcard)
180 dptr_struct *dptr = dptr_get(key, False);
189 /****************************************************************************
190 Set the dir attrib for a dir index (lanman2 specific).
191 Returns 0 on ok, 1 on fail.
192 ****************************************************************************/
194 BOOL dptr_set_attr(int key, uint16 attr)
196 dptr_struct *dptr = dptr_get(key, False);
205 /****************************************************************************
206 Get the dir attrib for a dir index (lanman2 specific)
207 ****************************************************************************/
209 uint16 dptr_attr(int key)
211 dptr_struct *dptr = dptr_get(key, False);
218 /****************************************************************************
219 Close a dptr (internal func).
220 ****************************************************************************/
222 static void dptr_close_internal(dptr_struct *dptr)
224 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
226 DLIST_REMOVE(dirptrs, dptr);
229 * Free the dnum in the bitmap. Remember the dnum value is always
230 * biased by one with respect to the bitmap.
233 if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
234 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
238 bitmap_clear(dptr_bmap, dptr->dnum - 1);
245 /* Lanman 2 specific code */
246 SAFE_FREE(dptr->wcard);
247 string_set(&dptr->path,"");
251 /****************************************************************************
252 Close a dptr given a key.
253 ****************************************************************************/
255 void dptr_close(int *key)
259 if(*key == INVALID_DPTR_KEY)
262 /* OS/2 seems to use -1 to indicate "close all directories" */
265 for(dptr = dirptrs; dptr; dptr = next) {
267 dptr_close_internal(dptr);
269 *key = INVALID_DPTR_KEY;
273 dptr = dptr_get(*key, True);
276 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
280 dptr_close_internal(dptr);
282 *key = INVALID_DPTR_KEY;
285 /****************************************************************************
286 Close all dptrs for a cnum.
287 ****************************************************************************/
289 void dptr_closecnum(connection_struct *conn)
291 dptr_struct *dptr, *next;
292 for(dptr = dirptrs; dptr; dptr = next) {
294 if (dptr->conn == conn)
295 dptr_close_internal(dptr);
299 /****************************************************************************
300 Idle all dptrs for a cnum.
301 ****************************************************************************/
303 void dptr_idlecnum(connection_struct *conn)
306 for(dptr = dirptrs; dptr; dptr = dptr->next) {
307 if (dptr->conn == conn && dptr->ptr)
312 /****************************************************************************
313 Close a dptr that matches a given path, only if it matches the spid also.
314 ****************************************************************************/
316 void dptr_closepath(char *path,uint16 spid)
318 dptr_struct *dptr, *next;
319 for(dptr = dirptrs; dptr; dptr = next) {
321 if (spid == dptr->spid && strequal(dptr->path,path))
322 dptr_close_internal(dptr);
326 /****************************************************************************
327 Start a directory listing.
328 ****************************************************************************/
330 static BOOL start_dir(connection_struct *conn, pstring directory)
334 DEBUG(5,("start_dir dir=%s\n",directory));
336 if (!check_name(directory,conn))
339 /* use a const pointer from here on */
345 conn->dirptr = OpenDir(conn, directory, True);
348 string_set(&conn->dirpath,directory);
355 /****************************************************************************
356 Try and close the oldest handle not marked for
357 expect close in the hope that the client has
358 finished with that one.
359 ****************************************************************************/
361 static void dptr_close_oldest(BOOL old)
366 * Go to the end of the list.
368 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
372 DEBUG(0,("No old dptrs available to close oldest ?\n"));
377 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
378 * does not have expect_close set. If 'old' is false, close
379 * one of the new dnum handles.
382 for(; dptr; dptr = dptr->prev) {
383 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
384 (!old && (dptr->dnum > 255))) {
385 dptr_close_internal(dptr);
391 /****************************************************************************
392 Create a new dir ptr. If the flag old_handle is true then we must allocate
393 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
394 one byte long. If old_handle is false we allocate from the range
395 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
396 a directory handle is never zero. All the above is folklore taught to
397 me at Andrew's knee.... :-) :-). JRA.
398 ****************************************************************************/
400 int dptr_create(connection_struct *conn, pstring path, BOOL old_handle, BOOL expect_close,uint16 spid)
404 if (!start_dir(conn,path))
405 return(-2); /* Code to say use a unix error return code. */
407 if (dptrs_open >= MAX_OPEN_DIRECTORIES)
410 dptr = SMB_MALLOC_P(dptr_struct);
412 DEBUG(0,("malloc fail in dptr_create.\n"));
421 * This is an old-style SMBsearch request. Ensure the
422 * value we return will fit in the range 1-255.
425 dptr->dnum = bitmap_find(dptr_bmap, 0);
427 if(dptr->dnum == -1 || dptr->dnum > 254) {
430 * Try and close the oldest handle not marked for
431 * expect close in the hope that the client has
432 * finished with that one.
435 dptr_close_oldest(True);
437 /* Now try again... */
438 dptr->dnum = bitmap_find(dptr_bmap, 0);
439 if(dptr->dnum == -1 || dptr->dnum > 254) {
440 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
448 * This is a new-style trans2 request. Allocate from
449 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
452 dptr->dnum = bitmap_find(dptr_bmap, 255);
454 if(dptr->dnum == -1 || dptr->dnum < 255) {
457 * Try and close the oldest handle close in the hope that
458 * the client has finished with that one. This will only
459 * happen in the case of the Win98 client bug where it leaks
463 dptr_close_oldest(False);
465 /* Now try again... */
466 dptr->dnum = bitmap_find(dptr_bmap, 255);
468 if(dptr->dnum == -1 || dptr->dnum < 255) {
469 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
476 bitmap_set(dptr_bmap, dptr->dnum);
478 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
480 dptr->ptr = conn->dirptr;
481 string_set(&dptr->path,path);
484 dptr->expect_close = expect_close;
485 dptr->wcard = NULL; /* Only used in lanman2 searches */
486 dptr->attr = 0; /* Only used in lanman2 searches */
488 DLIST_ADD(dirptrs, dptr);
490 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
491 dptr->dnum,path,expect_close));
496 /****************************************************************************
497 Fill the 5 byte server reserved dptr field.
498 ****************************************************************************/
500 BOOL dptr_fill(char *buf1,unsigned int key)
502 unsigned char *buf = (unsigned char *)buf1;
503 void *p = dptr_ptr(key);
506 DEBUG(1,("filling null dirptr %d\n",key));
510 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
511 (long)p,(int)offset));
513 SIVAL(buf,1,offset | DPTR_MASK);
517 /****************************************************************************
518 Fetch the dir ptr and seek it given the 5 byte server field.
519 ****************************************************************************/
521 void *dptr_fetch(char *buf,int *num)
523 unsigned int key = *(unsigned char *)buf;
524 void *p = dptr_ptr(key);
528 DEBUG(3,("fetched null dirptr %d\n",key));
532 offset = IVAL(buf,1)&~DPTR_MASK;
534 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
535 key,dptr_path(key),offset));
539 /****************************************************************************
541 ****************************************************************************/
543 void *dptr_fetch_lanman2(int dptr_num)
545 void *p = dptr_ptr(dptr_num);
548 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
551 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
555 /****************************************************************************
556 Check a filetype for being valid.
557 ****************************************************************************/
559 BOOL dir_check_ftype(connection_struct *conn,int mode,SMB_STRUCT_STAT *st,int dirtype)
563 /* Check the "may have" search bits. */
564 if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
567 /* Check the "must have" bits, which are the may have bits shifted eight */
568 /* If must have bit is set, the file/dir can not be returned in search unless the matching
569 file attribute is set */
570 mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
572 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask) /* check if matching attribute present */
581 static BOOL mangle_mask_match(connection_struct *conn, fstring filename, char *mask)
583 mangle_map(filename,True,False,SNUM(conn));
584 return mask_match(filename,mask,False);
587 /****************************************************************************
588 Get an 8.3 directory entry.
589 ****************************************************************************/
591 BOOL get_dir_entry(connection_struct *conn,char *mask,int dirtype, pstring fname,
592 SMB_OFF_T *size,int *mode,time_t *date,BOOL check_descend)
596 SMB_STRUCT_STAT sbuf;
603 *path = *pathreal = *filename = 0;
605 isrootdir = (strequal(conn->dirpath,"./") ||
606 strequal(conn->dirpath,".") ||
607 strequal(conn->dirpath,"/"));
609 needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
615 long curoff = TellDir(conn->dirptr);
616 dname = ReadDirName(conn->dirptr, &curoff);
618 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
619 (long)conn->dirptr,TellDir(conn->dirptr)));
624 pstrcpy(filename,dname);
626 /* notice the special *.* handling. This appears to be the only difference
627 between the wildcard handling in this routine and in the trans2 routines.
628 see masktest for a demo
630 if ((strcmp(mask,"*.*") == 0) ||
631 mask_match(filename,mask,False) ||
632 mangle_mask_match(conn,filename,mask)) {
633 if (isrootdir && (strequal(filename,"..") || strequal(filename,".")))
636 if (!mangle_is_8_3(filename, False))
637 mangle_map(filename,True,False,SNUM(conn));
639 pstrcpy(fname,filename);
641 pstrcpy(path,conn->dirpath);
644 pstrcpy(pathreal,path);
646 pstrcat(pathreal,dname);
647 if (SMB_VFS_STAT(conn, pathreal, &sbuf) != 0) {
648 DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",path, strerror(errno) ));
652 *mode = dos_mode(conn,pathreal,&sbuf);
654 if (!dir_check_ftype(conn,*mode,&sbuf,dirtype)) {
655 DEBUG(5,("[%s] attribs didn't match %x\n",filename,dirtype));
659 *size = sbuf.st_size;
660 *date = sbuf.st_mtime;
662 DEBUG(3,("get_dir_entry mask=[%s] found %s fname=%s\n",mask, pathreal,fname));
671 /*******************************************************************
672 Check to see if a user can read a file. This is only approximate,
673 it is used as part of the "hide unreadable" option. Don't
674 use it for anything security sensitive.
675 ********************************************************************/
677 static BOOL user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
679 extern struct current_user current_user;
680 SEC_DESC *psd = NULL;
685 uint32 access_granted;
688 * If user is a member of the Admin group
689 * we never hide files from them.
692 if (conn->admin_user)
695 /* If we can't stat it does not show it */
696 if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0))
699 /* Pseudo-open the file (note - no fd's created). */
701 if(S_ISDIR(pst->st_mode))
702 fsp = open_directory(conn, name, pst, 0, SET_DENY_MODE(DENY_NONE), (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
705 fsp = open_file_stat(conn, name, pst);
710 /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
711 sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fd,
712 (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
713 close_file(fsp, True);
715 /* No access if SD get failed. */
719 return se_access_check(psd, current_user.nt_user_token, FILE_READ_DATA,
720 &access_granted, &status);
723 /*******************************************************************
724 Check to see if a user can write a file (and only files, we do not
725 check dirs on this one). This is only approximate,
726 it is used as part of the "hide unwriteable" option. Don't
727 use it for anything security sensitive.
728 ********************************************************************/
730 static BOOL user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
732 extern struct current_user current_user;
733 SEC_DESC *psd = NULL;
739 uint32 access_granted;
742 * If user is a member of the Admin group
743 * we never hide files from them.
746 if (conn->admin_user)
749 /* If we can't stat it does not show it */
750 if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0))
753 /* Pseudo-open the file (note - no fd's created). */
755 if(S_ISDIR(pst->st_mode))
758 fsp = open_file_shared1(conn, name, pst, FILE_WRITE_ATTRIBUTES, SET_DENY_MODE(DENY_NONE),
759 (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), FILE_ATTRIBUTE_NORMAL, INTERNAL_OPEN_ONLY,
760 &access_mode, &smb_action);
765 /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
766 sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fd,
767 (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
768 close_file(fsp, False);
770 /* No access if SD get failed. */
774 return se_access_check(psd, current_user.nt_user_token, FILE_WRITE_DATA,
775 &access_granted, &status);
778 /*******************************************************************
779 Is a file a "special" type ?
780 ********************************************************************/
782 static BOOL file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
785 * If user is a member of the Admin group
786 * we never hide files from them.
789 if (conn->admin_user)
792 /* If we can't stat it does not show it */
793 if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0))
796 if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
802 #define NAME_CACHE_SIZE 100
804 struct name_cache_entry {
810 connection_struct *conn;
814 struct name_cache_entry *name_cache;
815 unsigned int name_cache_index;
816 BOOL hide_unreadable;
817 BOOL hide_unwriteable;
823 /*******************************************************************
825 ********************************************************************/
827 void *OpenDir(connection_struct *conn, const char *name, BOOL use_veto)
829 Dir *dirp = SMB_MALLOC_P(Dir);
836 dirp->use_veto = use_veto;
838 dirp->dir_path = SMB_STRDUP(name);
839 if (!dirp->dir_path) {
842 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path);
844 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path, strerror(errno) ));
848 dirp->name_cache = SMB_CALLOC_ARRAY(struct name_cache_entry, NAME_CACHE_SIZE);
849 if (!dirp->name_cache) {
853 dirp->hide_unreadable = lp_hideunreadable(SNUM(conn));
854 dirp->hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
855 dirp->hide_special = lp_hide_special_files(SNUM(conn));
857 return((void *)dirp);
863 SMB_VFS_CLOSEDIR(conn,dirp->dir);
865 SAFE_FREE(dirp->dir_path);
866 SAFE_FREE(dirp->name_cache);
873 /*******************************************************************
875 ********************************************************************/
877 int CloseDir(void *p)
880 Dir *dirp = (Dir *)p;
883 ret = SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
885 SAFE_FREE(dirp->dir_path);
886 if (dirp->name_cache) {
887 for (i = 0; i < NAME_CACHE_SIZE; i++) {
888 SAFE_FREE(dirp->name_cache[i].name);
891 SAFE_FREE(dirp->name_cache);
896 /*******************************************************************
897 Set a directory into an inactive state.
898 ********************************************************************/
900 static void SleepDir(Dir *dirp)
903 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
909 /*******************************************************************
910 Wake a directory into a known state.
911 ********************************************************************/
913 static int WakeDir(Dir *dirp, long offset)
916 dirp->dir = SMB_VFS_OPENDIR(dirp->conn, dirp->dir_path);
918 DEBUG(0,("WakeDir: Can't open %s. %s\n", dirp->dir_path, strerror(errno) ));
919 dirp->finished = True;
923 if (offset != dirp->offset) {
924 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
925 dirp->offset = SMB_VFS_TELLDIR(dirp->conn, dirp->dir);
926 if (dirp->offset != offset) {
927 DEBUG(0,("WakeDir: in path %s. offset changed %ld -> %ld\n",
928 dirp->dir_path, offset, dirp->offset ));
935 /*******************************************************************
936 Read from a directory. Also return current offset.
937 ********************************************************************/
939 const char *ReadDirName(void *p, long *poffset)
942 Dir *dirp = (Dir *)p;
943 connection_struct *conn = dirp->conn;
945 if (WakeDir(dirp, *poffset) == -1) {
949 while ((n = vfs_readdirname(conn, dirp->dir))) {
950 struct name_cache_entry *e;
952 if (!((strcmp(".",n) == 0) || (strcmp("..",n) == 0))) {
953 /* If it's a vetoed file, pretend it doesn't even exist */
954 if (dirp->use_veto && IS_VETO_PATH(conn, n)) {
958 if (dirp->hide_unreadable || dirp->hide_unwriteable || dirp->hide_special) {
963 if (asprintf(&entry, "%s/%s/%s", conn->origpath, dirp->dir_path, n) == -1) {
966 /* Honour _hide unreadable_ option */
967 if (dirp->hide_unreadable && !user_can_read_file(conn, entry, &st)) {
971 /* Honour _hide unwriteable_ option */
972 if (dirp->hide_unwriteable && !user_can_write_file(conn, entry, &st)) {
976 /* Honour _hide_special_ option */
977 if (dirp->hide_special && !file_is_special(conn, entry, &st)) {
985 dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
986 if (dirp->offset == -1) {
989 dirp->name_cache_index = (dirp->name_cache_index+1) % NAME_CACHE_SIZE;
991 e = &dirp->name_cache[dirp->name_cache_index];
993 e->name = SMB_STRDUP(n);
994 *poffset = e->offset= dirp->offset;
998 dirp->finished = True;
1003 /*******************************************************************
1005 ********************************************************************/
1007 BOOL SeekDir(void *p,long offset)
1009 Dir *dirp = (Dir *)p;
1010 return (WakeDir(dirp, offset) != -1);
1013 /*******************************************************************
1014 Tell a dir position.
1015 ********************************************************************/
1017 long TellDir(void *p)
1019 Dir *dirp = (Dir *)p;
1020 return(dirp->offset);
1023 /*******************************************************************
1024 Find an entry by name. Leave us at the offset after it.
1025 ********************************************************************/
1027 BOOL SearchDir(void *p, const char *name, long *poffset, BOOL case_sensitive)
1030 Dir *dirp = (Dir *)p;
1032 connection_struct *conn = dirp->conn;
1034 /* Re-create dir but don't seek. */
1035 if (WakeDir(dirp, dirp->offset) == -1) {
1039 /* Search back in the name cache. */
1040 for (i = dirp->name_cache_index; i >= 0; i--) {
1041 struct name_cache_entry *e = &dirp->name_cache[i];
1042 if (e->name && (case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1043 *poffset = e->offset;
1044 WakeDir(dirp, e->offset);
1048 for (i = NAME_CACHE_SIZE-1; i > dirp->name_cache_index; i--) {
1049 struct name_cache_entry *e = &dirp->name_cache[i];
1050 if (e->name && (case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1051 *poffset = e->offset;
1052 WakeDir(dirp, e->offset);
1057 /* Not found in the name cache. Rewind directory and start from scratch. */
1058 SMB_VFS_REWINDDIR(conn, dirp->dir);
1060 while ((entry = ReadDirName(dirp, poffset))) {
1061 if (case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {