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;
53 files_struct *fsp; /* Back pointer to containing fsp, only
54 set from OpenDir_fsp(). */
58 struct dptr_struct *next, *prev;
61 struct connection_struct *conn;
62 struct smb_Dir *dir_hnd;
67 bool has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
68 bool did_stat; /* Optimisation for non-wcard searches. */
69 bool priv; /* Directory handle opened with privilege. */
72 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
77 static void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset);
79 #define INVALID_DPTR_KEY (-3)
81 /****************************************************************************
83 ****************************************************************************/
85 bool make_dir_struct(TALLOC_CTX *ctx,
95 char *mask2 = talloc_strdup(ctx, mask);
101 if ((mode & FILE_ATTRIBUTE_DIRECTORY) != 0) {
105 memset(buf+1,' ',11);
106 if ((p = strchr_m(mask2,'.')) != NULL) {
108 push_ascii(buf+1,mask2,8, 0);
109 push_ascii(buf+9,p+1,3, 0);
112 push_ascii(buf+1,mask2,11, 0);
115 memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
117 srv_put_dos_date(buf,22,date);
118 SSVAL(buf,26,size & 0xFFFF);
119 SSVAL(buf,28,(size >> 16)&0xFFFF);
120 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
121 Strange, but verified on W2K3. Needed for OS/2. JRA. */
122 push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
123 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
127 /****************************************************************************
128 Initialise the dir bitmap.
129 ****************************************************************************/
131 bool init_dptrs(struct smbd_server_connection *sconn)
133 if (sconn->searches.dptr_bmap) {
137 sconn->searches.dptr_bmap = bitmap_talloc(
138 sconn, MAX_DIRECTORY_HANDLES);
140 if (sconn->searches.dptr_bmap == NULL) {
147 /****************************************************************************
148 Idle a dptr - the directory is closed but the control info is kept.
149 ****************************************************************************/
151 static void dptr_idle(struct dptr_struct *dptr)
154 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
155 TALLOC_FREE(dptr->dir_hnd);
159 /****************************************************************************
160 Idle the oldest dptr.
161 ****************************************************************************/
163 static void dptr_idleoldest(struct smbd_server_connection *sconn)
165 struct dptr_struct *dptr;
168 * Go to the end of the list.
170 dptr = DLIST_TAIL(sconn->searches.dirptrs);
173 DEBUG(0,("No dptrs available to idle ?\n"));
178 * Idle the oldest pointer.
181 for(; dptr; dptr = DLIST_PREV(dptr)) {
189 /****************************************************************************
190 Get the struct dptr_struct for a dir index.
191 ****************************************************************************/
193 static struct dptr_struct *dptr_get(struct smbd_server_connection *sconn,
194 int key, bool forclose)
196 struct dptr_struct *dptr;
198 for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
199 if(dptr->dnum == key) {
200 if (!forclose && !dptr->dir_hnd) {
201 if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES)
202 dptr_idleoldest(sconn);
203 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
204 if (!(dptr->dir_hnd = OpenDir(
205 NULL, dptr->conn, dptr->path,
206 dptr->wcard, dptr->attr))) {
207 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
212 DLIST_PROMOTE(sconn->searches.dirptrs,dptr);
219 /****************************************************************************
220 Get the dir path for a dir index.
221 ****************************************************************************/
223 const char *dptr_path(struct smbd_server_connection *sconn, int key)
225 struct dptr_struct *dptr = dptr_get(sconn, key, false);
231 /****************************************************************************
232 Get the dir wcard for a dir index.
233 ****************************************************************************/
235 const char *dptr_wcard(struct smbd_server_connection *sconn, int key)
237 struct dptr_struct *dptr = dptr_get(sconn, key, false);
243 /****************************************************************************
244 Get the dir attrib for a dir index.
245 ****************************************************************************/
247 uint16 dptr_attr(struct smbd_server_connection *sconn, int key)
249 struct dptr_struct *dptr = dptr_get(sconn, key, false);
255 /****************************************************************************
256 Close a dptr (internal func).
257 ****************************************************************************/
259 static void dptr_close_internal(struct dptr_struct *dptr)
261 struct smbd_server_connection *sconn = dptr->conn->sconn;
263 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
269 if (sconn->using_smb2) {
273 DLIST_REMOVE(sconn->searches.dirptrs, dptr);
276 * Free the dnum in the bitmap. Remember the dnum value is always
277 * biased by one with respect to the bitmap.
280 if (!bitmap_query(sconn->searches.dptr_bmap, dptr->dnum - 1)) {
281 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
285 bitmap_clear(sconn->searches.dptr_bmap, dptr->dnum - 1);
288 TALLOC_FREE(dptr->dir_hnd);
292 /****************************************************************************
293 Close a dptr given a key.
294 ****************************************************************************/
296 void dptr_close(struct smbd_server_connection *sconn, int *key)
298 struct dptr_struct *dptr;
300 if(*key == INVALID_DPTR_KEY)
303 /* OS/2 seems to use -1 to indicate "close all directories" */
305 struct dptr_struct *next;
306 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
308 dptr_close_internal(dptr);
310 *key = INVALID_DPTR_KEY;
314 dptr = dptr_get(sconn, *key, true);
317 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
321 dptr_close_internal(dptr);
323 *key = INVALID_DPTR_KEY;
326 /****************************************************************************
327 Close all dptrs for a cnum.
328 ****************************************************************************/
330 void dptr_closecnum(connection_struct *conn)
332 struct dptr_struct *dptr, *next;
333 struct smbd_server_connection *sconn = conn->sconn;
339 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
341 if (dptr->conn == conn) {
342 dptr_close_internal(dptr);
347 /****************************************************************************
348 Idle all dptrs for a cnum.
349 ****************************************************************************/
351 void dptr_idlecnum(connection_struct *conn)
353 struct dptr_struct *dptr;
354 struct smbd_server_connection *sconn = conn->sconn;
360 for(dptr = sconn->searches.dirptrs; dptr; dptr = dptr->next) {
361 if (dptr->conn == conn && dptr->dir_hnd) {
367 /****************************************************************************
368 Close a dptr that matches a given path, only if it matches the spid also.
369 ****************************************************************************/
371 void dptr_closepath(struct smbd_server_connection *sconn,
372 char *path,uint16 spid)
374 struct dptr_struct *dptr, *next;
375 for(dptr = sconn->searches.dirptrs; dptr; dptr = next) {
377 if (spid == dptr->spid && strequal(dptr->path,path))
378 dptr_close_internal(dptr);
382 /****************************************************************************
383 Try and close the oldest handle not marked for
384 expect close in the hope that the client has
385 finished with that one.
386 ****************************************************************************/
388 static void dptr_close_oldest(struct smbd_server_connection *sconn,
391 struct dptr_struct *dptr;
394 * Go to the end of the list.
396 for(dptr = sconn->searches.dirptrs; dptr && dptr->next; dptr = dptr->next)
400 DEBUG(0,("No old dptrs available to close oldest ?\n"));
405 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
406 * does not have expect_close set. If 'old' is false, close
407 * one of the new dnum handles.
410 for(; dptr; dptr = DLIST_PREV(dptr)) {
411 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
412 (!old && (dptr->dnum > 255))) {
413 dptr_close_internal(dptr);
419 /****************************************************************************
420 Safely do an OpenDir as root, ensuring we're in the right place.
421 ****************************************************************************/
423 static struct smb_Dir *open_dir_with_privilege(connection_struct *conn,
424 struct smb_request *req,
429 struct smb_Dir *dir_hnd = NULL;
430 struct smb_filename *smb_fname_cwd;
431 char *saved_dir = vfs_GetWd(talloc_tos(), conn);
432 struct privilege_paths *priv_paths = req->priv_paths;
435 if (saved_dir == NULL) {
439 if (vfs_ChDir(conn, path) == -1) {
443 /* Now check the stat value is the same. */
444 smb_fname_cwd = synthetic_smb_fname(talloc_tos(), ".", NULL, NULL);
446 if (smb_fname_cwd == NULL) {
449 ret = SMB_VFS_STAT(conn, smb_fname_cwd);
454 if (!check_same_stat(&smb_fname_cwd->st, &priv_paths->parent_name.st)) {
455 DEBUG(0,("open_dir_with_privilege: stat mismatch between %s "
458 smb_fname_str_dbg(&priv_paths->parent_name)));
462 dir_hnd = OpenDir(NULL, conn, ".", wcard, attr);
466 vfs_ChDir(conn, saved_dir);
470 /****************************************************************************
471 Create a new dir ptr. If the flag old_handle is true then we must allocate
472 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
473 one byte long. If old_handle is false we allocate from the range
474 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
475 a directory handle is never zero.
476 wcard must not be zero.
477 ****************************************************************************/
479 NTSTATUS dptr_create(connection_struct *conn,
480 struct smb_request *req,
482 const char *path, bool old_handle, bool expect_close,uint16 spid,
483 const char *wcard, bool wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
485 struct smbd_server_connection *sconn = conn->sconn;
486 struct dptr_struct *dptr = NULL;
487 struct smb_Dir *dir_hnd;
489 if (fsp && fsp->is_directory && fsp->fh->fd != -1) {
490 path = fsp->fsp_name->base_name;
493 DEBUG(5,("dptr_create dir=%s\n", path));
496 DEBUG(0,("dptr_create: called with fake connection_struct\n"));
497 return NT_STATUS_INTERNAL_ERROR;
501 return NT_STATUS_INVALID_PARAMETER;
505 if (!(fsp->access_mask & SEC_DIR_LIST)) {
506 DEBUG(5,("dptr_create: directory %s "
507 "not open for LIST access\n",
509 return NT_STATUS_ACCESS_DENIED;
511 dir_hnd = OpenDir_fsp(NULL, conn, fsp, wcard, attr);
514 bool backup_intent = (req && req->priv_paths);
515 struct smb_filename *smb_dname;
518 smb_dname = synthetic_smb_fname(talloc_tos(), path,
520 if (smb_dname == NULL) {
521 return NT_STATUS_NO_MEMORY;
523 if (lp_posix_pathnames()) {
524 ret = SMB_VFS_LSTAT(conn, smb_dname);
526 ret = SMB_VFS_STAT(conn, smb_dname);
529 return map_nt_error_from_unix(errno);
531 if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
532 return NT_STATUS_NOT_A_DIRECTORY;
534 status = smbd_check_access_rights(conn,
538 if (!NT_STATUS_IS_OK(status)) {
542 dir_hnd = open_dir_with_privilege(conn,
548 dir_hnd = OpenDir(NULL, conn, path, wcard, attr);
553 return map_nt_error_from_unix(errno);
556 if (sconn->searches.dirhandles_open >= MAX_OPEN_DIRECTORIES) {
557 dptr_idleoldest(sconn);
560 dptr = talloc(NULL, struct dptr_struct);
562 DEBUG(0,("talloc fail in dptr_create.\n"));
563 TALLOC_FREE(dir_hnd);
564 return NT_STATUS_NO_MEMORY;
569 dptr->path = talloc_strdup(dptr, path);
572 TALLOC_FREE(dir_hnd);
573 return NT_STATUS_NO_MEMORY;
576 dptr->dir_hnd = dir_hnd;
578 dptr->expect_close = expect_close;
579 dptr->wcard = talloc_strdup(dptr, wcard);
582 TALLOC_FREE(dir_hnd);
583 return NT_STATUS_NO_MEMORY;
585 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
586 dptr->has_wild = True;
588 dptr->has_wild = wcard_has_wild;
593 if (sconn->using_smb2) {
600 * This is an old-style SMBsearch request. Ensure the
601 * value we return will fit in the range 1-255.
604 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
606 if(dptr->dnum == -1 || dptr->dnum > 254) {
609 * Try and close the oldest handle not marked for
610 * expect close in the hope that the client has
611 * finished with that one.
614 dptr_close_oldest(sconn, true);
616 /* Now try again... */
617 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 0);
618 if(dptr->dnum == -1 || dptr->dnum > 254) {
619 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
621 TALLOC_FREE(dir_hnd);
622 return NT_STATUS_TOO_MANY_OPENED_FILES;
628 * This is a new-style trans2 request. Allocate from
629 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
632 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
634 if(dptr->dnum == -1 || dptr->dnum < 255) {
637 * Try and close the oldest handle close in the hope that
638 * the client has finished with that one. This will only
639 * happen in the case of the Win98 client bug where it leaks
643 dptr_close_oldest(sconn, false);
645 /* Now try again... */
646 dptr->dnum = bitmap_find(sconn->searches.dptr_bmap, 255);
648 if(dptr->dnum == -1 || dptr->dnum < 255) {
649 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
651 TALLOC_FREE(dir_hnd);
652 return NT_STATUS_TOO_MANY_OPENED_FILES;
657 bitmap_set(sconn->searches.dptr_bmap, dptr->dnum);
659 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
661 DLIST_ADD(sconn->searches.dirptrs, dptr);
664 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
665 dptr->dnum,path,expect_close));
673 /****************************************************************************
674 Wrapper functions to access the lower level directory handles.
675 ****************************************************************************/
677 void dptr_CloseDir(files_struct *fsp)
681 * The destructor for the struct smb_Dir
682 * (fsp->dptr->dir_hnd) now handles
683 * all resource deallocation.
685 dptr_close_internal(fsp->dptr);
690 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
692 SeekDir(dptr->dir_hnd, offset);
695 long dptr_TellDir(struct dptr_struct *dptr)
697 return TellDir(dptr->dir_hnd);
700 bool dptr_has_wild(struct dptr_struct *dptr)
702 return dptr->has_wild;
705 int dptr_dnum(struct dptr_struct *dptr)
710 bool dptr_get_priv(struct dptr_struct *dptr)
715 void dptr_set_priv(struct dptr_struct *dptr)
720 /****************************************************************************
721 Return the next visible file name, skipping veto'd and invisible files.
722 ****************************************************************************/
724 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr,
725 long *poffset, SMB_STRUCT_STAT *pst,
728 /* Normal search for the next file. */
730 char *talloced = NULL;
732 while ((name = ReadDirName(dptr->dir_hnd, poffset, pst, &talloced))
734 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
735 *ptalloced = talloced;
738 TALLOC_FREE(talloced);
743 /****************************************************************************
744 Return the next visible file name, skipping veto'd and invisible files.
745 ****************************************************************************/
747 char *dptr_ReadDirName(TALLOC_CTX *ctx,
748 struct dptr_struct *dptr,
750 SMB_STRUCT_STAT *pst)
752 struct smb_filename smb_fname_base;
754 const char *name_temp = NULL;
755 char *talloced = NULL;
756 char *pathreal = NULL;
757 char *found_name = NULL;
760 SET_STAT_INVALID(*pst);
762 if (dptr->has_wild || dptr->did_stat) {
763 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst,
765 if (name_temp == NULL) {
768 if (talloced != NULL) {
769 return talloc_move(ctx, &talloced);
771 return talloc_strdup(ctx, name_temp);
774 /* If poffset is -1 then we know we returned this name before and we
775 * have no wildcards. We're at the end of the directory. */
776 if (*poffset == END_OF_DIRECTORY_OFFSET) {
780 /* We know the stored wcard contains no wildcard characters.
781 * See if we can match with a stat call. If we can't, then set
782 * did_stat to true to ensure we only do this once and keep
785 dptr->did_stat = true;
787 /* First check if it should be visible. */
788 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard,
791 /* This only returns false if the file was found, but
792 is explicitly not visible. Set us to end of
793 directory, but return NULL as we know we can't ever
798 if (VALID_STAT(*pst)) {
799 name = talloc_strdup(ctx, dptr->wcard);
803 pathreal = talloc_asprintf(ctx,
810 /* Create an smb_filename with stream_name == NULL. */
811 ZERO_STRUCT(smb_fname_base);
812 smb_fname_base.base_name = pathreal;
814 if (SMB_VFS_STAT(dptr->conn, &smb_fname_base) == 0) {
815 *pst = smb_fname_base.st;
816 name = talloc_strdup(ctx, dptr->wcard);
819 /* If we get any other error than ENOENT or ENOTDIR
820 then the file exists we just can't stat it. */
821 if (errno != ENOENT && errno != ENOTDIR) {
822 name = talloc_strdup(ctx, dptr->wcard);
827 /* Stat failed. We know this is authoratiative if we are
828 * providing case sensitive semantics or the underlying
829 * filesystem is case sensitive.
831 if (dptr->conn->case_sensitive ||
832 !(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH))
838 * Try case-insensitive stat if the fs has the ability. This avoids
839 * scanning the whole directory.
841 ret = SMB_VFS_GET_REAL_FILENAME(dptr->conn, dptr->path, dptr->wcard,
846 } else if (errno == ENOENT) {
847 /* The case-insensitive lookup was authoritative. */
851 TALLOC_FREE(pathreal);
853 name_temp = dptr_normal_ReadDirName(dptr, poffset, pst, &talloced);
854 if (name_temp == NULL) {
857 if (talloced != NULL) {
858 return talloc_move(ctx, &talloced);
860 return talloc_strdup(ctx, name_temp);
863 TALLOC_FREE(pathreal);
865 /* We need to set the underlying dir_hnd offset to -1
866 * also as this function is usually called with the
867 * output from TellDir. */
868 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
872 /****************************************************************************
873 Search for a file by name, skipping veto'ed and not visible files.
874 ****************************************************************************/
876 bool dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
878 SET_STAT_INVALID(*pst);
880 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
881 /* This is a singleton directory and we're already at the end. */
882 *poffset = END_OF_DIRECTORY_OFFSET;
886 return SearchDir(dptr->dir_hnd, name, poffset);
889 /****************************************************************************
890 Initialize variables & state data at the beginning of all search SMB requests.
891 ****************************************************************************/
892 void dptr_init_search_op(struct dptr_struct *dptr)
894 SMB_VFS_INIT_SEARCH_OP(dptr->conn, dptr->dir_hnd->dir);
897 /****************************************************************************
898 Map a native directory offset to a 32-bit cookie.
899 ****************************************************************************/
901 static uint32_t map_dir_offset_to_wire(struct dptr_struct *dptr, long offset)
903 return (uint32_t)offset;
906 /****************************************************************************
907 Fill the 5 byte server reserved dptr field.
908 ****************************************************************************/
910 bool dptr_fill(struct smbd_server_connection *sconn,
911 char *buf1,unsigned int key)
913 unsigned char *buf = (unsigned char *)buf1;
914 struct dptr_struct *dptr = dptr_get(sconn, key, false);
915 uint32_t wire_offset;
917 DEBUG(1,("filling null dirptr %d\n",key));
920 wire_offset = map_dir_offset_to_wire(dptr,TellDir(dptr->dir_hnd));
921 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
922 (long)dptr->dir_hnd,(int)wire_offset));
924 SIVAL(buf,1,wire_offset);
928 /****************************************************************************
929 Fetch the dir ptr and seek it given the 5 byte server field.
930 ****************************************************************************/
932 struct dptr_struct *dptr_fetch(struct smbd_server_connection *sconn,
935 unsigned int key = *(unsigned char *)buf;
936 struct dptr_struct *dptr = dptr_get(sconn, key, false);
937 uint32_t wire_offset;
941 DEBUG(3,("fetched null dirptr %d\n",key));
945 wire_offset = IVAL(buf,1);
946 if (wire_offset == (uint32_t)-1) {
947 seekoff = END_OF_DIRECTORY_OFFSET;
949 seekoff = (long)wire_offset;
951 SeekDir(dptr->dir_hnd,seekoff);
952 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
953 key, dptr->path, (int)seekoff));
957 /****************************************************************************
959 ****************************************************************************/
961 struct dptr_struct *dptr_fetch_lanman2(struct smbd_server_connection *sconn,
964 struct dptr_struct *dptr = dptr_get(sconn, dptr_num, false);
967 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
970 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr->path));
974 static bool mangle_mask_match(connection_struct *conn,
975 const char *filename,
980 if (!name_to_8_3(filename,mname,False,conn->params)) {
983 return mask_match_search(mname,mask,False);
986 bool smbd_dirptr_get_entry(TALLOC_CTX *ctx,
987 struct dptr_struct *dirptr,
992 bool (*match_fn)(TALLOC_CTX *ctx,
997 bool (*mode_fn)(TALLOC_CTX *ctx,
999 struct smb_filename *smb_fname,
1003 struct smb_filename **_smb_fname,
1007 connection_struct *conn = dirptr->conn;
1014 pathlen = strlen(dirptr->path);
1015 slashlen = ( dirptr->path[pathlen-1] != '/') ? 1 : 0;
1020 SMB_STRUCT_STAT sbuf;
1024 char *pathreal = NULL;
1025 struct smb_filename smb_fname;
1029 cur_offset = dptr_TellDir(dirptr);
1030 prev_offset = cur_offset;
1031 dname = dptr_ReadDirName(ctx, dirptr, &cur_offset, &sbuf);
1033 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
1034 (long)dirptr, cur_offset));
1036 if (dname == NULL) {
1040 isdots = (ISDOT(dname) || ISDOTDOT(dname));
1041 if (dont_descend && !isdots) {
1047 * fname may get mangled, dname is never mangled.
1048 * Whenever we're accessing the filesystem we use
1049 * pathreal which is composed from dname.
1052 ok = match_fn(ctx, private_data, dname, mask, &fname);
1060 * pathreal = talloc_asprintf(ctx, "%s%s%s", dirptr->path,
1061 * needslash?"/":"", dname);
1062 * but this was measurably slower than doing the memcpy.
1065 pathreal = talloc_array(
1067 pathlen + slashlen + talloc_get_size(dname));
1074 memcpy(pathreal, dirptr->path, pathlen);
1075 pathreal[pathlen] = '/';
1076 memcpy(pathreal + slashlen + pathlen, dname,
1077 talloc_get_size(dname));
1079 /* Create smb_fname with NULL stream_name. */
1080 ZERO_STRUCT(smb_fname);
1081 smb_fname.base_name = pathreal;
1082 smb_fname.st = sbuf;
1084 ok = mode_fn(ctx, private_data, &smb_fname, &mode);
1088 TALLOC_FREE(pathreal);
1092 if (!dir_check_ftype(mode, dirtype)) {
1093 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1094 fname, (unsigned int)mode, (unsigned int)dirtype));
1097 TALLOC_FREE(pathreal);
1101 if (ask_sharemode) {
1102 struct timespec write_time_ts;
1103 struct file_id fileid;
1105 fileid = vfs_file_id_from_sbuf(conn,
1107 get_file_infos(fileid, 0, NULL, &write_time_ts);
1108 if (!null_timespec(write_time_ts)) {
1109 update_stat_ex_mtime(&smb_fname.st,
1114 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1116 mask, smb_fname_str_dbg(&smb_fname),
1119 DirCacheAdd(dirptr->dir_hnd, dname, cur_offset);
1123 *_smb_fname = cp_smb_filename(ctx, &smb_fname);
1124 TALLOC_FREE(pathreal);
1125 if (*_smb_fname == NULL) {
1130 *_prev_offset = prev_offset;
1138 /****************************************************************************
1139 Get an 8.3 directory entry.
1140 ****************************************************************************/
1142 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX *ctx,
1148 connection_struct *conn = (connection_struct *)private_data;
1150 if ((strcmp(mask,"*.*") == 0) ||
1151 mask_match_search(dname, mask, false) ||
1152 mangle_mask_match(conn, dname, mask)) {
1156 if (!mangle_is_8_3(dname, false, conn->params)) {
1157 bool ok = name_to_8_3(dname, mname, false,
1167 *_fname = talloc_strdup(ctx, fname);
1168 if (*_fname == NULL) {
1178 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX *ctx,
1180 struct smb_filename *smb_fname,
1183 connection_struct *conn = (connection_struct *)private_data;
1185 if (!VALID_STAT(smb_fname->st)) {
1186 if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
1187 DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1188 "Couldn't stat [%s]. Error "
1190 smb_fname_str_dbg(smb_fname),
1196 *_mode = dos_mode(conn, smb_fname);
1200 bool get_dir_entry(TALLOC_CTX *ctx,
1201 struct dptr_struct *dirptr,
1207 struct timespec *_date,
1211 connection_struct *conn = dirptr->conn;
1213 struct smb_filename *smb_fname = NULL;
1218 ok = smbd_dirptr_get_entry(ctx,
1224 smbd_dirptr_8_3_match_fn,
1225 smbd_dirptr_8_3_mode_fn,
1235 *_fname = talloc_move(ctx, &fname);
1236 *_size = smb_fname->st.st_ex_size;
1238 *_date = smb_fname->st.st_ex_mtime;
1239 TALLOC_FREE(smb_fname);
1243 /*******************************************************************
1244 Check to see if a user can read a file. This is only approximate,
1245 it is used as part of the "hide unreadable" option. Don't
1246 use it for anything security sensitive.
1247 ********************************************************************/
1249 static bool user_can_read_file(connection_struct *conn,
1250 struct smb_filename *smb_fname)
1253 * Never hide files from the root user.
1254 * We use (uid_t)0 here not sec_initial_uid()
1255 * as make test uses a single user context.
1258 if (get_current_uid(conn) == (uid_t)0) {
1262 return NT_STATUS_IS_OK(smbd_check_access_rights(conn,
1268 /*******************************************************************
1269 Check to see if a user can write a file (and only files, we do not
1270 check dirs on this one). This is only approximate,
1271 it is used as part of the "hide unwriteable" option. Don't
1272 use it for anything security sensitive.
1273 ********************************************************************/
1275 static bool user_can_write_file(connection_struct *conn,
1276 const struct smb_filename *smb_fname)
1279 * Never hide files from the root user.
1280 * We use (uid_t)0 here not sec_initial_uid()
1281 * as make test uses a single user context.
1284 if (get_current_uid(conn) == (uid_t)0) {
1288 SMB_ASSERT(VALID_STAT(smb_fname->st));
1290 /* Pseudo-open the file */
1292 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
1296 return can_write_to_file(conn, smb_fname);
1299 /*******************************************************************
1300 Is a file a "special" type ?
1301 ********************************************************************/
1303 static bool file_is_special(connection_struct *conn,
1304 const struct smb_filename *smb_fname)
1307 * Never hide files from the root user.
1308 * We use (uid_t)0 here not sec_initial_uid()
1309 * as make test uses a single user context.
1312 if (get_current_uid(conn) == (uid_t)0) {
1316 SMB_ASSERT(VALID_STAT(smb_fname->st));
1318 if (S_ISREG(smb_fname->st.st_ex_mode) ||
1319 S_ISDIR(smb_fname->st.st_ex_mode) ||
1320 S_ISLNK(smb_fname->st.st_ex_mode))
1326 /*******************************************************************
1327 Should the file be seen by the client?
1328 NOTE: A successful return is no guarantee of the file's existence.
1329 ********************************************************************/
1331 bool is_visible_file(connection_struct *conn, const char *dir_path,
1332 const char *name, SMB_STRUCT_STAT *pst, bool use_veto)
1334 bool hide_unreadable = lp_hideunreadable(SNUM(conn));
1335 bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1336 bool hide_special = lp_hide_special_files(SNUM(conn));
1338 struct smb_filename *smb_fname_base = NULL;
1341 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1342 return True; /* . and .. are always visible. */
1345 /* If it's a vetoed file, pretend it doesn't even exist */
1346 if (use_veto && IS_VETO_PATH(conn, name)) {
1347 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1351 if (hide_unreadable || hide_unwriteable || hide_special) {
1352 entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
1358 /* Create an smb_filename with stream_name == NULL. */
1359 smb_fname_base = synthetic_smb_fname(talloc_tos(), entry, NULL,
1361 if (smb_fname_base == NULL) {
1366 /* If the file name does not exist, there's no point checking
1367 * the configuration options. We succeed, on the basis that the
1368 * checks *might* have passed if the file was present.
1370 if (!VALID_STAT(*pst)) {
1371 if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
1375 *pst = smb_fname_base->st;
1379 /* Honour _hide unreadable_ option */
1380 if (hide_unreadable &&
1381 !user_can_read_file(conn, smb_fname_base)) {
1382 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1387 /* Honour _hide unwriteable_ option */
1388 if (hide_unwriteable && !user_can_write_file(conn,
1390 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1395 /* Honour _hide_special_ option */
1396 if (hide_special && file_is_special(conn, smb_fname_base)) {
1397 DEBUG(10,("is_visible_file: file %s is special.\n",
1406 TALLOC_FREE(smb_fname_base);
1411 static int smb_Dir_destructor(struct smb_Dir *dirp)
1413 if (dirp->dir != NULL) {
1414 SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1415 if (dirp->fsp != NULL) {
1417 * The SMB_VFS_CLOSEDIR above
1418 * closes the underlying fd inside
1421 dirp->fsp->fh->fd = -1;
1422 if (dirp->fsp->dptr != NULL) {
1423 SMB_ASSERT(dirp->fsp->dptr->dir_hnd == dirp);
1424 dirp->fsp->dptr->dir_hnd = NULL;
1429 if (dirp->conn->sconn && !dirp->conn->sconn->using_smb2) {
1430 dirp->conn->sconn->searches.dirhandles_open--;
1435 /*******************************************************************
1437 ********************************************************************/
1439 struct smb_Dir *OpenDir(TALLOC_CTX *mem_ctx, connection_struct *conn,
1444 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1445 struct smbd_server_connection *sconn = conn->sconn;
1452 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1454 dirp->dir_path = talloc_strdup(dirp, name);
1455 if (!dirp->dir_path) {
1460 if (sconn && !sconn->using_smb2) {
1461 sconn->searches.dirhandles_open++;
1463 talloc_set_destructor(dirp, smb_Dir_destructor);
1465 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1467 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path,
1479 /*******************************************************************
1480 Open a directory from an fsp.
1481 ********************************************************************/
1483 static struct smb_Dir *OpenDir_fsp(TALLOC_CTX *mem_ctx, connection_struct *conn,
1488 struct smb_Dir *dirp = talloc_zero(mem_ctx, struct smb_Dir);
1489 struct smbd_server_connection *sconn = conn->sconn;
1496 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1498 dirp->dir_path = talloc_strdup(dirp, fsp->fsp_name->base_name);
1499 if (!dirp->dir_path) {
1504 if (sconn && !sconn->using_smb2) {
1505 sconn->searches.dirhandles_open++;
1507 talloc_set_destructor(dirp, smb_Dir_destructor);
1509 if (fsp->is_directory && fsp->fh->fd != -1) {
1510 dirp->dir = SMB_VFS_FDOPENDIR(fsp, mask, attr);
1511 if (dirp->dir != NULL) {
1514 DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1518 if (errno != ENOSYS) {
1524 if (dirp->dir == NULL) {
1525 /* FDOPENDIR didn't work. Use OPENDIR instead. */
1526 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1530 DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp->dir_path,
1543 /*******************************************************************
1544 Read from a directory.
1545 Return directory entry, current offset, and optional stat information.
1546 Don't check for veto or invisible files.
1547 ********************************************************************/
1549 const char *ReadDirName(struct smb_Dir *dirp, long *poffset,
1550 SMB_STRUCT_STAT *sbuf, char **ptalloced)
1553 char *talloced = NULL;
1554 connection_struct *conn = dirp->conn;
1556 /* Cheat to allow . and .. to be the first entries returned. */
1557 if (((*poffset == START_OF_DIRECTORY_OFFSET) ||
1558 (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2))
1560 if (dirp->file_number == 0) {
1562 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1565 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1567 dirp->file_number++;
1570 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1571 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1574 /* A real offset, seek to it. */
1575 SeekDir(dirp, *poffset);
1578 while ((n = vfs_readdirname(conn, dirp->dir, sbuf, &talloced))) {
1579 /* Ignore . and .. - we've already returned them. */
1581 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1582 TALLOC_FREE(talloced);
1586 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1587 *ptalloced = talloced;
1588 dirp->file_number++;
1591 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1596 /*******************************************************************
1597 Rewind to the start.
1598 ********************************************************************/
1600 void RewindDir(struct smb_Dir *dirp, long *poffset)
1602 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1603 dirp->file_number = 0;
1604 dirp->offset = START_OF_DIRECTORY_OFFSET;
1605 *poffset = START_OF_DIRECTORY_OFFSET;
1608 /*******************************************************************
1610 ********************************************************************/
1612 void SeekDir(struct smb_Dir *dirp, long offset)
1614 if (offset != dirp->offset) {
1615 if (offset == START_OF_DIRECTORY_OFFSET) {
1616 RewindDir(dirp, &offset);
1618 * Ok we should really set the file number here
1619 * to 1 to enable ".." to be returned next. Trouble
1620 * is I'm worried about callers using SeekDir(dirp,0)
1621 * as equivalent to RewindDir(). So leave this alone
1624 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1625 RewindDir(dirp, &offset);
1627 * Set the file number to 2 - we want to get the first
1628 * real file entry (the one we return after "..")
1629 * on the next ReadDir.
1631 dirp->file_number = 2;
1632 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1633 ; /* Don't seek in this case. */
1635 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1637 dirp->offset = offset;
1641 /*******************************************************************
1642 Tell a dir position.
1643 ********************************************************************/
1645 long TellDir(struct smb_Dir *dirp)
1647 return(dirp->offset);
1650 /*******************************************************************
1651 Add an entry into the dcache.
1652 ********************************************************************/
1654 static void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1656 struct name_cache_entry *e;
1658 if (dirp->name_cache_size == 0) {
1662 if (dirp->name_cache == NULL) {
1663 dirp->name_cache = talloc_zero_array(
1664 dirp, struct name_cache_entry, dirp->name_cache_size);
1666 if (dirp->name_cache == NULL) {
1671 dirp->name_cache_index = (dirp->name_cache_index+1) %
1672 dirp->name_cache_size;
1673 e = &dirp->name_cache[dirp->name_cache_index];
1674 TALLOC_FREE(e->name);
1675 e->name = talloc_strdup(dirp, name);
1679 /*******************************************************************
1680 Find an entry by name. Leave us at the offset after it.
1681 Don't check for veto or invisible files.
1682 ********************************************************************/
1684 bool SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1687 const char *entry = NULL;
1688 char *talloced = NULL;
1689 connection_struct *conn = dirp->conn;
1691 /* Search back in the name cache. */
1692 if (dirp->name_cache_size && dirp->name_cache) {
1693 for (i = dirp->name_cache_index; i >= 0; i--) {
1694 struct name_cache_entry *e = &dirp->name_cache[i];
1695 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1696 *poffset = e->offset;
1697 SeekDir(dirp, e->offset);
1701 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1702 struct name_cache_entry *e = &dirp->name_cache[i];
1703 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1704 *poffset = e->offset;
1705 SeekDir(dirp, e->offset);
1711 /* Not found in the name cache. Rewind directory and start from scratch. */
1712 SMB_VFS_REWINDDIR(conn, dirp->dir);
1713 dirp->file_number = 0;
1714 *poffset = START_OF_DIRECTORY_OFFSET;
1715 while ((entry = ReadDirName(dirp, poffset, NULL, &talloced))) {
1716 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1717 TALLOC_FREE(talloced);
1720 TALLOC_FREE(talloced);
1725 /*****************************************************************
1726 Is this directory empty ?
1727 *****************************************************************/
1729 NTSTATUS can_delete_directory_fsp(files_struct *fsp)
1731 NTSTATUS status = NT_STATUS_OK;
1733 const char *dname = NULL;
1734 const char *dirname = fsp->fsp_name->base_name;
1735 char *talloced = NULL;
1737 struct connection_struct *conn = fsp->conn;
1738 struct smb_Dir *dir_hnd = OpenDir_fsp(talloc_tos(),
1745 return map_nt_error_from_unix(errno);
1748 while ((dname = ReadDirName(dir_hnd, &dirpos, &st, &talloced))) {
1749 /* Quick check for "." and ".." */
1750 if (dname[0] == '.') {
1751 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1752 TALLOC_FREE(talloced);
1757 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1758 TALLOC_FREE(talloced);
1762 DEBUG(10,("got name %s - can't delete\n",
1764 status = NT_STATUS_DIRECTORY_NOT_EMPTY;
1767 TALLOC_FREE(talloced);
1768 TALLOC_FREE(dir_hnd);