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. */
69 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
74 #define INVALID_DPTR_KEY (-3)
76 /****************************************************************************
78 ****************************************************************************/
80 bool make_dir_struct(TALLOC_CTX *ctx,
90 char *mask2 = talloc_strdup(ctx, mask);
96 if ((mode & FILE_ATTRIBUTE_DIRECTORY) != 0) {
100 memset(buf+1,' ',11);
101 if ((p = strchr_m(mask2,'.')) != NULL) {
103 push_ascii(buf+1,mask2,8, 0);
104 push_ascii(buf+9,p+1,3, 0);
107 push_ascii(buf+1,mask2,11, 0);
110 memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
112 srv_put_dos_date(buf,22,date);
113 SSVAL(buf,26,size & 0xFFFF);
114 SSVAL(buf,28,(size >> 16)&0xFFFF);
115 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
116 Strange, but verified on W2K3. Needed for OS/2. JRA. */
117 push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
118 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
122 /****************************************************************************
123 Initialise the dir bitmap.
124 ****************************************************************************/
126 bool init_dptrs(struct smbd_server_connection *sconn)
128 if (sconn->searches.dptr_bmap) {
132 sconn->searches.dptr_bmap = bitmap_talloc(
133 sconn, MAX_DIRECTORY_HANDLES);
135 if (sconn->searches.dptr_bmap == NULL) {
142 /****************************************************************************
143 Idle a dptr - the directory is closed but the control info is kept.
144 ****************************************************************************/
146 static void dptr_idle(struct dptr_struct *dptr)
149 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
150 TALLOC_FREE(dptr->dir_hnd);
154 /****************************************************************************
155 Idle the oldest dptr.
156 ****************************************************************************/
158 static void dptr_idleoldest(struct smbd_server_connection *sconn)
160 struct dptr_struct *dptr;
163 * Go to the end of the list.
165 dptr = DLIST_TAIL(sconn->searches.dirptrs);
168 DEBUG(0,("No dptrs available to idle ?\n"));
173 * Idle the oldest pointer.
176 for(; dptr; dptr = DLIST_PREV(dptr)) {
184 /****************************************************************************
185 Get the struct dptr_struct for a dir index.
186 ****************************************************************************/
188 static struct dptr_struct *dptr_get(struct smbd_server_connection *sconn,
189 int key, bool forclose)
191 struct dptr_struct *dptr;
193 for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
194 if(dptr->dnum == key) {
195 if (!forclose && !dptr->dir_hnd) {
196 if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES)
197 dptr_idleoldest(sconn);
198 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
199 if (!(dptr->dir_hnd = OpenDir(
200 NULL, dptr->conn, dptr->path,
201 dptr->wcard, dptr->attr))) {
202 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
207 DLIST_PROMOTE(sconn->searches.dirptrs,dptr);
214 /****************************************************************************
215 Get the dir path for a dir index.
216 ****************************************************************************/
218 char *dptr_path(struct smbd_server_connection *sconn, int key)
220 struct dptr_struct *dptr = dptr_get(sconn, key, false);
226 /****************************************************************************
227 Get the dir wcard for a dir index.
228 ****************************************************************************/
230 char *dptr_wcard(struct smbd_server_connection *sconn, int key)
232 struct dptr_struct *dptr = dptr_get(sconn, key, false);
238 /****************************************************************************
239 Get the dir attrib for a dir index.
240 ****************************************************************************/
242 uint16 dptr_attr(struct smbd_server_connection *sconn, int key)
244 struct dptr_struct *dptr = dptr_get(sconn, key, false);
250 /****************************************************************************
251 Close a dptr (internal func).
252 ****************************************************************************/
254 static void dptr_close_internal(struct dptr_struct *dptr)
256 struct smbd_server_connection *sconn = dptr->conn->sconn;
258 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
264 DLIST_REMOVE(sconn->searches.dirptrs, dptr);
267 * Free the dnum in the bitmap. Remember the dnum value is always
268 * biased by one with respect to the bitmap.
271 if (!bitmap_query(sconn->searches.dptr_bmap, dptr->dnum - 1)) {
272 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
276 bitmap_clear(sconn->searches.dptr_bmap, dptr->dnum - 1);
279 TALLOC_FREE(dptr->dir_hnd);
281 /* Lanman 2 specific code */
282 SAFE_FREE(dptr->wcard);
283 string_set(&dptr->path,"");
287 /****************************************************************************
288 Close a dptr given a key.
289 ****************************************************************************/
291 void dptr_close(struct smbd_server_connection *sconn, int *key)
293 struct dptr_struct *dptr;
295 if(*key == INVALID_DPTR_KEY)
298 /* OS/2 seems to use -1 to indicate "close all directories" */
300 struct dptr_struct *next;
301 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
303 dptr_close_internal(dptr);
305 *key = INVALID_DPTR_KEY;
309 dptr = dptr_get(sconn, *key, true);
312 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
316 dptr_close_internal(dptr);
318 *key = INVALID_DPTR_KEY;
321 /****************************************************************************
322 Close all dptrs for a cnum.
323 ****************************************************************************/
325 void dptr_closecnum(connection_struct *conn)
327 struct dptr_struct *dptr, *next;
328 struct smbd_server_connection *sconn = conn->sconn;
334 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
336 if (dptr->conn == conn) {
337 dptr_close_internal(dptr);
342 /****************************************************************************
343 Idle all dptrs for a cnum.
344 ****************************************************************************/
346 void dptr_idlecnum(connection_struct *conn)
348 struct dptr_struct *dptr;
349 struct smbd_server_connection *sconn = conn->sconn;
355 for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
356 if (dptr->conn == conn && dptr->dir_hnd) {
362 /****************************************************************************
363 Close a dptr that matches a given path, only if it matches the spid also.
364 ****************************************************************************/
366 void dptr_closepath(struct smbd_server_connection *sconn,
367 char *path,uint16 spid)
369 struct dptr_struct *dptr, *next;
370 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
372 if (spid == dptr->spid && strequal(dptr->path,path))
373 dptr_close_internal(dptr);
377 /****************************************************************************
378 Try and close the oldest handle not marked for
379 expect close in the hope that the client has
380 finished with that one.
381 ****************************************************************************/
383 static void dptr_close_oldest(struct smbd_server_connection *sconn,
386 struct dptr_struct *dptr;
389 * Go to the end of the list.
391 for(dptr = sconn->searches.dirptrs; dptr && dptr->next; dptr = dptr->next)
395 DEBUG(0,("No old dptrs available to close oldest ?\n"));
400 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
401 * does not have expect_close set. If 'old' is false, close
402 * one of the new dnum handles.
405 for(; dptr; dptr = DLIST_PREV(dptr)) {
406 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
407 (!old && (dptr->dnum > 255))) {
408 dptr_close_internal(dptr);
414 /****************************************************************************
415 Create a new dir ptr. If the flag old_handle is true then we must allocate
416 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
417 one byte long. If old_handle is false we allocate from the range
418 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
419 a directory handle is never zero.
420 wcard must not be zero.
421 ****************************************************************************/
423 NTSTATUS dptr_create(connection_struct *conn, files_struct *fsp,
424 const char *path, bool old_handle, bool expect_close,uint16 spid,
425 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
427 struct smbd_server_connection *sconn = conn->sconn;
428 struct dptr_struct *dptr = NULL;
429 struct smb_Dir *dir_hnd;
431 if (fsp && fsp->is_directory && fsp->fh->fd != -1) {
432 path = fsp->fsp_name->base_name;
435 DEBUG(5,("dptr_create dir=%s\n", path));
438 DEBUG(0,("dptr_create: called with fake connection_struct\n"));
439 return NT_STATUS_INTERNAL_ERROR;
443 return NT_STATUS_INVALID_PARAMETER;
447 dir_hnd = OpenDir_fsp(NULL, conn, fsp, wcard, attr);
449 dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
453 return map_nt_error_from_unix(errno);
456 if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES) {
457 dptr_idleoldest(sconn);
460 dptr = SMB_MALLOC_P(struct dptr_struct);
462 DEBUG(0,("malloc fail in dptr_create.\n"));
463 TALLOC_FREE(dir_hnd);
464 return NT_STATUS_NO_MEMORY;
472 * This is an old-style SMBsearch request. Ensure the
473 * value we return will fit in the range 1-255.
476 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
478 if(dptr->dnum == -1 || dptr->dnum > 254) {
481 * Try and close the oldest handle not marked for
482 * expect close in the hope that the client has
483 * finished with that one.
486 dptr_close_oldest(sconn, true);
488 /* Now try again... */
489 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
490 if(dptr->dnum == -1 || dptr->dnum > 254) {
491 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
493 TALLOC_FREE(dir_hnd);
494 return NT_STATUS_TOO_MANY_OPENED_FILES;
500 * This is a new-style trans2 request. Allocate from
501 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
504 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
506 if(dptr->dnum == -1 || dptr->dnum < 255) {
509 * Try and close the oldest handle close in the hope that
510 * the client has finished with that one. This will only
511 * happen in the case of the Win98 client bug where it leaks
515 dptr_close_oldest(sconn, false);
517 /* Now try again... */
518 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
520 if(dptr->dnum == -1 || dptr->dnum < 255) {
521 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
523 TALLOC_FREE(dir_hnd);
524 return NT_STATUS_TOO_MANY_OPENED_FILES;
529 bitmap_set(sconn->searches.dptr_bmap, dptr->dnum);
531 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
533 string_set(&dptr->path,path);
535 dptr->dir_hnd = dir_hnd;
537 dptr->expect_close = expect_close;
538 dptr->wcard = SMB_STRDUP(wcard);
540 bitmap_clear(sconn->searches.dptr_bmap, dptr->dnum - 1);
542 TALLOC_FREE(dir_hnd);
543 return NT_STATUS_NO_MEMORY;
545 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
546 dptr->has_wild = True;
548 dptr->has_wild = wcard_has_wild;
553 DLIST_ADD(sconn->searches.dirptrs, dptr);
555 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
556 dptr->dnum,path,expect_close));
564 /****************************************************************************
565 Wrapper functions to access the lower level directory handles.
566 ****************************************************************************/
568 void dptr_CloseDir(files_struct *fsp)
572 * Ugly hack. We have defined fdopendir to return ENOSYS if dirfd also isn't
573 * present. I hate Solaris. JRA.
576 if (fsp->fh->fd != -1 &&
577 fsp->dptr->dir_hnd &&
578 dirfd(fsp->dptr->dir_hnd->dir)) {
579 /* The call below closes the underlying fd. */
583 dptr_close_internal(fsp->dptr);
588 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
590 SeekDir(dptr->dir_hnd, offset);
593 long dptr_TellDir(struct dptr_struct *dptr)
595 return TellDir(dptr->dir_hnd);
598 bool dptr_has_wild(struct dptr_struct *dptr)
600 return dptr->has_wild;
603 int dptr_dnum(struct dptr_struct *dptr)
608 /****************************************************************************
609 Return the next visible file name, skipping veto'd and invisible files.
610 ****************************************************************************/
612 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
613 long *poffset, SMB_STRUCT_STAT *pst,
616 /* Normal search for the next file. */
618 char *talloced = NULL;
620 while ((name = ReadDirName(dptr->dir_hnd, poffset, pst, &talloced))
622 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
623 *ptalloced = talloced;
626 TALLOC_FREE(talloced);
631 /****************************************************************************
632 Return the next visible file name, skipping veto'd and invisible files.
633 ****************************************************************************/
635 char *dptr_ReadDirName(TALLOC_CTX *ctx,
636 struct dptr_struct *dptr,
638 SMB_STRUCT_STAT *pst)
640 struct smb_filename smb_fname_base;
642 const char *name_temp = NULL;
643 char *talloced = NULL;
644 char *pathreal = NULL;
645 char *found_name = NULL;
648 SET_STAT_INVALID(*pst);
650 if (dptr->has_wild || dptr->did_stat) {
651 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst,
653 if (name_temp == NULL) {
656 if (talloced != NULL) {
657 return talloc_move(ctx, &talloced);
659 return talloc_strdup(ctx, name_temp);
662 /* If poffset is -1 then we know we returned this name before and we
663 * have no wildcards. We're at the end of the directory. */
664 if (*poffset == END_OF_DIRECTORY_OFFSET) {
668 /* We know the stored wcard contains no wildcard characters.
669 * See if we can match with a stat call. If we can't, then set
670 * did_stat to true to ensure we only do this once and keep
673 dptr->did_stat = true;
675 /* First check if it should be visible. */
676 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
679 /* This only returns false if the file was found, but
680 is explicitly not visible. Set us to end of
681 directory, but return NULL as we know we can't ever
686 if (VALID_STAT(*pst)) {
687 name = talloc_strdup(ctx, dptr->wcard);
691 pathreal = talloc_asprintf(ctx,
698 /* Create an smb_filename with stream_name == NULL. */
699 ZERO_STRUCT(smb_fname_base);
700 smb_fname_base.base_name = pathreal;
702 if (SMB_VFS_STAT(dptr->conn, &smb_fname_base) == 0) {
703 *pst = smb_fname_base.st;
704 name = talloc_strdup(ctx, dptr->wcard);
707 /* If we get any other error than ENOENT or ENOTDIR
708 then the file exists we just can't stat it. */
709 if (errno != ENOENT && errno != ENOTDIR) {
710 name = talloc_strdup(ctx, dptr->wcard);
715 /* Stat failed. We know this is authoratiative if we are
716 * providing case sensitive semantics or the underlying
717 * filesystem is case sensitive.
719 if (dptr->conn->case_sensitive ||
720 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
726 * Try case-insensitive stat if the fs has the ability. This avoids
727 * scanning the whole directory.
729 ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
734 } else if (errno == ENOENT) {
735 /* The case-insensitive lookup was authoritative. */
739 TALLOC_FREE(pathreal);
741 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst, &talloced);
742 if (name_temp == NULL) {
745 if (talloced != NULL) {
746 return talloc_move(ctx, &talloced);
748 return talloc_strdup(ctx, name_temp);
751 TALLOC_FREE(pathreal);
753 /* We need to set the underlying dir_hnd offset to -1
754 * also as this function is usually called with the
755 * output from TellDir. */
756 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
760 /****************************************************************************
761 Search for a file by name, skipping veto'ed and not visible files.
762 ****************************************************************************/
764 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
766 SET_STAT_INVALID(*pst);
768 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
769 /* This is a singleton directory and we're already at the end. */
770 *poffset = END_OF_DIRECTORY_OFFSET;
774 return SearchDir(dptr->dir_hnd, name, poffset);
777 /****************************************************************************
778 Add the name we're returning into the underlying cache.
779 ****************************************************************************/
781 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
783 DirCacheAdd(dptr->dir_hnd, name, offset);
786 /****************************************************************************
787 Initialize variables & state data at the beginning of all search SMB requests.
788 ****************************************************************************/
789 void dptr_init_search_op(struct dptr_struct *dptr)
791 SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
794 /****************************************************************************
795 Fill the 5 byte server reserved dptr field.
796 ****************************************************************************/
798 bool dptr_fill(struct smbd_server_connection *sconn,
799 char *buf1,unsigned int key)
801 unsigned char *buf = (unsigned char *)buf1;
802 struct dptr_struct *dptr = dptr_get(sconn, key, false);
805 DEBUG(1,("filling null dirptr %d\n",key));
808 offset = (uint32)TellDir(dptr->dir_hnd);
809 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
810 (long)dptr->dir_hnd,(int)offset));
816 /****************************************************************************
817 Fetch the dir ptr and seek it given the 5 byte server field.
818 ****************************************************************************/
820 struct dptr_struct *dptr_fetch(struct smbd_server_connection *sconn,
823 unsigned int key = *(unsigned char *)buf;
824 struct dptr_struct *dptr = dptr_get(sconn, key, false);
829 DEBUG(3,("fetched null dirptr %d\n",key));
833 offset = IVAL(buf,1);
834 if (offset == (uint32)-1) {
835 seekoff = END_OF_DIRECTORY_OFFSET;
837 seekoff = (long)offset;
839 SeekDir(dptr->dir_hnd,seekoff);
840 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
841 key, dptr->path, (int)seekoff));
845 /****************************************************************************
847 ****************************************************************************/
849 struct dptr_struct *dptr_fetch_lanman2(struct smbd_server_connection *sconn,
852 struct dptr_struct *dptr = dptr_get(sconn, dptr_num, false);
855 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
858 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr->path));
862 /****************************************************************************
863 Check that a file matches a particular file type.
864 ****************************************************************************/
866 bool dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
870 /* Check the "may have" search bits. */
871 if (((mode & ~dirtype) & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_DIRECTORY)) != 0)
874 /* Check the "must have" bits, which are the may have bits shifted eight */
875 /* If must have bit is set, the file/dir can not be returned in search unless the matching
876 file attribute is set */
877 mask = ((dirtype >> 8) & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM)); /* & 0x37 */
879 if((mask & (mode & (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_ARCHIVE|FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM))) == mask) /* check if matching attribute present */
888 static bool mangle_mask_match(connection_struct *conn,
889 const char *filename,
894 if (!name_to_8_3(filename,mname,False,conn->params)) {
897 return mask_match_search(mname,mask,False);
900 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
901 struct dptr_struct *dirptr,
906 bool (*match_fn)(TALLOC_CTX *ctx,
911 bool (*mode_fn)(TALLOC_CTX *ctx,
913 struct smb_filename *smb_fname,
917 struct smb_filename **_smb_fname,
921 connection_struct *conn = dirptr->conn;
927 needslash = ( dirptr->path[strlen(dirptr->path) -1] != '/');
932 SMB_STRUCT_STAT sbuf;
936 char *pathreal = NULL;
937 struct smb_filename smb_fname;
942 cur_offset = dptr_TellDir(dirptr);
943 prev_offset = cur_offset;
944 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
946 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
947 (long)dirptr, cur_offset));
953 isdots = (ISDOT(dname) || ISDOTDOT(dname));
954 if (dont_descend && !isdots) {
960 * fname may get mangled, dname is never mangled.
961 * Whenever we're accessing the filesystem we use
962 * pathreal which is composed from dname.
965 ok = match_fn(ctx, private_data, dname, mask, &fname);
971 pathreal = talloc_asprintf(ctx, "%s%s%s",
981 /* Create smb_fname with NULL stream_name. */
982 ZERO_STRUCT(smb_fname);
983 smb_fname.base_name = pathreal;
986 ok = mode_fn(ctx, private_data, &smb_fname, &mode);
990 TALLOC_FREE(pathreal);
994 if (!dir_check_ftype(conn, mode, dirtype)) {
995 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
996 fname, (unsigned int)mode, (unsigned int)dirtype));
999 TALLOC_FREE(pathreal);
1003 if (ask_sharemode) {
1004 struct timespec write_time_ts;
1005 struct file_id fileid;
1007 fileid = vfs_file_id_from_sbuf(conn,
1009 get_file_infos(fileid, 0, NULL, &write_time_ts);
1010 if (!null_timespec(write_time_ts)) {
1011 update_stat_ex_mtime(&smb_fname.st,
1016 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1018 mask, smb_fname_str_dbg(&smb_fname),
1021 DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
1025 status = copy_smb_filename(ctx, &smb_fname, _smb_fname);
1026 TALLOC_FREE(pathreal);
1027 if (!NT_STATUS_IS_OK(status)) {
1032 *_prev_offset = prev_offset;
1040 /****************************************************************************
1041 Get an 8.3 directory entry.
1042 ****************************************************************************/
1044 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1050 connection_struct *conn = (connection_struct *)private_data;
1052 if ((strcmp(mask,"*.*") == 0) ||
1053 mask_match_search(dname, mask, false) ||
1054 mangle_mask_match(conn, dname, mask)) {
1058 if (!mangle_is_8_3(dname, false, conn->params)) {
1059 bool ok = name_to_8_3(dname, mname, false,
1069 *_fname = talloc_strdup(ctx, fname);
1070 if (*_fname == NULL) {
1080 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1082 struct smb_filename *smb_fname,
1085 connection_struct *conn = (connection_struct *)private_data;
1087 if (!VALID_STAT(smb_fname->st)) {
1088 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1089 DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1090 "Couldn't stat [%s]. Error "
1092 smb_fname_str_dbg(smb_fname),
1098 *_mode = dos_mode(conn, smb_fname);
1102 bool get_dir_entry(TALLOC_CTX *ctx,
1103 struct dptr_struct *dirptr,
1109 struct timespec *_date,
1113 connection_struct *conn = dirptr->conn;
1115 struct smb_filename *smb_fname = NULL;
1120 ok = smbd_dirptr_get_entry(ctx,
1126 smbd_dirptr_8_3_match_fn,
1127 smbd_dirptr_8_3_mode_fn,
1137 *_fname = talloc_move(ctx, &fname);
1138 *_size = smb_fname->st.st_ex_size;
1140 *_date = smb_fname->st.st_ex_mtime;
1141 TALLOC_FREE(smb_fname);
1145 /*******************************************************************
1146 Check to see if a user can read a file. This is only approximate,
1147 it is used as part of the "hide unreadable" option. Don't
1148 use it for anything security sensitive.
1149 ********************************************************************/
1151 static bool user_can_read_file(connection_struct *conn,
1152 struct smb_filename *smb_fname)
1155 * Never hide files from the root user.
1156 * We use (uid_t)0 here not sec_initial_uid()
1157 * as make test uses a single user context.
1160 if (get_current_uid(conn) == (uid_t)0) {
1164 return NT_STATUS_IS_OK(smbd_check_access_rights(conn,
1169 /*******************************************************************
1170 Check to see if a user can write a file (and only files, we do not
1171 check dirs on this one). This is only approximate,
1172 it is used as part of the "hide unwriteable" option. Don't
1173 use it for anything security sensitive.
1174 ********************************************************************/
1176 static bool user_can_write_file(connection_struct *conn,
1177 const struct smb_filename *smb_fname)
1180 * Never hide files from the root user.
1181 * We use (uid_t)0 here not sec_initial_uid()
1182 * as make test uses a single user context.
1185 if (get_current_uid(conn) == (uid_t)0) {
1189 SMB_ASSERT(VALID_STAT(smb_fname->st));
1191 /* Pseudo-open the file */
1193 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1197 return can_write_to_file(conn, smb_fname);
1200 /*******************************************************************
1201 Is a file a "special" type ?
1202 ********************************************************************/
1204 static bool file_is_special(connection_struct *conn,
1205 const 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 SMB_ASSERT(VALID_STAT(smb_fname->st));
1219 if (S_ISREG(smb_fname->st.st_ex_mode) ||
1220 S_ISDIR(smb_fname->st.st_ex_mode) ||
1221 S_ISLNK(smb_fname->st.st_ex_mode))
1227 /*******************************************************************
1228 Should the file be seen by the client?
1229 NOTE: A successful return is no guarantee of the file's existence.
1230 ********************************************************************/
1232 bool is_visible_file(connection_struct *conn, const char *dir_path,
1233 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1235 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1236 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1237 bool hide_special = lp_hide_special_files(SNUM(conn));
1239 struct smb_filename *smb_fname_base = NULL;
1243 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1244 return True; /* . and .. are always visible. */
1247 /* If it's a vetoed file, pretend it doesn't even exist */
1248 if (use_veto && IS_VETO_PATH(conn, name)) {
1249 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1253 if (hide_unreadable || hide_unwriteable || hide_special) {
1254 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1260 /* Create an smb_filename with stream_name == NULL. */
1261 status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
1262 pst, &smb_fname_base);
1263 if (!NT_STATUS_IS_OK(status)) {
1268 /* If the file name does not exist, there's no point checking
1269 * the configuration options. We succeed, on the basis that the
1270 * checks *might* have passed if the file was present.
1272 if (!VALID_STAT(*pst)) {
1273 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1277 *pst = smb_fname_base->st;
1281 /* Honour _hide unreadable_ option */
1282 if (hide_unreadable &&
1283 !user_can_read_file(conn, smb_fname_base)) {
1284 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1289 /* Honour _hide unwriteable_ option */
1290 if (hide_unwriteable && !user_can_write_file(conn,
1292 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1297 /* Honour _hide_special_ option */
1298 if (hide_special && file_is_special(conn, smb_fname_base)) {
1299 DEBUG(10,("is_visible_file: file %s is special.\n",
1308 TALLOC_FREE(smb_fname_base);
1313 static int smb_Dir_destructor(struct smb_Dir *dirp)
1317 if (dirp->conn->sconn) {
1318 files_struct *fsp = file_find_fd(dirp->conn->sconn,
1321 /* The call below closes the underlying fd. */
1326 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1328 if (dirp->conn->sconn) {
1329 dirp->conn->sconn->searches.dirhandles_open--;
1334 /*******************************************************************
1336 ********************************************************************/
1338 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1343 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1344 struct smbd_server_connection *sconn = conn->sconn;
1351 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1353 dirp->dir_path = talloc_strdup(dirp, name);
1354 if (!dirp->dir_path) {
1360 sconn->searches.dirhandles_open++;
1362 talloc_set_destructor(dirp, smb_Dir_destructor);
1364 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1366 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1378 /*******************************************************************
1379 Open a directory from an fsp.
1380 ********************************************************************/
1382 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
1387 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1388 struct smbd_server_connection *sconn = conn->sconn;
1395 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1397 dirp->dir_path = talloc_strdup(dirp, fsp->fsp_name->base_name);
1398 if (!dirp->dir_path) {
1404 sconn->searches.dirhandles_open++;
1406 talloc_set_destructor(dirp, smb_Dir_destructor);
1408 if (fsp->is_directory && fsp->fh->fd != -1) {
1409 dirp->dir = SMB_VFS_FDOPENDIR(fsp, mask, attr);
1410 if (dirp->dir == NULL) {
1411 DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1415 if (errno != ENOSYS) {
1421 if (dirp->dir == NULL) {
1422 /* FDOPENDIR didn't work. Use OPENDIR instead. */
1423 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1427 DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp->dir_path,
1440 /*******************************************************************
1441 Read from a directory.
1442 Return directory entry, current offset, and optional stat information.
1443 Don't check for veto or invisible files.
1444 ********************************************************************/
1446 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1447 SMB_STRUCT_STAT *sbuf, char **ptalloced)
1450 char *talloced = NULL;
1451 connection_struct *conn = dirp->conn;
1453 /* Cheat to allow . and .. to be the first entries returned. */
1454 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1455 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1457 if (dirp->file_number == 0) {
1459 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1462 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1464 dirp->file_number++;
1467 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1468 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1471 /* A real offset, seek to it. */
1472 SeekDir(dirp, *poffset);
1475 while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1476 /* Ignore . and .. - we've already returned them. */
1478 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1479 TALLOC_FREE(talloced);
1483 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1484 *ptalloced = talloced;
1485 dirp->file_number++;
1488 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1493 /*******************************************************************
1494 Rewind to the start.
1495 ********************************************************************/
1497 void RewindDir(struct smb_Dir *dirp, long *poffset)
1499 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1500 dirp->file_number = 0;
1501 dirp->offset = START_OF_DIRECTORY_OFFSET;
1502 *poffset = START_OF_DIRECTORY_OFFSET;
1505 /*******************************************************************
1507 ********************************************************************/
1509 void SeekDir(struct smb_Dir *dirp, long offset)
1511 if (offset != dirp->offset) {
1512 if (offset == START_OF_DIRECTORY_OFFSET) {
1513 RewindDir(dirp, &offset);
1515 * Ok we should really set the file number here
1516 * to 1 to enable ".." to be returned next. Trouble
1517 * is I'm worried about callers using SeekDir(dirp,0)
1518 * as equivalent to RewindDir(). So leave this alone
1521 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1522 RewindDir(dirp, &offset);
1524 * Set the file number to 2 - we want to get the first
1525 * real file entry (the one we return after "..")
1526 * on the next ReadDir.
1528 dirp->file_number = 2;
1529 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1530 ; /* Don't seek in this case. */
1532 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1534 dirp->offset = offset;
1538 /*******************************************************************
1539 Tell a dir position.
1540 ********************************************************************/
1542 long TellDir(struct smb_Dir *dirp)
1544 return(dirp->offset);
1547 /*******************************************************************
1548 Add an entry into the dcache.
1549 ********************************************************************/
1551 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1553 struct name_cache_entry *e;
1555 if (dirp->name_cache_size == 0) {
1559 if (dirp->name_cache == NULL) {
1560 dirp->name_cache = talloc_zero_array(
1561 dirp, struct name_cache_entry, dirp->name_cache_size);
1563 if (dirp->name_cache == NULL) {
1568 dirp->name_cache_index = (dirp->name_cache_index+1) %
1569 dirp->name_cache_size;
1570 e = &dirp->name_cache[dirp->name_cache_index];
1571 TALLOC_FREE(e->name);
1572 e->name = talloc_strdup(dirp, name);
1576 /*******************************************************************
1577 Find an entry by name. Leave us at the offset after it.
1578 Don't check for veto or invisible files.
1579 ********************************************************************/
1581 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1584 const char *entry = NULL;
1585 char *talloced = NULL;
1586 connection_struct *conn = dirp->conn;
1588 /* Search back in the name cache. */
1589 if (dirp->name_cache_size && dirp->name_cache) {
1590 for (i = dirp->name_cache_index; i >= 0; i--) {
1591 struct name_cache_entry *e = &dirp->name_cache[i];
1592 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1593 *poffset = e->offset;
1594 SeekDir(dirp, e->offset);
1598 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1599 struct name_cache_entry *e = &dirp->name_cache[i];
1600 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1601 *poffset = e->offset;
1602 SeekDir(dirp, e->offset);
1608 /* Not found in the name cache. Rewind directory and start from scratch. */
1609 SMB_VFS_REWINDDIR(conn, dirp->dir);
1610 dirp->file_number = 0;
1611 *poffset = START_OF_DIRECTORY_OFFSET;
1612 while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
1613 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1614 TALLOC_FREE(talloced);
1617 TALLOC_FREE(talloced);
1622 /*****************************************************************
1623 Is this directory empty ?
1624 *****************************************************************/
1626 NTSTATUS smbd_can_delete_directory(struct connection_struct *conn,
1627 const char *dirname)
1629 NTSTATUS status = NT_STATUS_OK;
1631 const char *dname = NULL;
1632 char *talloced = NULL;
1634 struct smb_Dir *dir_hnd = OpenDir(talloc_tos(), conn,
1638 return map_nt_error_from_unix(errno);
1641 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
1642 /* Quick check for "." and ".." */
1643 if (dname[0] == '.') {
1644 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1645 TALLOC_FREE(talloced);
1650 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1651 TALLOC_FREE(talloced);
1655 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1657 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1660 TALLOC_FREE(talloced);
1661 TALLOC_FREE(dir_hnd);