2 Unix SMB/CIFS implementation.
3 Directory handling routines
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2007
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.
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.
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/>.
22 #include "system/filesys.h"
23 #include "smbd/smbd.h"
24 #include "smbd/globals.h"
25 #include "libcli/security/security.h"
26 #include "lib/util/bitmap.h"
29 This module implements directory related functions for Samba.
32 /* "Special" directory offsets. */
33 #define END_OF_DIRECTORY_OFFSET ((long)-1)
34 #define START_OF_DIRECTORY_OFFSET ((long)0)
35 #define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
37 /* Make directory handle internals available. */
39 struct name_cache_entry {
45 connection_struct *conn;
49 size_t name_cache_size;
50 struct name_cache_entry *name_cache;
51 unsigned int name_cache_index;
52 unsigned int file_number;
56 struct dptr_struct *next, *prev;
59 struct connection_struct *conn;
60 struct smb_Dir *dir_hnd;
65 bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
66 bool did_stat; /* Optimisation for non-wcard searches. */
67 bool priv; /* Directory handle opened with privilege. */
70 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
75 #define INVALID_DPTR_KEY (-3)
77 /****************************************************************************
79 ****************************************************************************/
81 bool make_dir_struct(TALLOC_CTX *ctx,
91 char *mask2 = talloc_strdup(ctx, mask);
97 if ((mode & FILE_ATTRIBUTE_DIRECTORY) != 0) {
101 memset(buf+1,' ',11);
102 if ((p = strchr_m(mask2,'.')) != NULL) {
104 push_ascii(buf+1,mask2,8, 0);
105 push_ascii(buf+9,p+1,3, 0);
108 push_ascii(buf+1,mask2,11, 0);
111 memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
113 srv_put_dos_date(buf,22,date);
114 SSVAL(buf,26,size & 0xFFFF);
115 SSVAL(buf,28,(size >> 16)&0xFFFF);
116 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
117 Strange, but verified on W2K3. Needed for OS/2. JRA. */
118 push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
119 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
123 /****************************************************************************
124 Initialise the dir bitmap.
125 ****************************************************************************/
127 bool init_dptrs(struct smbd_server_connection *sconn)
129 if (sconn->searches.dptr_bmap) {
133 sconn->searches.dptr_bmap = bitmap_talloc(
134 sconn, MAX_DIRECTORY_HANDLES);
136 if (sconn->searches.dptr_bmap == NULL) {
143 /****************************************************************************
144 Idle a dptr - the directory is closed but the control info is kept.
145 ****************************************************************************/
147 static void dptr_idle(struct dptr_struct *dptr)
150 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
151 TALLOC_FREE(dptr->dir_hnd);
155 /****************************************************************************
156 Idle the oldest dptr.
157 ****************************************************************************/
159 static void dptr_idleoldest(struct smbd_server_connection *sconn)
161 struct dptr_struct *dptr;
164 * Go to the end of the list.
166 dptr = DLIST_TAIL(sconn->searches.dirptrs);
169 DEBUG(0,("No dptrs available to idle ?\n"));
174 * Idle the oldest pointer.
177 for(; dptr; dptr = DLIST_PREV(dptr)) {
185 /****************************************************************************
186 Get the struct dptr_struct for a dir index.
187 ****************************************************************************/
189 static struct dptr_struct *dptr_get(struct smbd_server_connection *sconn,
190 int key, bool forclose)
192 struct dptr_struct *dptr;
194 for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
195 if(dptr->dnum == key) {
196 if (!forclose && !dptr->dir_hnd) {
197 if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES)
198 dptr_idleoldest(sconn);
199 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
200 if (!(dptr->dir_hnd = OpenDir(
201 NULL, dptr->conn, dptr->path,
202 dptr->wcard, dptr->attr))) {
203 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
208 DLIST_PROMOTE(sconn->searches.dirptrs,dptr);
215 /****************************************************************************
216 Get the dir path for a dir index.
217 ****************************************************************************/
219 const char *dptr_path(struct smbd_server_connection *sconn, int key)
221 struct dptr_struct *dptr = dptr_get(sconn, key, false);
227 /****************************************************************************
228 Get the dir wcard for a dir index.
229 ****************************************************************************/
231 const char *dptr_wcard(struct smbd_server_connection *sconn, int key)
233 struct dptr_struct *dptr = dptr_get(sconn, key, false);
239 /****************************************************************************
240 Get the dir attrib for a dir index.
241 ****************************************************************************/
243 uint16 dptr_attr(struct smbd_server_connection *sconn, int key)
245 struct dptr_struct *dptr = dptr_get(sconn, key, false);
251 /****************************************************************************
252 Close a dptr (internal func).
253 ****************************************************************************/
255 static void dptr_close_internal(struct dptr_struct *dptr)
257 struct smbd_server_connection *sconn = dptr->conn->sconn;
259 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
265 if (sconn->using_smb2) {
269 DLIST_REMOVE(sconn->searches.dirptrs, dptr);
272 * Free the dnum in the bitmap. Remember the dnum value is always
273 * biased by one with respect to the bitmap.
276 if (!bitmap_query(sconn->searches.dptr_bmap, dptr->dnum - 1)) {
277 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
281 bitmap_clear(sconn->searches.dptr_bmap, dptr->dnum - 1);
284 TALLOC_FREE(dptr->dir_hnd);
288 /****************************************************************************
289 Close a dptr given a key.
290 ****************************************************************************/
292 void dptr_close(struct smbd_server_connection *sconn, int *key)
294 struct dptr_struct *dptr;
296 if(*key == INVALID_DPTR_KEY)
299 /* OS/2 seems to use -1 to indicate "close all directories" */
301 struct dptr_struct *next;
302 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
304 dptr_close_internal(dptr);
306 *key = INVALID_DPTR_KEY;
310 dptr = dptr_get(sconn, *key, true);
313 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
317 dptr_close_internal(dptr);
319 *key = INVALID_DPTR_KEY;
322 /****************************************************************************
323 Close all dptrs for a cnum.
324 ****************************************************************************/
326 void dptr_closecnum(connection_struct *conn)
328 struct dptr_struct *dptr, *next;
329 struct smbd_server_connection *sconn = conn->sconn;
335 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
337 if (dptr->conn == conn) {
338 dptr_close_internal(dptr);
343 /****************************************************************************
344 Idle all dptrs for a cnum.
345 ****************************************************************************/
347 void dptr_idlecnum(connection_struct *conn)
349 struct dptr_struct *dptr;
350 struct smbd_server_connection *sconn = conn->sconn;
356 for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
357 if (dptr->conn == conn && dptr->dir_hnd) {
363 /****************************************************************************
364 Close a dptr that matches a given path, only if it matches the spid also.
365 ****************************************************************************/
367 void dptr_closepath(struct smbd_server_connection *sconn,
368 char *path,uint16 spid)
370 struct dptr_struct *dptr, *next;
371 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
373 if (spid == dptr->spid && strequal(dptr->path,path))
374 dptr_close_internal(dptr);
378 /****************************************************************************
379 Try and close the oldest handle not marked for
380 expect close in the hope that the client has
381 finished with that one.
382 ****************************************************************************/
384 static void dptr_close_oldest(struct smbd_server_connection *sconn,
387 struct dptr_struct *dptr;
390 * Go to the end of the list.
392 for(dptr = sconn->searches.dirptrs; dptr && dptr->next; dptr = dptr->next)
396 DEBUG(0,("No old dptrs available to close oldest ?\n"));
401 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
402 * does not have expect_close set. If 'old' is false, close
403 * one of the new dnum handles.
406 for(; dptr; dptr = DLIST_PREV(dptr)) {
407 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
408 (!old && (dptr->dnum > 255))) {
409 dptr_close_internal(dptr);
415 /****************************************************************************
416 Create a new dir ptr. If the flag old_handle is true then we must allocate
417 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
418 one byte long. If old_handle is false we allocate from the range
419 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
420 a directory handle is never zero.
421 wcard must not be zero.
422 ****************************************************************************/
424 NTSTATUS dptr_create(connection_struct *conn, files_struct *fsp,
425 const char *path, bool old_handle, bool expect_close,uint16 spid,
426 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
428 struct smbd_server_connection *sconn = conn->sconn;
429 struct dptr_struct *dptr = NULL;
430 struct smb_Dir *dir_hnd;
432 if (fsp && fsp->is_directory && fsp->fh->fd != -1) {
433 path = fsp->fsp_name->base_name;
436 DEBUG(5,("dptr_create dir=%s\n", path));
439 DEBUG(0,("dptr_create: called with fake connection_struct\n"));
440 return NT_STATUS_INTERNAL_ERROR;
444 return NT_STATUS_INVALID_PARAMETER;
448 if (!(fsp->access_mask & SEC_DIR_LIST)) {
449 DEBUG(5,("dptr_create: directory %s "
450 "not open for LIST access\n",
452 return NT_STATUS_ACCESS_DENIED;
454 dir_hnd = OpenDir_fsp(NULL, conn, fsp, wcard, attr);
457 struct smb_filename *smb_dname = NULL;
458 NTSTATUS status = create_synthetic_smb_fname(talloc_tos(),
463 if (!NT_STATUS_IS_OK(status)) {
466 if (lp_posix_pathnames()) {
467 ret = SMB_VFS_LSTAT(conn, smb_dname);
469 ret = SMB_VFS_STAT(conn, smb_dname);
472 return map_nt_error_from_unix(errno);
474 if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
475 return NT_STATUS_NOT_A_DIRECTORY;
477 status = smbd_check_access_rights(conn,
480 if (!NT_STATUS_IS_OK(status)) {
483 dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
487 return map_nt_error_from_unix(errno);
490 if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES) {
491 dptr_idleoldest(sconn);
494 dptr = talloc(NULL, struct dptr_struct);
496 DEBUG(0,("talloc fail in dptr_create.\n"));
497 TALLOC_FREE(dir_hnd);
498 return NT_STATUS_NO_MEMORY;
503 dptr->path = talloc_strdup(dptr, path);
506 TALLOC_FREE(dir_hnd);
507 return NT_STATUS_NO_MEMORY;
510 dptr->dir_hnd = dir_hnd;
512 dptr->expect_close = expect_close;
513 dptr->wcard = talloc_strdup(dptr, wcard);
516 TALLOC_FREE(dir_hnd);
517 return NT_STATUS_NO_MEMORY;
519 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
520 dptr->has_wild = True;
522 dptr->has_wild = wcard_has_wild;
527 if (sconn->using_smb2) {
534 * This is an old-style SMBsearch request. Ensure the
535 * value we return will fit in the range 1-255.
538 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
540 if(dptr->dnum == -1 || dptr->dnum > 254) {
543 * Try and close the oldest handle not marked for
544 * expect close in the hope that the client has
545 * finished with that one.
548 dptr_close_oldest(sconn, true);
550 /* Now try again... */
551 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
552 if(dptr->dnum == -1 || dptr->dnum > 254) {
553 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
555 TALLOC_FREE(dir_hnd);
556 return NT_STATUS_TOO_MANY_OPENED_FILES;
562 * This is a new-style trans2 request. Allocate from
563 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
566 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
568 if(dptr->dnum == -1 || dptr->dnum < 255) {
571 * Try and close the oldest handle close in the hope that
572 * the client has finished with that one. This will only
573 * happen in the case of the Win98 client bug where it leaks
577 dptr_close_oldest(sconn, false);
579 /* Now try again... */
580 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
582 if(dptr->dnum == -1 || dptr->dnum < 255) {
583 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
585 TALLOC_FREE(dir_hnd);
586 return NT_STATUS_TOO_MANY_OPENED_FILES;
591 bitmap_set(sconn->searches.dptr_bmap, dptr->dnum);
593 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
595 DLIST_ADD(sconn->searches.dirptrs, dptr);
598 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
599 dptr->dnum,path,expect_close));
607 /****************************************************************************
608 Wrapper functions to access the lower level directory handles.
609 ****************************************************************************/
611 void dptr_CloseDir(files_struct *fsp)
615 * Ugly hack. We have defined fdopendir to return ENOSYS if dirfd also isn't
616 * present. I hate Solaris. JRA.
619 if (fsp->fh->fd != -1 &&
620 fsp->dptr->dir_hnd &&
621 dirfd(fsp->dptr->dir_hnd->dir)) {
622 /* The call below closes the underlying fd. */
626 dptr_close_internal(fsp->dptr);
631 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
633 SeekDir(dptr->dir_hnd, offset);
636 long dptr_TellDir(struct dptr_struct *dptr)
638 return TellDir(dptr->dir_hnd);
641 bool dptr_has_wild(struct dptr_struct *dptr)
643 return dptr->has_wild;
646 int dptr_dnum(struct dptr_struct *dptr)
651 bool dptr_get_priv(struct dptr_struct *dptr)
656 void dptr_set_priv(struct dptr_struct *dptr)
661 /****************************************************************************
662 Return the next visible file name, skipping veto'd and invisible files.
663 ****************************************************************************/
665 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
666 long *poffset, SMB_STRUCT_STAT *pst,
669 /* Normal search for the next file. */
671 char *talloced = NULL;
673 while ((name = ReadDirName(dptr->dir_hnd, poffset, pst, &talloced))
675 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
676 *ptalloced = talloced;
679 TALLOC_FREE(talloced);
684 /****************************************************************************
685 Return the next visible file name, skipping veto'd and invisible files.
686 ****************************************************************************/
688 char *dptr_ReadDirName(TALLOC_CTX *ctx,
689 struct dptr_struct *dptr,
691 SMB_STRUCT_STAT *pst)
693 struct smb_filename smb_fname_base;
695 const char *name_temp = NULL;
696 char *talloced = NULL;
697 char *pathreal = NULL;
698 char *found_name = NULL;
701 SET_STAT_INVALID(*pst);
703 if (dptr->has_wild || dptr->did_stat) {
704 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst,
706 if (name_temp == NULL) {
709 if (talloced != NULL) {
710 return talloc_move(ctx, &talloced);
712 return talloc_strdup(ctx, name_temp);
715 /* If poffset is -1 then we know we returned this name before and we
716 * have no wildcards. We're at the end of the directory. */
717 if (*poffset == END_OF_DIRECTORY_OFFSET) {
721 /* We know the stored wcard contains no wildcard characters.
722 * See if we can match with a stat call. If we can't, then set
723 * did_stat to true to ensure we only do this once and keep
726 dptr->did_stat = true;
728 /* First check if it should be visible. */
729 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
732 /* This only returns false if the file was found, but
733 is explicitly not visible. Set us to end of
734 directory, but return NULL as we know we can't ever
739 if (VALID_STAT(*pst)) {
740 name = talloc_strdup(ctx, dptr->wcard);
744 pathreal = talloc_asprintf(ctx,
751 /* Create an smb_filename with stream_name == NULL. */
752 ZERO_STRUCT(smb_fname_base);
753 smb_fname_base.base_name = pathreal;
755 if (SMB_VFS_STAT(dptr->conn, &smb_fname_base) == 0) {
756 *pst = smb_fname_base.st;
757 name = talloc_strdup(ctx, dptr->wcard);
760 /* If we get any other error than ENOENT or ENOTDIR
761 then the file exists we just can't stat it. */
762 if (errno != ENOENT && errno != ENOTDIR) {
763 name = talloc_strdup(ctx, dptr->wcard);
768 /* Stat failed. We know this is authoratiative if we are
769 * providing case sensitive semantics or the underlying
770 * filesystem is case sensitive.
772 if (dptr->conn->case_sensitive ||
773 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
779 * Try case-insensitive stat if the fs has the ability. This avoids
780 * scanning the whole directory.
782 ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
787 } else if (errno == ENOENT) {
788 /* The case-insensitive lookup was authoritative. */
792 TALLOC_FREE(pathreal);
794 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst, &talloced);
795 if (name_temp == NULL) {
798 if (talloced != NULL) {
799 return talloc_move(ctx, &talloced);
801 return talloc_strdup(ctx, name_temp);
804 TALLOC_FREE(pathreal);
806 /* We need to set the underlying dir_hnd offset to -1
807 * also as this function is usually called with the
808 * output from TellDir. */
809 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
813 /****************************************************************************
814 Search for a file by name, skipping veto'ed and not visible files.
815 ****************************************************************************/
817 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
819 SET_STAT_INVALID(*pst);
821 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
822 /* This is a singleton directory and we're already at the end. */
823 *poffset = END_OF_DIRECTORY_OFFSET;
827 return SearchDir(dptr->dir_hnd, name, poffset);
830 /****************************************************************************
831 Add the name we're returning into the underlying cache.
832 ****************************************************************************/
834 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
836 DirCacheAdd(dptr->dir_hnd, name, offset);
839 /****************************************************************************
840 Initialize variables & state data at the beginning of all search SMB requests.
841 ****************************************************************************/
842 void dptr_init_search_op(struct dptr_struct *dptr)
844 SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
847 /****************************************************************************
848 Fill the 5 byte server reserved dptr field.
849 ****************************************************************************/
851 bool dptr_fill(struct smbd_server_connection *sconn,
852 char *buf1,unsigned int key)
854 unsigned char *buf = (unsigned char *)buf1;
855 struct dptr_struct *dptr = dptr_get(sconn, key, false);
858 DEBUG(1,("filling null dirptr %d\n",key));
861 offset = (uint32)TellDir(dptr->dir_hnd);
862 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
863 (long)dptr->dir_hnd,(int)offset));
869 /****************************************************************************
870 Fetch the dir ptr and seek it given the 5 byte server field.
871 ****************************************************************************/
873 struct dptr_struct *dptr_fetch(struct smbd_server_connection *sconn,
876 unsigned int key = *(unsigned char *)buf;
877 struct dptr_struct *dptr = dptr_get(sconn, key, false);
882 DEBUG(3,("fetched null dirptr %d\n",key));
886 offset = IVAL(buf,1);
887 if (offset == (uint32)-1) {
888 seekoff = END_OF_DIRECTORY_OFFSET;
890 seekoff = (long)offset;
892 SeekDir(dptr->dir_hnd,seekoff);
893 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
894 key, dptr->path, (int)seekoff));
898 /****************************************************************************
900 ****************************************************************************/
902 struct dptr_struct *dptr_fetch_lanman2(struct smbd_server_connection *sconn,
905 struct dptr_struct *dptr = dptr_get(sconn, dptr_num, false);
908 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
911 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr->path));
915 /****************************************************************************
916 Check that a file matches a particular file type.
917 ****************************************************************************/
919 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
923 /* Check the "may have" search bits. */
924 if (((mode & ~dirtype) & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY)) != 0)
927 /* Check the "must have" bits, which are the may have bits shifted eight */
928 /* If must have bit is set, the file/dir can not be returned in search unless the matching
929 file attribute is set */
930 mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
932 if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM))) == mask) /* check if matching attribute present */
941 static bool mangle_mask_match(connection_struct *conn,
942 const char *filename,
947 if (!name_to_8_3(filename,mname,False,conn->params)) {
950 return mask_match_search(mname,mask,False);
953 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
954 struct dptr_struct *dirptr,
959 bool (*match_fn)(TALLOC_CTX *ctx,
964 bool (*mode_fn)(TALLOC_CTX *ctx,
966 struct smb_filename *smb_fname,
970 struct smb_filename **_smb_fname,
974 connection_struct *conn = dirptr->conn;
980 needslash = ( dirptr->path[strlen(dirptr->path) -1] != '/');
985 SMB_STRUCT_STAT sbuf;
989 char *pathreal = NULL;
990 struct smb_filename smb_fname;
995 cur_offset = dptr_TellDir(dirptr);
996 prev_offset = cur_offset;
997 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
999 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
1000 (long)dirptr, cur_offset));
1002 if (dname == NULL) {
1006 isdots = (ISDOT(dname) || ISDOTDOT(dname));
1007 if (dont_descend && !isdots) {
1013 * fname may get mangled, dname is never mangled.
1014 * Whenever we're accessing the filesystem we use
1015 * pathreal which is composed from dname.
1018 ok = match_fn(ctx, private_data, dname, mask, &fname);
1024 pathreal = talloc_asprintf(ctx, "%s%s%s",
1034 /* Create smb_fname with NULL stream_name. */
1035 ZERO_STRUCT(smb_fname);
1036 smb_fname.base_name = pathreal;
1037 smb_fname.st = sbuf;
1039 ok = mode_fn(ctx, private_data, &smb_fname, &mode);
1043 TALLOC_FREE(pathreal);
1047 if (!dir_check_ftype(conn, mode, dirtype)) {
1048 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1049 fname, (unsigned int)mode, (unsigned int)dirtype));
1052 TALLOC_FREE(pathreal);
1056 if (ask_sharemode) {
1057 struct timespec write_time_ts;
1058 struct file_id fileid;
1060 fileid = vfs_file_id_from_sbuf(conn,
1062 get_file_infos(fileid, 0, NULL, &write_time_ts);
1063 if (!null_timespec(write_time_ts)) {
1064 update_stat_ex_mtime(&smb_fname.st,
1069 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1071 mask, smb_fname_str_dbg(&smb_fname),
1074 DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
1078 status = copy_smb_filename(ctx, &smb_fname, _smb_fname);
1079 TALLOC_FREE(pathreal);
1080 if (!NT_STATUS_IS_OK(status)) {
1085 *_prev_offset = prev_offset;
1093 /****************************************************************************
1094 Get an 8.3 directory entry.
1095 ****************************************************************************/
1097 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1103 connection_struct *conn = (connection_struct *)private_data;
1105 if ((strcmp(mask,"*.*") == 0) ||
1106 mask_match_search(dname, mask, false) ||
1107 mangle_mask_match(conn, dname, mask)) {
1111 if (!mangle_is_8_3(dname, false, conn->params)) {
1112 bool ok = name_to_8_3(dname, mname, false,
1122 *_fname = talloc_strdup(ctx, fname);
1123 if (*_fname == NULL) {
1133 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1135 struct smb_filename *smb_fname,
1138 connection_struct *conn = (connection_struct *)private_data;
1140 if (!VALID_STAT(smb_fname->st)) {
1141 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1142 DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1143 "Couldn't stat [%s]. Error "
1145 smb_fname_str_dbg(smb_fname),
1151 *_mode = dos_mode(conn, smb_fname);
1155 bool get_dir_entry(TALLOC_CTX *ctx,
1156 struct dptr_struct *dirptr,
1162 struct timespec *_date,
1166 connection_struct *conn = dirptr->conn;
1168 struct smb_filename *smb_fname = NULL;
1173 ok = smbd_dirptr_get_entry(ctx,
1179 smbd_dirptr_8_3_match_fn,
1180 smbd_dirptr_8_3_mode_fn,
1190 *_fname = talloc_move(ctx, &fname);
1191 *_size = smb_fname->st.st_ex_size;
1193 *_date = smb_fname->st.st_ex_mtime;
1194 TALLOC_FREE(smb_fname);
1198 /*******************************************************************
1199 Check to see if a user can read a file. This is only approximate,
1200 it is used as part of the "hide unreadable" option. Don't
1201 use it for anything security sensitive.
1202 ********************************************************************/
1204 static bool user_can_read_file(connection_struct *conn,
1205 struct smb_filename *smb_fname)
1208 * Never hide files from the root user.
1209 * We use (uid_t)0 here not sec_initial_uid()
1210 * as make test uses a single user context.
1213 if (get_current_uid(conn) == (uid_t)0) {
1217 return NT_STATUS_IS_OK(smbd_check_access_rights(conn,
1222 /*******************************************************************
1223 Check to see if a user can write a file (and only files, we do not
1224 check dirs on this one). This is only approximate,
1225 it is used as part of the "hide unwriteable" option. Don't
1226 use it for anything security sensitive.
1227 ********************************************************************/
1229 static bool user_can_write_file(connection_struct *conn,
1230 const struct smb_filename *smb_fname)
1233 * Never hide files from the root user.
1234 * We use (uid_t)0 here not sec_initial_uid()
1235 * as make test uses a single user context.
1238 if (get_current_uid(conn) == (uid_t)0) {
1242 SMB_ASSERT(VALID_STAT(smb_fname->st));
1244 /* Pseudo-open the file */
1246 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1250 return can_write_to_file(conn, smb_fname);
1253 /*******************************************************************
1254 Is a file a "special" type ?
1255 ********************************************************************/
1257 static bool file_is_special(connection_struct *conn,
1258 const struct smb_filename *smb_fname)
1261 * Never hide files from the root user.
1262 * We use (uid_t)0 here not sec_initial_uid()
1263 * as make test uses a single user context.
1266 if (get_current_uid(conn) == (uid_t)0) {
1270 SMB_ASSERT(VALID_STAT(smb_fname->st));
1272 if (S_ISREG(smb_fname->st.st_ex_mode) ||
1273 S_ISDIR(smb_fname->st.st_ex_mode) ||
1274 S_ISLNK(smb_fname->st.st_ex_mode))
1280 /*******************************************************************
1281 Should the file be seen by the client?
1282 NOTE: A successful return is no guarantee of the file's existence.
1283 ********************************************************************/
1285 bool is_visible_file(connection_struct *conn, const char *dir_path,
1286 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1288 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1289 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1290 bool hide_special = lp_hide_special_files(SNUM(conn));
1292 struct smb_filename *smb_fname_base = NULL;
1296 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1297 return True; /* . and .. are always visible. */
1300 /* If it's a vetoed file, pretend it doesn't even exist */
1301 if (use_veto && IS_VETO_PATH(conn, name)) {
1302 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1306 if (hide_unreadable || hide_unwriteable || hide_special) {
1307 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1313 /* Create an smb_filename with stream_name == NULL. */
1314 status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1315 pst, &smb_fname_base);
1316 if (!NT_STATUS_IS_OK(status)) {
1321 /* If the file name does not exist, there's no point checking
1322 * the configuration options. We succeed, on the basis that the
1323 * checks *might* have passed if the file was present.
1325 if (!VALID_STAT(*pst)) {
1326 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1330 *pst = smb_fname_base->st;
1334 /* Honour _hide unreadable_ option */
1335 if (hide_unreadable &&
1336 !user_can_read_file(conn, smb_fname_base)) {
1337 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1342 /* Honour _hide unwriteable_ option */
1343 if (hide_unwriteable && !user_can_write_file(conn,
1345 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1350 /* Honour _hide_special_ option */
1351 if (hide_special && file_is_special(conn, smb_fname_base)) {
1352 DEBUG(10,("is_visible_file: file %s is special.\n",
1361 TALLOC_FREE(smb_fname_base);
1366 static int smb_Dir_destructor(struct smb_Dir *dirp)
1370 if (dirp->conn->sconn) {
1371 files_struct *fsp = file_find_fd(dirp->conn->sconn,
1374 /* The call below closes the underlying fd. */
1379 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1381 if (dirp->conn->sconn && !dirp->conn->sconn->using_smb2) {
1382 dirp->conn->sconn->searches.dirhandles_open--;
1387 /*******************************************************************
1389 ********************************************************************/
1391 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1396 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1397 struct smbd_server_connection *sconn = conn->sconn;
1404 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1406 dirp->dir_path = talloc_strdup(dirp, name);
1407 if (!dirp->dir_path) {
1412 if (sconn && !sconn->using_smb2) {
1413 sconn->searches.dirhandles_open++;
1415 talloc_set_destructor(dirp, smb_Dir_destructor);
1417 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1419 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1431 /*******************************************************************
1432 Open a directory from an fsp.
1433 ********************************************************************/
1435 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
1440 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1441 struct smbd_server_connection *sconn = conn->sconn;
1448 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1450 dirp->dir_path = talloc_strdup(dirp, fsp->fsp_name->base_name);
1451 if (!dirp->dir_path) {
1456 if (sconn && !sconn->using_smb2) {
1457 sconn->searches.dirhandles_open++;
1459 talloc_set_destructor(dirp, smb_Dir_destructor);
1461 if (fsp->is_directory && fsp->fh->fd != -1) {
1462 dirp->dir = SMB_VFS_FDOPENDIR(fsp, mask, attr);
1463 if (dirp->dir == NULL) {
1464 DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1468 if (errno != ENOSYS) {
1474 if (dirp->dir == NULL) {
1475 /* FDOPENDIR didn't work. Use OPENDIR instead. */
1476 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1480 DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp->dir_path,
1493 /*******************************************************************
1494 Read from a directory.
1495 Return directory entry, current offset, and optional stat information.
1496 Don't check for veto or invisible files.
1497 ********************************************************************/
1499 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1500 SMB_STRUCT_STAT *sbuf, char **ptalloced)
1503 char *talloced = NULL;
1504 connection_struct *conn = dirp->conn;
1506 /* Cheat to allow . and .. to be the first entries returned. */
1507 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1508 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1510 if (dirp->file_number == 0) {
1512 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1515 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1517 dirp->file_number++;
1520 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1521 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1524 /* A real offset, seek to it. */
1525 SeekDir(dirp, *poffset);
1528 while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1529 /* Ignore . and .. - we've already returned them. */
1531 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1532 TALLOC_FREE(talloced);
1536 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1537 *ptalloced = talloced;
1538 dirp->file_number++;
1541 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1546 /*******************************************************************
1547 Rewind to the start.
1548 ********************************************************************/
1550 void RewindDir(struct smb_Dir *dirp, long *poffset)
1552 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1553 dirp->file_number = 0;
1554 dirp->offset = START_OF_DIRECTORY_OFFSET;
1555 *poffset = START_OF_DIRECTORY_OFFSET;
1558 /*******************************************************************
1560 ********************************************************************/
1562 void SeekDir(struct smb_Dir *dirp, long offset)
1564 if (offset != dirp->offset) {
1565 if (offset == START_OF_DIRECTORY_OFFSET) {
1566 RewindDir(dirp, &offset);
1568 * Ok we should really set the file number here
1569 * to 1 to enable ".." to be returned next. Trouble
1570 * is I'm worried about callers using SeekDir(dirp,0)
1571 * as equivalent to RewindDir(). So leave this alone
1574 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1575 RewindDir(dirp, &offset);
1577 * Set the file number to 2 - we want to get the first
1578 * real file entry (the one we return after "..")
1579 * on the next ReadDir.
1581 dirp->file_number = 2;
1582 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1583 ; /* Don't seek in this case. */
1585 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1587 dirp->offset = offset;
1591 /*******************************************************************
1592 Tell a dir position.
1593 ********************************************************************/
1595 long TellDir(struct smb_Dir *dirp)
1597 return(dirp->offset);
1600 /*******************************************************************
1601 Add an entry into the dcache.
1602 ********************************************************************/
1604 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1606 struct name_cache_entry *e;
1608 if (dirp->name_cache_size == 0) {
1612 if (dirp->name_cache == NULL) {
1613 dirp->name_cache = talloc_zero_array(
1614 dirp, struct name_cache_entry, dirp->name_cache_size);
1616 if (dirp->name_cache == NULL) {
1621 dirp->name_cache_index = (dirp->name_cache_index+1) %
1622 dirp->name_cache_size;
1623 e = &dirp->name_cache[dirp->name_cache_index];
1624 TALLOC_FREE(e->name);
1625 e->name = talloc_strdup(dirp, name);
1629 /*******************************************************************
1630 Find an entry by name. Leave us at the offset after it.
1631 Don't check for veto or invisible files.
1632 ********************************************************************/
1634 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1637 const char *entry = NULL;
1638 char *talloced = NULL;
1639 connection_struct *conn = dirp->conn;
1641 /* Search back in the name cache. */
1642 if (dirp->name_cache_size && dirp->name_cache) {
1643 for (i = dirp->name_cache_index; i >= 0; i--) {
1644 struct name_cache_entry *e = &dirp->name_cache[i];
1645 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1646 *poffset = e->offset;
1647 SeekDir(dirp, e->offset);
1651 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1652 struct name_cache_entry *e = &dirp->name_cache[i];
1653 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1654 *poffset = e->offset;
1655 SeekDir(dirp, e->offset);
1661 /* Not found in the name cache. Rewind directory and start from scratch. */
1662 SMB_VFS_REWINDDIR(conn, dirp->dir);
1663 dirp->file_number = 0;
1664 *poffset = START_OF_DIRECTORY_OFFSET;
1665 while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
1666 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1667 TALLOC_FREE(talloced);
1670 TALLOC_FREE(talloced);
1675 /*****************************************************************
1676 Is this directory empty ?
1677 *****************************************************************/
1679 NTSTATUS can_delete_directory(struct connection_struct *conn,
1680 const char *dirname)
1682 NTSTATUS status = NT_STATUS_OK;
1684 const char *dname = NULL;
1685 char *talloced = NULL;
1687 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
1691 return map_nt_error_from_unix(errno);
1694 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
1695 /* Quick check for "." and ".." */
1696 if (dname[0] == '.') {
1697 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1698 TALLOC_FREE(talloced);
1703 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1704 TALLOC_FREE(talloced);
1708 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1710 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1713 TALLOC_FREE(talloced);
1714 TALLOC_FREE(dir_hnd);