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 if (sconn
->using_smb2
) {
268 DLIST_REMOVE(sconn
->searches
.dirptrs
, dptr
);
271 * Free the dnum in the bitmap. Remember the dnum value is always
272 * biased by one with respect to the bitmap.
275 if (!bitmap_query(sconn
->searches
.dptr_bmap
, dptr
->dnum
- 1)) {
276 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
280 bitmap_clear(sconn
->searches
.dptr_bmap
, dptr
->dnum
- 1);
283 TALLOC_FREE(dptr
->dir_hnd
);
285 /* Lanman 2 specific code */
286 SAFE_FREE(dptr
->wcard
);
287 SAFE_FREE(dptr
->path
);
291 /****************************************************************************
292 Close a dptr given a key.
293 ****************************************************************************/
295 void dptr_close(struct smbd_server_connection
*sconn
, int *key
)
297 struct dptr_struct
*dptr
;
299 if(*key
== INVALID_DPTR_KEY
)
302 /* OS/2 seems to use -1 to indicate "close all directories" */
304 struct dptr_struct
*next
;
305 for(dptr
= sconn
->searches
.dirptrs
; dptr
; dptr
= next
) {
307 dptr_close_internal(dptr
);
309 *key
= INVALID_DPTR_KEY
;
313 dptr
= dptr_get(sconn
, *key
, true);
316 DEBUG(0,("Invalid key %d given to dptr_close\n", *key
));
320 dptr_close_internal(dptr
);
322 *key
= INVALID_DPTR_KEY
;
325 /****************************************************************************
326 Close all dptrs for a cnum.
327 ****************************************************************************/
329 void dptr_closecnum(connection_struct
*conn
)
331 struct dptr_struct
*dptr
, *next
;
332 struct smbd_server_connection
*sconn
= conn
->sconn
;
338 for(dptr
= sconn
->searches
.dirptrs
; dptr
; dptr
= next
) {
340 if (dptr
->conn
== conn
) {
341 dptr_close_internal(dptr
);
346 /****************************************************************************
347 Idle all dptrs for a cnum.
348 ****************************************************************************/
350 void dptr_idlecnum(connection_struct
*conn
)
352 struct dptr_struct
*dptr
;
353 struct smbd_server_connection
*sconn
= conn
->sconn
;
359 for(dptr
= sconn
->searches
.dirptrs
; dptr
; dptr
= dptr
->next
) {
360 if (dptr
->conn
== conn
&& dptr
->dir_hnd
) {
366 /****************************************************************************
367 Close a dptr that matches a given path, only if it matches the spid also.
368 ****************************************************************************/
370 void dptr_closepath(struct smbd_server_connection
*sconn
,
371 char *path
,uint16 spid
)
373 struct dptr_struct
*dptr
, *next
;
374 for(dptr
= sconn
->searches
.dirptrs
; dptr
; dptr
= next
) {
376 if (spid
== dptr
->spid
&& strequal(dptr
->path
,path
))
377 dptr_close_internal(dptr
);
381 /****************************************************************************
382 Try and close the oldest handle not marked for
383 expect close in the hope that the client has
384 finished with that one.
385 ****************************************************************************/
387 static void dptr_close_oldest(struct smbd_server_connection
*sconn
,
390 struct dptr_struct
*dptr
;
393 * Go to the end of the list.
395 for(dptr
= sconn
->searches
.dirptrs
; dptr
&& dptr
->next
; dptr
= dptr
->next
)
399 DEBUG(0,("No old dptrs available to close oldest ?\n"));
404 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
405 * does not have expect_close set. If 'old' is false, close
406 * one of the new dnum handles.
409 for(; dptr
; dptr
= DLIST_PREV(dptr
)) {
410 if ((old
&& (dptr
->dnum
< 256) && !dptr
->expect_close
) ||
411 (!old
&& (dptr
->dnum
> 255))) {
412 dptr_close_internal(dptr
);
418 /****************************************************************************
419 Create a new dir ptr. If the flag old_handle is true then we must allocate
420 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
421 one byte long. If old_handle is false we allocate from the range
422 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
423 a directory handle is never zero.
424 wcard must not be zero.
425 ****************************************************************************/
427 NTSTATUS
dptr_create(connection_struct
*conn
, files_struct
*fsp
,
428 const char *path
, bool old_handle
, bool expect_close
,uint16 spid
,
429 const char *wcard
, bool wcard_has_wild
, uint32 attr
, struct dptr_struct
**dptr_ret
)
431 struct smbd_server_connection
*sconn
= conn
->sconn
;
432 struct dptr_struct
*dptr
= NULL
;
433 struct smb_Dir
*dir_hnd
;
435 if (fsp
&& fsp
->is_directory
&& fsp
->fh
->fd
!= -1) {
436 path
= fsp
->fsp_name
->base_name
;
439 DEBUG(5,("dptr_create dir=%s\n", path
));
442 DEBUG(0,("dptr_create: called with fake connection_struct\n"));
443 return NT_STATUS_INTERNAL_ERROR
;
447 return NT_STATUS_INVALID_PARAMETER
;
451 if (!(fsp
->access_mask
& SEC_DIR_LIST
)) {
452 DEBUG(5,("dptr_create: directory %s "
453 "not open for LIST access\n",
455 return NT_STATUS_ACCESS_DENIED
;
457 dir_hnd
= OpenDir_fsp(NULL
, conn
, fsp
, wcard
, attr
);
460 struct smb_filename
*smb_dname
= NULL
;
461 NTSTATUS status
= create_synthetic_smb_fname(talloc_tos(),
466 if (!NT_STATUS_IS_OK(status
)) {
469 if (lp_posix_pathnames()) {
470 ret
= SMB_VFS_LSTAT(conn
, smb_dname
);
472 ret
= SMB_VFS_STAT(conn
, smb_dname
);
475 return map_nt_error_from_unix(errno
);
477 if (!S_ISDIR(smb_dname
->st
.st_ex_mode
)) {
478 return NT_STATUS_NOT_A_DIRECTORY
;
480 status
= smbd_check_access_rights(conn
,
483 if (!NT_STATUS_IS_OK(status
)) {
486 dir_hnd
= OpenDir(NULL
, conn
, path
, wcard
, attr
);
490 return map_nt_error_from_unix(errno
);
493 if (sconn
->searches
.dirhandles_open
>= MAX_OPEN_DIRECTORIES
) {
494 dptr_idleoldest(sconn
);
497 dptr
= SMB_MALLOC_P(struct dptr_struct
);
499 DEBUG(0,("malloc fail in dptr_create.\n"));
500 TALLOC_FREE(dir_hnd
);
501 return NT_STATUS_NO_MEMORY
;
506 dptr
->path
= SMB_STRDUP(path
);
509 TALLOC_FREE(dir_hnd
);
510 return NT_STATUS_NO_MEMORY
;
513 dptr
->dir_hnd
= dir_hnd
;
515 dptr
->expect_close
= expect_close
;
516 dptr
->wcard
= SMB_STRDUP(wcard
);
518 SAFE_FREE(dptr
->path
);
520 TALLOC_FREE(dir_hnd
);
521 return NT_STATUS_NO_MEMORY
;
523 if (lp_posix_pathnames() || (wcard
[0] == '.' && wcard
[1] == 0)) {
524 dptr
->has_wild
= True
;
526 dptr
->has_wild
= wcard_has_wild
;
531 if (sconn
->using_smb2
) {
538 * This is an old-style SMBsearch request. Ensure the
539 * value we return will fit in the range 1-255.
542 dptr
->dnum
= bitmap_find(sconn
->searches
.dptr_bmap
, 0);
544 if(dptr
->dnum
== -1 || dptr
->dnum
> 254) {
547 * Try and close the oldest handle not marked for
548 * expect close in the hope that the client has
549 * finished with that one.
552 dptr_close_oldest(sconn
, true);
554 /* Now try again... */
555 dptr
->dnum
= bitmap_find(sconn
->searches
.dptr_bmap
, 0);
556 if(dptr
->dnum
== -1 || dptr
->dnum
> 254) {
557 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr
->dnum
));
558 SAFE_FREE(dptr
->path
);
559 SAFE_FREE(dptr
->wcard
);
561 TALLOC_FREE(dir_hnd
);
562 return NT_STATUS_TOO_MANY_OPENED_FILES
;
568 * This is a new-style trans2 request. Allocate from
569 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
572 dptr
->dnum
= bitmap_find(sconn
->searches
.dptr_bmap
, 255);
574 if(dptr
->dnum
== -1 || dptr
->dnum
< 255) {
577 * Try and close the oldest handle close in the hope that
578 * the client has finished with that one. This will only
579 * happen in the case of the Win98 client bug where it leaks
583 dptr_close_oldest(sconn
, false);
585 /* Now try again... */
586 dptr
->dnum
= bitmap_find(sconn
->searches
.dptr_bmap
, 255);
588 if(dptr
->dnum
== -1 || dptr
->dnum
< 255) {
589 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr
->dnum
));
590 SAFE_FREE(dptr
->path
);
591 SAFE_FREE(dptr
->wcard
);
593 TALLOC_FREE(dir_hnd
);
594 return NT_STATUS_TOO_MANY_OPENED_FILES
;
599 bitmap_set(sconn
->searches
.dptr_bmap
, dptr
->dnum
);
601 dptr
->dnum
+= 1; /* Always bias the dnum by one - no zero dnums allowed. */
603 DLIST_ADD(sconn
->searches
.dirptrs
, dptr
);
606 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
607 dptr
->dnum
,path
,expect_close
));
615 /****************************************************************************
616 Wrapper functions to access the lower level directory handles.
617 ****************************************************************************/
619 void dptr_CloseDir(files_struct
*fsp
)
623 * Ugly hack. We have defined fdopendir to return ENOSYS if dirfd also isn't
624 * present. I hate Solaris. JRA.
627 if (fsp
->fh
->fd
!= -1 &&
628 fsp
->dptr
->dir_hnd
&&
629 dirfd(fsp
->dptr
->dir_hnd
->dir
)) {
630 /* The call below closes the underlying fd. */
634 dptr_close_internal(fsp
->dptr
);
639 void dptr_SeekDir(struct dptr_struct
*dptr
, long offset
)
641 SeekDir(dptr
->dir_hnd
, offset
);
644 long dptr_TellDir(struct dptr_struct
*dptr
)
646 return TellDir(dptr
->dir_hnd
);
649 bool dptr_has_wild(struct dptr_struct
*dptr
)
651 return dptr
->has_wild
;
654 int dptr_dnum(struct dptr_struct
*dptr
)
659 /****************************************************************************
660 Return the next visible file name, skipping veto'd and invisible files.
661 ****************************************************************************/
663 static const char *dptr_normal_ReadDirName(struct dptr_struct
*dptr
,
664 long *poffset
, SMB_STRUCT_STAT
*pst
,
667 /* Normal search for the next file. */
669 char *talloced
= NULL
;
671 while ((name
= ReadDirName(dptr
->dir_hnd
, poffset
, pst
, &talloced
))
673 if (is_visible_file(dptr
->conn
, dptr
->path
, name
, pst
, True
)) {
674 *ptalloced
= talloced
;
677 TALLOC_FREE(talloced
);
682 /****************************************************************************
683 Return the next visible file name, skipping veto'd and invisible files.
684 ****************************************************************************/
686 char *dptr_ReadDirName(TALLOC_CTX
*ctx
,
687 struct dptr_struct
*dptr
,
689 SMB_STRUCT_STAT
*pst
)
691 struct smb_filename smb_fname_base
;
693 const char *name_temp
= NULL
;
694 char *talloced
= NULL
;
695 char *pathreal
= NULL
;
696 char *found_name
= NULL
;
699 SET_STAT_INVALID(*pst
);
701 if (dptr
->has_wild
|| dptr
->did_stat
) {
702 name_temp
= dptr_normal_ReadDirName(dptr
, poffset
, pst
,
704 if (name_temp
== NULL
) {
707 if (talloced
!= NULL
) {
708 return talloc_move(ctx
, &talloced
);
710 return talloc_strdup(ctx
, name_temp
);
713 /* If poffset is -1 then we know we returned this name before and we
714 * have no wildcards. We're at the end of the directory. */
715 if (*poffset
== END_OF_DIRECTORY_OFFSET
) {
719 /* We know the stored wcard contains no wildcard characters.
720 * See if we can match with a stat call. If we can't, then set
721 * did_stat to true to ensure we only do this once and keep
724 dptr
->did_stat
= true;
726 /* First check if it should be visible. */
727 if (!is_visible_file(dptr
->conn
, dptr
->path
, dptr
->wcard
,
730 /* This only returns false if the file was found, but
731 is explicitly not visible. Set us to end of
732 directory, but return NULL as we know we can't ever
737 if (VALID_STAT(*pst
)) {
738 name
= talloc_strdup(ctx
, dptr
->wcard
);
742 pathreal
= talloc_asprintf(ctx
,
749 /* Create an smb_filename with stream_name == NULL. */
750 ZERO_STRUCT(smb_fname_base
);
751 smb_fname_base
.base_name
= pathreal
;
753 if (SMB_VFS_STAT(dptr
->conn
, &smb_fname_base
) == 0) {
754 *pst
= smb_fname_base
.st
;
755 name
= talloc_strdup(ctx
, dptr
->wcard
);
758 /* If we get any other error than ENOENT or ENOTDIR
759 then the file exists we just can't stat it. */
760 if (errno
!= ENOENT
&& errno
!= ENOTDIR
) {
761 name
= talloc_strdup(ctx
, dptr
->wcard
);
766 /* Stat failed. We know this is authoratiative if we are
767 * providing case sensitive semantics or the underlying
768 * filesystem is case sensitive.
770 if (dptr
->conn
->case_sensitive
||
771 !(dptr
->conn
->fs_capabilities
& FILE_CASE_SENSITIVE_SEARCH
))
777 * Try case-insensitive stat if the fs has the ability. This avoids
778 * scanning the whole directory.
780 ret
= SMB_VFS_GET_REAL_FILENAME(dptr
->conn
, dptr
->path
, dptr
->wcard
,
785 } else if (errno
== ENOENT
) {
786 /* The case-insensitive lookup was authoritative. */
790 TALLOC_FREE(pathreal
);
792 name_temp
= dptr_normal_ReadDirName(dptr
, poffset
, pst
, &talloced
);
793 if (name_temp
== NULL
) {
796 if (talloced
!= NULL
) {
797 return talloc_move(ctx
, &talloced
);
799 return talloc_strdup(ctx
, name_temp
);
802 TALLOC_FREE(pathreal
);
804 /* We need to set the underlying dir_hnd offset to -1
805 * also as this function is usually called with the
806 * output from TellDir. */
807 dptr
->dir_hnd
->offset
= *poffset
= END_OF_DIRECTORY_OFFSET
;
811 /****************************************************************************
812 Search for a file by name, skipping veto'ed and not visible files.
813 ****************************************************************************/
815 bool dptr_SearchDir(struct dptr_struct
*dptr
, const char *name
, long *poffset
, SMB_STRUCT_STAT
*pst
)
817 SET_STAT_INVALID(*pst
);
819 if (!dptr
->has_wild
&& (dptr
->dir_hnd
->offset
== END_OF_DIRECTORY_OFFSET
)) {
820 /* This is a singleton directory and we're already at the end. */
821 *poffset
= END_OF_DIRECTORY_OFFSET
;
825 return SearchDir(dptr
->dir_hnd
, name
, poffset
);
828 /****************************************************************************
829 Add the name we're returning into the underlying cache.
830 ****************************************************************************/
832 void dptr_DirCacheAdd(struct dptr_struct
*dptr
, const char *name
, long offset
)
834 DirCacheAdd(dptr
->dir_hnd
, name
, offset
);
837 /****************************************************************************
838 Initialize variables & state data at the beginning of all search SMB requests.
839 ****************************************************************************/
840 void dptr_init_search_op(struct dptr_struct
*dptr
)
842 SMB_VFS_INIT_SEARCH_OP(dptr
->conn
, dptr
->dir_hnd
->dir
);
845 /****************************************************************************
846 Fill the 5 byte server reserved dptr field.
847 ****************************************************************************/
849 bool dptr_fill(struct smbd_server_connection
*sconn
,
850 char *buf1
,unsigned int key
)
852 unsigned char *buf
= (unsigned char *)buf1
;
853 struct dptr_struct
*dptr
= dptr_get(sconn
, key
, false);
856 DEBUG(1,("filling null dirptr %d\n",key
));
859 offset
= (uint32
)TellDir(dptr
->dir_hnd
);
860 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key
,
861 (long)dptr
->dir_hnd
,(int)offset
));
867 /****************************************************************************
868 Fetch the dir ptr and seek it given the 5 byte server field.
869 ****************************************************************************/
871 struct dptr_struct
*dptr_fetch(struct smbd_server_connection
*sconn
,
874 unsigned int key
= *(unsigned char *)buf
;
875 struct dptr_struct
*dptr
= dptr_get(sconn
, key
, false);
880 DEBUG(3,("fetched null dirptr %d\n",key
));
884 offset
= IVAL(buf
,1);
885 if (offset
== (uint32
)-1) {
886 seekoff
= END_OF_DIRECTORY_OFFSET
;
888 seekoff
= (long)offset
;
890 SeekDir(dptr
->dir_hnd
,seekoff
);
891 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
892 key
, dptr
->path
, (int)seekoff
));
896 /****************************************************************************
898 ****************************************************************************/
900 struct dptr_struct
*dptr_fetch_lanman2(struct smbd_server_connection
*sconn
,
903 struct dptr_struct
*dptr
= dptr_get(sconn
, dptr_num
, false);
906 DEBUG(3,("fetched null dirptr %d\n",dptr_num
));
909 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num
,dptr
->path
));
913 /****************************************************************************
914 Check that a file matches a particular file type.
915 ****************************************************************************/
917 bool dir_check_ftype(connection_struct
*conn
, uint32 mode
, uint32 dirtype
)
921 /* Check the "may have" search bits. */
922 if (((mode
& ~dirtype
) & (FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_DIRECTORY
)) != 0)
925 /* Check the "must have" bits, which are the may have bits shifted eight */
926 /* If must have bit is set, the file/dir can not be returned in search unless the matching
927 file attribute is set */
928 mask
= ((dirtype
>> 8) & (FILE_ATTRIBUTE_DIRECTORY
|FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
|FILE_ATTRIBUTE_SYSTEM
)); /* & 0x37 */
930 if((mask
& (mode
& (FILE_ATTRIBUTE_DIRECTORY
|FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
|FILE_ATTRIBUTE_SYSTEM
))) == mask
) /* check if matching attribute present */
939 static bool mangle_mask_match(connection_struct
*conn
,
940 const char *filename
,
945 if (!name_to_8_3(filename
,mname
,False
,conn
->params
)) {
948 return mask_match_search(mname
,mask
,False
);
951 bool smbd_dirptr_get_entry(TALLOC_CTX
*ctx
,
952 struct dptr_struct
*dirptr
,
957 bool (*match_fn
)(TALLOC_CTX
*ctx
,
962 bool (*mode_fn
)(TALLOC_CTX
*ctx
,
964 struct smb_filename
*smb_fname
,
968 struct smb_filename
**_smb_fname
,
972 connection_struct
*conn
= dirptr
->conn
;
978 needslash
= ( dirptr
->path
[strlen(dirptr
->path
) -1] != '/');
983 SMB_STRUCT_STAT sbuf
;
987 char *pathreal
= NULL
;
988 struct smb_filename smb_fname
;
993 cur_offset
= dptr_TellDir(dirptr
);
994 prev_offset
= cur_offset
;
995 dname
= dptr_ReadDirName(ctx
, dirptr
, &cur_offset
, &sbuf
);
997 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
998 (long)dirptr
, cur_offset
));
1000 if (dname
== NULL
) {
1004 isdots
= (ISDOT(dname
) || ISDOTDOT(dname
));
1005 if (dont_descend
&& !isdots
) {
1011 * fname may get mangled, dname is never mangled.
1012 * Whenever we're accessing the filesystem we use
1013 * pathreal which is composed from dname.
1016 ok
= match_fn(ctx
, private_data
, dname
, mask
, &fname
);
1022 pathreal
= talloc_asprintf(ctx
, "%s%s%s",
1032 /* Create smb_fname with NULL stream_name. */
1033 ZERO_STRUCT(smb_fname
);
1034 smb_fname
.base_name
= pathreal
;
1035 smb_fname
.st
= sbuf
;
1037 ok
= mode_fn(ctx
, private_data
, &smb_fname
, &mode
);
1041 TALLOC_FREE(pathreal
);
1045 if (!dir_check_ftype(conn
, mode
, dirtype
)) {
1046 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1047 fname
, (unsigned int)mode
, (unsigned int)dirtype
));
1050 TALLOC_FREE(pathreal
);
1054 if (ask_sharemode
) {
1055 struct timespec write_time_ts
;
1056 struct file_id fileid
;
1058 fileid
= vfs_file_id_from_sbuf(conn
,
1060 get_file_infos(fileid
, 0, NULL
, &write_time_ts
);
1061 if (!null_timespec(write_time_ts
)) {
1062 update_stat_ex_mtime(&smb_fname
.st
,
1067 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1069 mask
, smb_fname_str_dbg(&smb_fname
),
1072 DirCacheAdd(dirptr
->dir_hnd
, dname
, cur_offset
);
1076 status
= copy_smb_filename(ctx
, &smb_fname
, _smb_fname
);
1077 TALLOC_FREE(pathreal
);
1078 if (!NT_STATUS_IS_OK(status
)) {
1083 *_prev_offset
= prev_offset
;
1091 /****************************************************************************
1092 Get an 8.3 directory entry.
1093 ****************************************************************************/
1095 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX
*ctx
,
1101 connection_struct
*conn
= (connection_struct
*)private_data
;
1103 if ((strcmp(mask
,"*.*") == 0) ||
1104 mask_match_search(dname
, mask
, false) ||
1105 mangle_mask_match(conn
, dname
, mask
)) {
1109 if (!mangle_is_8_3(dname
, false, conn
->params
)) {
1110 bool ok
= name_to_8_3(dname
, mname
, false,
1120 *_fname
= talloc_strdup(ctx
, fname
);
1121 if (*_fname
== NULL
) {
1131 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX
*ctx
,
1133 struct smb_filename
*smb_fname
,
1136 connection_struct
*conn
= (connection_struct
*)private_data
;
1138 if (!VALID_STAT(smb_fname
->st
)) {
1139 if ((SMB_VFS_STAT(conn
, smb_fname
)) != 0) {
1140 DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1141 "Couldn't stat [%s]. Error "
1143 smb_fname_str_dbg(smb_fname
),
1149 *_mode
= dos_mode(conn
, smb_fname
);
1153 bool get_dir_entry(TALLOC_CTX
*ctx
,
1154 struct dptr_struct
*dirptr
,
1160 struct timespec
*_date
,
1164 connection_struct
*conn
= dirptr
->conn
;
1166 struct smb_filename
*smb_fname
= NULL
;
1171 ok
= smbd_dirptr_get_entry(ctx
,
1177 smbd_dirptr_8_3_match_fn
,
1178 smbd_dirptr_8_3_mode_fn
,
1188 *_fname
= talloc_move(ctx
, &fname
);
1189 *_size
= smb_fname
->st
.st_ex_size
;
1191 *_date
= smb_fname
->st
.st_ex_mtime
;
1192 TALLOC_FREE(smb_fname
);
1196 /*******************************************************************
1197 Check to see if a user can read a file. This is only approximate,
1198 it is used as part of the "hide unreadable" option. Don't
1199 use it for anything security sensitive.
1200 ********************************************************************/
1202 static bool user_can_read_file(connection_struct
*conn
,
1203 struct smb_filename
*smb_fname
)
1206 * Never hide files from the root user.
1207 * We use (uid_t)0 here not sec_initial_uid()
1208 * as make test uses a single user context.
1211 if (get_current_uid(conn
) == (uid_t
)0) {
1215 return NT_STATUS_IS_OK(smbd_check_access_rights(conn
,
1220 /*******************************************************************
1221 Check to see if a user can write a file (and only files, we do not
1222 check dirs on this one). This is only approximate,
1223 it is used as part of the "hide unwriteable" option. Don't
1224 use it for anything security sensitive.
1225 ********************************************************************/
1227 static bool user_can_write_file(connection_struct
*conn
,
1228 const struct smb_filename
*smb_fname
)
1231 * Never hide files from the root user.
1232 * We use (uid_t)0 here not sec_initial_uid()
1233 * as make test uses a single user context.
1236 if (get_current_uid(conn
) == (uid_t
)0) {
1240 SMB_ASSERT(VALID_STAT(smb_fname
->st
));
1242 /* Pseudo-open the file */
1244 if(S_ISDIR(smb_fname
->st
.st_ex_mode
)) {
1248 return can_write_to_file(conn
, smb_fname
);
1251 /*******************************************************************
1252 Is a file a "special" type ?
1253 ********************************************************************/
1255 static bool file_is_special(connection_struct
*conn
,
1256 const struct smb_filename
*smb_fname
)
1259 * Never hide files from the root user.
1260 * We use (uid_t)0 here not sec_initial_uid()
1261 * as make test uses a single user context.
1264 if (get_current_uid(conn
) == (uid_t
)0) {
1268 SMB_ASSERT(VALID_STAT(smb_fname
->st
));
1270 if (S_ISREG(smb_fname
->st
.st_ex_mode
) ||
1271 S_ISDIR(smb_fname
->st
.st_ex_mode
) ||
1272 S_ISLNK(smb_fname
->st
.st_ex_mode
))
1278 /*******************************************************************
1279 Should the file be seen by the client?
1280 NOTE: A successful return is no guarantee of the file's existence.
1281 ********************************************************************/
1283 bool is_visible_file(connection_struct
*conn
, const char *dir_path
,
1284 const char *name
, SMB_STRUCT_STAT
*pst
, bool use_veto
)
1286 bool hide_unreadable
= lp_hideunreadable(SNUM(conn
));
1287 bool hide_unwriteable
= lp_hideunwriteable_files(SNUM(conn
));
1288 bool hide_special
= lp_hide_special_files(SNUM(conn
));
1290 struct smb_filename
*smb_fname_base
= NULL
;
1294 if ((strcmp(".",name
) == 0) || (strcmp("..",name
) == 0)) {
1295 return True
; /* . and .. are always visible. */
1298 /* If it's a vetoed file, pretend it doesn't even exist */
1299 if (use_veto
&& IS_VETO_PATH(conn
, name
)) {
1300 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name
));
1304 if (hide_unreadable
|| hide_unwriteable
|| hide_special
) {
1305 entry
= talloc_asprintf(talloc_tos(), "%s/%s", dir_path
, name
);
1311 /* Create an smb_filename with stream_name == NULL. */
1312 status
= create_synthetic_smb_fname(talloc_tos(), entry
, NULL
,
1313 pst
, &smb_fname_base
);
1314 if (!NT_STATUS_IS_OK(status
)) {
1319 /* If the file name does not exist, there's no point checking
1320 * the configuration options. We succeed, on the basis that the
1321 * checks *might* have passed if the file was present.
1323 if (!VALID_STAT(*pst
)) {
1324 if (SMB_VFS_STAT(conn
, smb_fname_base
) != 0) {
1328 *pst
= smb_fname_base
->st
;
1332 /* Honour _hide unreadable_ option */
1333 if (hide_unreadable
&&
1334 !user_can_read_file(conn
, smb_fname_base
)) {
1335 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1340 /* Honour _hide unwriteable_ option */
1341 if (hide_unwriteable
&& !user_can_write_file(conn
,
1343 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1348 /* Honour _hide_special_ option */
1349 if (hide_special
&& file_is_special(conn
, smb_fname_base
)) {
1350 DEBUG(10,("is_visible_file: file %s is special.\n",
1359 TALLOC_FREE(smb_fname_base
);
1364 static int smb_Dir_destructor(struct smb_Dir
*dirp
)
1368 if (dirp
->conn
->sconn
) {
1369 files_struct
*fsp
= file_find_fd(dirp
->conn
->sconn
,
1372 /* The call below closes the underlying fd. */
1377 SMB_VFS_CLOSEDIR(dirp
->conn
,dirp
->dir
);
1379 if (dirp
->conn
->sconn
&& !dirp
->conn
->sconn
->using_smb2
) {
1380 dirp
->conn
->sconn
->searches
.dirhandles_open
--;
1385 /*******************************************************************
1387 ********************************************************************/
1389 struct smb_Dir
*OpenDir(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
,
1394 struct smb_Dir
*dirp
= talloc_zero(mem_ctx
, struct smb_Dir
);
1395 struct smbd_server_connection
*sconn
= conn
->sconn
;
1402 dirp
->name_cache_size
= lp_directory_name_cache_size(SNUM(conn
));
1404 dirp
->dir_path
= talloc_strdup(dirp
, name
);
1405 if (!dirp
->dir_path
) {
1410 if (sconn
&& !sconn
->using_smb2
) {
1411 sconn
->searches
.dirhandles_open
++;
1413 talloc_set_destructor(dirp
, smb_Dir_destructor
);
1415 dirp
->dir
= SMB_VFS_OPENDIR(conn
, dirp
->dir_path
, mask
, attr
);
1417 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp
->dir_path
,
1429 /*******************************************************************
1430 Open a directory from an fsp.
1431 ********************************************************************/
1433 static struct smb_Dir
*OpenDir_fsp(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
,
1438 struct smb_Dir
*dirp
= talloc_zero(mem_ctx
, struct smb_Dir
);
1439 struct smbd_server_connection
*sconn
= conn
->sconn
;
1446 dirp
->name_cache_size
= lp_directory_name_cache_size(SNUM(conn
));
1448 dirp
->dir_path
= talloc_strdup(dirp
, fsp
->fsp_name
->base_name
);
1449 if (!dirp
->dir_path
) {
1454 if (sconn
&& !sconn
->using_smb2
) {
1455 sconn
->searches
.dirhandles_open
++;
1457 talloc_set_destructor(dirp
, smb_Dir_destructor
);
1459 if (fsp
->is_directory
&& fsp
->fh
->fd
!= -1) {
1460 dirp
->dir
= SMB_VFS_FDOPENDIR(fsp
, mask
, attr
);
1461 if (dirp
->dir
== NULL
) {
1462 DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1466 if (errno
!= ENOSYS
) {
1472 if (dirp
->dir
== NULL
) {
1473 /* FDOPENDIR didn't work. Use OPENDIR instead. */
1474 dirp
->dir
= SMB_VFS_OPENDIR(conn
, dirp
->dir_path
, mask
, attr
);
1478 DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp
->dir_path
,
1491 /*******************************************************************
1492 Read from a directory.
1493 Return directory entry, current offset, and optional stat information.
1494 Don't check for veto or invisible files.
1495 ********************************************************************/
1497 const char *ReadDirName(struct smb_Dir
*dirp
, long *poffset
,
1498 SMB_STRUCT_STAT
*sbuf
, char **ptalloced
)
1501 char *talloced
= NULL
;
1502 connection_struct
*conn
= dirp
->conn
;
1504 /* Cheat to allow . and .. to be the first entries returned. */
1505 if (((*poffset
== START_OF_DIRECTORY_OFFSET
) ||
1506 (*poffset
== DOT_DOT_DIRECTORY_OFFSET
)) && (dirp
->file_number
< 2))
1508 if (dirp
->file_number
== 0) {
1510 *poffset
= dirp
->offset
= START_OF_DIRECTORY_OFFSET
;
1513 *poffset
= dirp
->offset
= DOT_DOT_DIRECTORY_OFFSET
;
1515 dirp
->file_number
++;
1518 } else if (*poffset
== END_OF_DIRECTORY_OFFSET
) {
1519 *poffset
= dirp
->offset
= END_OF_DIRECTORY_OFFSET
;
1522 /* A real offset, seek to it. */
1523 SeekDir(dirp
, *poffset
);
1526 while ((n
= vfs_readdirname(conn
, dirp
->dir
, sbuf
, &talloced
))) {
1527 /* Ignore . and .. - we've already returned them. */
1529 if ((n
[1] == '\0') || (n
[1] == '.' && n
[2] == '\0')) {
1530 TALLOC_FREE(talloced
);
1534 *poffset
= dirp
->offset
= SMB_VFS_TELLDIR(conn
, dirp
->dir
);
1535 *ptalloced
= talloced
;
1536 dirp
->file_number
++;
1539 *poffset
= dirp
->offset
= END_OF_DIRECTORY_OFFSET
;
1544 /*******************************************************************
1545 Rewind to the start.
1546 ********************************************************************/
1548 void RewindDir(struct smb_Dir
*dirp
, long *poffset
)
1550 SMB_VFS_REWINDDIR(dirp
->conn
, dirp
->dir
);
1551 dirp
->file_number
= 0;
1552 dirp
->offset
= START_OF_DIRECTORY_OFFSET
;
1553 *poffset
= START_OF_DIRECTORY_OFFSET
;
1556 /*******************************************************************
1558 ********************************************************************/
1560 void SeekDir(struct smb_Dir
*dirp
, long offset
)
1562 if (offset
!= dirp
->offset
) {
1563 if (offset
== START_OF_DIRECTORY_OFFSET
) {
1564 RewindDir(dirp
, &offset
);
1566 * Ok we should really set the file number here
1567 * to 1 to enable ".." to be returned next. Trouble
1568 * is I'm worried about callers using SeekDir(dirp,0)
1569 * as equivalent to RewindDir(). So leave this alone
1572 } else if (offset
== DOT_DOT_DIRECTORY_OFFSET
) {
1573 RewindDir(dirp
, &offset
);
1575 * Set the file number to 2 - we want to get the first
1576 * real file entry (the one we return after "..")
1577 * on the next ReadDir.
1579 dirp
->file_number
= 2;
1580 } else if (offset
== END_OF_DIRECTORY_OFFSET
) {
1581 ; /* Don't seek in this case. */
1583 SMB_VFS_SEEKDIR(dirp
->conn
, dirp
->dir
, offset
);
1585 dirp
->offset
= offset
;
1589 /*******************************************************************
1590 Tell a dir position.
1591 ********************************************************************/
1593 long TellDir(struct smb_Dir
*dirp
)
1595 return(dirp
->offset
);
1598 /*******************************************************************
1599 Add an entry into the dcache.
1600 ********************************************************************/
1602 void DirCacheAdd(struct smb_Dir
*dirp
, const char *name
, long offset
)
1604 struct name_cache_entry
*e
;
1606 if (dirp
->name_cache_size
== 0) {
1610 if (dirp
->name_cache
== NULL
) {
1611 dirp
->name_cache
= talloc_zero_array(
1612 dirp
, struct name_cache_entry
, dirp
->name_cache_size
);
1614 if (dirp
->name_cache
== NULL
) {
1619 dirp
->name_cache_index
= (dirp
->name_cache_index
+1) %
1620 dirp
->name_cache_size
;
1621 e
= &dirp
->name_cache
[dirp
->name_cache_index
];
1622 TALLOC_FREE(e
->name
);
1623 e
->name
= talloc_strdup(dirp
, name
);
1627 /*******************************************************************
1628 Find an entry by name. Leave us at the offset after it.
1629 Don't check for veto or invisible files.
1630 ********************************************************************/
1632 bool SearchDir(struct smb_Dir
*dirp
, const char *name
, long *poffset
)
1635 const char *entry
= NULL
;
1636 char *talloced
= NULL
;
1637 connection_struct
*conn
= dirp
->conn
;
1639 /* Search back in the name cache. */
1640 if (dirp
->name_cache_size
&& dirp
->name_cache
) {
1641 for (i
= dirp
->name_cache_index
; i
>= 0; i
--) {
1642 struct name_cache_entry
*e
= &dirp
->name_cache
[i
];
1643 if (e
->name
&& (conn
->case_sensitive
? (strcmp(e
->name
, name
) == 0) : strequal(e
->name
, name
))) {
1644 *poffset
= e
->offset
;
1645 SeekDir(dirp
, e
->offset
);
1649 for (i
= dirp
->name_cache_size
- 1; i
> dirp
->name_cache_index
; i
--) {
1650 struct name_cache_entry
*e
= &dirp
->name_cache
[i
];
1651 if (e
->name
&& (conn
->case_sensitive
? (strcmp(e
->name
, name
) == 0) : strequal(e
->name
, name
))) {
1652 *poffset
= e
->offset
;
1653 SeekDir(dirp
, e
->offset
);
1659 /* Not found in the name cache. Rewind directory and start from scratch. */
1660 SMB_VFS_REWINDDIR(conn
, dirp
->dir
);
1661 dirp
->file_number
= 0;
1662 *poffset
= START_OF_DIRECTORY_OFFSET
;
1663 while ((entry
= ReadDirName(dirp
, poffset
, NULL
, &talloced
))) {
1664 if (conn
->case_sensitive
? (strcmp(entry
, name
) == 0) : strequal(entry
, name
)) {
1665 TALLOC_FREE(talloced
);
1668 TALLOC_FREE(talloced
);
1673 /*****************************************************************
1674 Is this directory empty ?
1675 *****************************************************************/
1677 NTSTATUS
can_delete_directory(struct connection_struct
*conn
,
1678 const char *dirname
)
1680 NTSTATUS status
= NT_STATUS_OK
;
1682 const char *dname
= NULL
;
1683 char *talloced
= NULL
;
1685 struct smb_Dir
*dir_hnd
= OpenDir(talloc_tos(), conn
,
1689 return map_nt_error_from_unix(errno
);
1692 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
, &talloced
))) {
1693 /* Quick check for "." and ".." */
1694 if (dname
[0] == '.') {
1695 if (!dname
[1] || (dname
[1] == '.' && !dname
[2])) {
1696 TALLOC_FREE(talloced
);
1701 if (!is_visible_file(conn
, dirname
, dname
, &st
, True
)) {
1702 TALLOC_FREE(talloced
);
1706 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1708 status
= NT_STATUS_DIRECTORY_NOT_EMPTY
;
1711 TALLOC_FREE(talloced
);
1712 TALLOC_FREE(dir_hnd
);