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
;
432 if (fsp
&& fsp
->is_directory
&& fsp
->fh
->fd
!= -1) {
433 path
= fsp
->fsp_name
->base_name
;
436 DEBUG(5,("dptr_create dir=%s\n", path
));
439 DEBUG(0,("dptr_create: called with fake connection_struct\n"));
440 return NT_STATUS_INTERNAL_ERROR
;
444 return NT_STATUS_INVALID_PARAMETER
;
447 status
= check_parent_access(conn
,
451 if (!NT_STATUS_IS_OK(status
)) {
452 DEBUG(5,("dptr_create: parent access check for path "
453 "%s failed with %s\n",
460 dir_hnd
= OpenDir_fsp(NULL
, conn
, fsp
, wcard
, attr
);
462 dir_hnd
= OpenDir(NULL
, conn
, path
, wcard
, attr
);
466 return map_nt_error_from_unix(errno
);
469 if (sconn
->searches
.dirhandles_open
>= MAX_OPEN_DIRECTORIES
) {
470 dptr_idleoldest(sconn
);
473 dptr
= SMB_MALLOC_P(struct dptr_struct
);
475 DEBUG(0,("malloc fail in dptr_create.\n"));
476 TALLOC_FREE(dir_hnd
);
477 return NT_STATUS_NO_MEMORY
;
485 * This is an old-style SMBsearch request. Ensure the
486 * value we return will fit in the range 1-255.
489 dptr
->dnum
= bitmap_find(sconn
->searches
.dptr_bmap
, 0);
491 if(dptr
->dnum
== -1 || dptr
->dnum
> 254) {
494 * Try and close the oldest handle not marked for
495 * expect close in the hope that the client has
496 * finished with that one.
499 dptr_close_oldest(sconn
, true);
501 /* Now try again... */
502 dptr
->dnum
= bitmap_find(sconn
->searches
.dptr_bmap
, 0);
503 if(dptr
->dnum
== -1 || dptr
->dnum
> 254) {
504 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr
->dnum
));
506 TALLOC_FREE(dir_hnd
);
507 return NT_STATUS_TOO_MANY_OPENED_FILES
;
513 * This is a new-style trans2 request. Allocate from
514 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
517 dptr
->dnum
= bitmap_find(sconn
->searches
.dptr_bmap
, 255);
519 if(dptr
->dnum
== -1 || dptr
->dnum
< 255) {
522 * Try and close the oldest handle close in the hope that
523 * the client has finished with that one. This will only
524 * happen in the case of the Win98 client bug where it leaks
528 dptr_close_oldest(sconn
, false);
530 /* Now try again... */
531 dptr
->dnum
= bitmap_find(sconn
->searches
.dptr_bmap
, 255);
533 if(dptr
->dnum
== -1 || dptr
->dnum
< 255) {
534 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr
->dnum
));
536 TALLOC_FREE(dir_hnd
);
537 return NT_STATUS_TOO_MANY_OPENED_FILES
;
542 bitmap_set(sconn
->searches
.dptr_bmap
, dptr
->dnum
);
544 dptr
->dnum
+= 1; /* Always bias the dnum by one - no zero dnums allowed. */
546 string_set(&dptr
->path
,path
);
548 dptr
->dir_hnd
= dir_hnd
;
550 dptr
->expect_close
= expect_close
;
551 dptr
->wcard
= SMB_STRDUP(wcard
);
553 bitmap_clear(sconn
->searches
.dptr_bmap
, dptr
->dnum
- 1);
555 TALLOC_FREE(dir_hnd
);
556 return NT_STATUS_NO_MEMORY
;
558 if (lp_posix_pathnames() || (wcard
[0] == '.' && wcard
[1] == 0)) {
559 dptr
->has_wild
= True
;
561 dptr
->has_wild
= wcard_has_wild
;
566 DLIST_ADD(sconn
->searches
.dirptrs
, dptr
);
568 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
569 dptr
->dnum
,path
,expect_close
));
577 /****************************************************************************
578 Wrapper functions to access the lower level directory handles.
579 ****************************************************************************/
581 void dptr_CloseDir(files_struct
*fsp
)
585 * Ugly hack. We have defined fdopendir to return ENOSYS if dirfd also isn't
586 * present. I hate Solaris. JRA.
589 if (fsp
->fh
->fd
!= -1 &&
590 fsp
->dptr
->dir_hnd
&&
591 dirfd(fsp
->dptr
->dir_hnd
->dir
)) {
592 /* The call below closes the underlying fd. */
596 dptr_close_internal(fsp
->dptr
);
601 void dptr_SeekDir(struct dptr_struct
*dptr
, long offset
)
603 SeekDir(dptr
->dir_hnd
, offset
);
606 long dptr_TellDir(struct dptr_struct
*dptr
)
608 return TellDir(dptr
->dir_hnd
);
611 bool dptr_has_wild(struct dptr_struct
*dptr
)
613 return dptr
->has_wild
;
616 int dptr_dnum(struct dptr_struct
*dptr
)
621 /****************************************************************************
622 Return the next visible file name, skipping veto'd and invisible files.
623 ****************************************************************************/
625 static const char *dptr_normal_ReadDirName(struct dptr_struct
*dptr
,
626 long *poffset
, SMB_STRUCT_STAT
*pst
,
629 /* Normal search for the next file. */
631 char *talloced
= NULL
;
633 while ((name
= ReadDirName(dptr
->dir_hnd
, poffset
, pst
, &talloced
))
635 if (is_visible_file(dptr
->conn
, dptr
->path
, name
, pst
, True
)) {
636 *ptalloced
= talloced
;
639 TALLOC_FREE(talloced
);
644 /****************************************************************************
645 Return the next visible file name, skipping veto'd and invisible files.
646 ****************************************************************************/
648 char *dptr_ReadDirName(TALLOC_CTX
*ctx
,
649 struct dptr_struct
*dptr
,
651 SMB_STRUCT_STAT
*pst
)
653 struct smb_filename smb_fname_base
;
655 const char *name_temp
= NULL
;
656 char *talloced
= NULL
;
657 char *pathreal
= NULL
;
658 char *found_name
= NULL
;
661 SET_STAT_INVALID(*pst
);
663 if (dptr
->has_wild
|| dptr
->did_stat
) {
664 name_temp
= dptr_normal_ReadDirName(dptr
, poffset
, pst
,
666 if (name_temp
== NULL
) {
669 if (talloced
!= NULL
) {
670 return talloc_move(ctx
, &talloced
);
672 return talloc_strdup(ctx
, name_temp
);
675 /* If poffset is -1 then we know we returned this name before and we
676 * have no wildcards. We're at the end of the directory. */
677 if (*poffset
== END_OF_DIRECTORY_OFFSET
) {
681 /* We know the stored wcard contains no wildcard characters.
682 * See if we can match with a stat call. If we can't, then set
683 * did_stat to true to ensure we only do this once and keep
686 dptr
->did_stat
= true;
688 /* First check if it should be visible. */
689 if (!is_visible_file(dptr
->conn
, dptr
->path
, dptr
->wcard
,
692 /* This only returns false if the file was found, but
693 is explicitly not visible. Set us to end of
694 directory, but return NULL as we know we can't ever
699 if (VALID_STAT(*pst
)) {
700 name
= talloc_strdup(ctx
, dptr
->wcard
);
704 pathreal
= talloc_asprintf(ctx
,
711 /* Create an smb_filename with stream_name == NULL. */
712 ZERO_STRUCT(smb_fname_base
);
713 smb_fname_base
.base_name
= pathreal
;
715 if (SMB_VFS_STAT(dptr
->conn
, &smb_fname_base
) == 0) {
716 *pst
= smb_fname_base
.st
;
717 name
= talloc_strdup(ctx
, dptr
->wcard
);
720 /* If we get any other error than ENOENT or ENOTDIR
721 then the file exists we just can't stat it. */
722 if (errno
!= ENOENT
&& errno
!= ENOTDIR
) {
723 name
= talloc_strdup(ctx
, dptr
->wcard
);
728 /* Stat failed. We know this is authoratiative if we are
729 * providing case sensitive semantics or the underlying
730 * filesystem is case sensitive.
732 if (dptr
->conn
->case_sensitive
||
733 !(dptr
->conn
->fs_capabilities
& FILE_CASE_SENSITIVE_SEARCH
))
739 * Try case-insensitive stat if the fs has the ability. This avoids
740 * scanning the whole directory.
742 ret
= SMB_VFS_GET_REAL_FILENAME(dptr
->conn
, dptr
->path
, dptr
->wcard
,
747 } else if (errno
== ENOENT
) {
748 /* The case-insensitive lookup was authoritative. */
752 TALLOC_FREE(pathreal
);
754 name_temp
= dptr_normal_ReadDirName(dptr
, poffset
, pst
, &talloced
);
755 if (name_temp
== NULL
) {
758 if (talloced
!= NULL
) {
759 return talloc_move(ctx
, &talloced
);
761 return talloc_strdup(ctx
, name_temp
);
764 TALLOC_FREE(pathreal
);
766 /* We need to set the underlying dir_hnd offset to -1
767 * also as this function is usually called with the
768 * output from TellDir. */
769 dptr
->dir_hnd
->offset
= *poffset
= END_OF_DIRECTORY_OFFSET
;
773 /****************************************************************************
774 Search for a file by name, skipping veto'ed and not visible files.
775 ****************************************************************************/
777 bool dptr_SearchDir(struct dptr_struct
*dptr
, const char *name
, long *poffset
, SMB_STRUCT_STAT
*pst
)
779 SET_STAT_INVALID(*pst
);
781 if (!dptr
->has_wild
&& (dptr
->dir_hnd
->offset
== END_OF_DIRECTORY_OFFSET
)) {
782 /* This is a singleton directory and we're already at the end. */
783 *poffset
= END_OF_DIRECTORY_OFFSET
;
787 return SearchDir(dptr
->dir_hnd
, name
, poffset
);
790 /****************************************************************************
791 Add the name we're returning into the underlying cache.
792 ****************************************************************************/
794 void dptr_DirCacheAdd(struct dptr_struct
*dptr
, const char *name
, long offset
)
796 DirCacheAdd(dptr
->dir_hnd
, name
, offset
);
799 /****************************************************************************
800 Initialize variables & state data at the beginning of all search SMB requests.
801 ****************************************************************************/
802 void dptr_init_search_op(struct dptr_struct
*dptr
)
804 SMB_VFS_INIT_SEARCH_OP(dptr
->conn
, dptr
->dir_hnd
->dir
);
807 /****************************************************************************
808 Fill the 5 byte server reserved dptr field.
809 ****************************************************************************/
811 bool dptr_fill(struct smbd_server_connection
*sconn
,
812 char *buf1
,unsigned int key
)
814 unsigned char *buf
= (unsigned char *)buf1
;
815 struct dptr_struct
*dptr
= dptr_get(sconn
, key
, false);
818 DEBUG(1,("filling null dirptr %d\n",key
));
821 offset
= (uint32
)TellDir(dptr
->dir_hnd
);
822 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key
,
823 (long)dptr
->dir_hnd
,(int)offset
));
829 /****************************************************************************
830 Fetch the dir ptr and seek it given the 5 byte server field.
831 ****************************************************************************/
833 struct dptr_struct
*dptr_fetch(struct smbd_server_connection
*sconn
,
836 unsigned int key
= *(unsigned char *)buf
;
837 struct dptr_struct
*dptr
= dptr_get(sconn
, key
, false);
842 DEBUG(3,("fetched null dirptr %d\n",key
));
846 offset
= IVAL(buf
,1);
847 if (offset
== (uint32
)-1) {
848 seekoff
= END_OF_DIRECTORY_OFFSET
;
850 seekoff
= (long)offset
;
852 SeekDir(dptr
->dir_hnd
,seekoff
);
853 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
854 key
, dptr
->path
, (int)seekoff
));
858 /****************************************************************************
860 ****************************************************************************/
862 struct dptr_struct
*dptr_fetch_lanman2(struct smbd_server_connection
*sconn
,
865 struct dptr_struct
*dptr
= dptr_get(sconn
, dptr_num
, false);
868 DEBUG(3,("fetched null dirptr %d\n",dptr_num
));
871 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num
,dptr
->path
));
875 /****************************************************************************
876 Check that a file matches a particular file type.
877 ****************************************************************************/
879 bool dir_check_ftype(connection_struct
*conn
, uint32 mode
, uint32 dirtype
)
883 /* Check the "may have" search bits. */
884 if (((mode
& ~dirtype
) & (FILE_ATTRIBUTE_HIDDEN
| FILE_ATTRIBUTE_SYSTEM
| FILE_ATTRIBUTE_DIRECTORY
)) != 0)
887 /* Check the "must have" bits, which are the may have bits shifted eight */
888 /* If must have bit is set, the file/dir can not be returned in search unless the matching
889 file attribute is set */
890 mask
= ((dirtype
>> 8) & (FILE_ATTRIBUTE_DIRECTORY
|FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
|FILE_ATTRIBUTE_SYSTEM
)); /* & 0x37 */
892 if((mask
& (mode
& (FILE_ATTRIBUTE_DIRECTORY
|FILE_ATTRIBUTE_ARCHIVE
|FILE_ATTRIBUTE_READONLY
|FILE_ATTRIBUTE_HIDDEN
|FILE_ATTRIBUTE_SYSTEM
))) == mask
) /* check if matching attribute present */
901 static bool mangle_mask_match(connection_struct
*conn
,
902 const char *filename
,
907 if (!name_to_8_3(filename
,mname
,False
,conn
->params
)) {
910 return mask_match_search(mname
,mask
,False
);
913 bool smbd_dirptr_get_entry(TALLOC_CTX
*ctx
,
914 struct dptr_struct
*dirptr
,
919 bool (*match_fn
)(TALLOC_CTX
*ctx
,
924 bool (*mode_fn
)(TALLOC_CTX
*ctx
,
926 struct smb_filename
*smb_fname
,
930 struct smb_filename
**_smb_fname
,
934 connection_struct
*conn
= dirptr
->conn
;
940 needslash
= ( dirptr
->path
[strlen(dirptr
->path
) -1] != '/');
945 SMB_STRUCT_STAT sbuf
;
949 char *pathreal
= NULL
;
950 struct smb_filename smb_fname
;
955 cur_offset
= dptr_TellDir(dirptr
);
956 prev_offset
= cur_offset
;
957 dname
= dptr_ReadDirName(ctx
, dirptr
, &cur_offset
, &sbuf
);
959 DEBUG(6,("smbd_dirptr_get_entry: dirptr 0x%lx now at offset %ld\n",
960 (long)dirptr
, cur_offset
));
966 isdots
= (ISDOT(dname
) || ISDOTDOT(dname
));
967 if (dont_descend
&& !isdots
) {
973 * fname may get mangled, dname is never mangled.
974 * Whenever we're accessing the filesystem we use
975 * pathreal which is composed from dname.
978 ok
= match_fn(ctx
, private_data
, dname
, mask
, &fname
);
984 pathreal
= talloc_asprintf(ctx
, "%s%s%s",
994 /* Create smb_fname with NULL stream_name. */
995 ZERO_STRUCT(smb_fname
);
996 smb_fname
.base_name
= pathreal
;
999 ok
= mode_fn(ctx
, private_data
, &smb_fname
, &mode
);
1003 TALLOC_FREE(pathreal
);
1007 if (!dir_check_ftype(conn
, mode
, dirtype
)) {
1008 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",
1009 fname
, (unsigned int)mode
, (unsigned int)dirtype
));
1012 TALLOC_FREE(pathreal
);
1016 if (ask_sharemode
) {
1017 struct timespec write_time_ts
;
1018 struct file_id fileid
;
1020 fileid
= vfs_file_id_from_sbuf(conn
,
1022 get_file_infos(fileid
, 0, NULL
, &write_time_ts
);
1023 if (!null_timespec(write_time_ts
)) {
1024 update_stat_ex_mtime(&smb_fname
.st
,
1029 DEBUG(3,("smbd_dirptr_get_entry mask=[%s] found %s "
1031 mask
, smb_fname_str_dbg(&smb_fname
),
1034 DirCacheAdd(dirptr
->dir_hnd
, dname
, cur_offset
);
1038 status
= copy_smb_filename(ctx
, &smb_fname
, _smb_fname
);
1039 TALLOC_FREE(pathreal
);
1040 if (!NT_STATUS_IS_OK(status
)) {
1045 *_prev_offset
= prev_offset
;
1053 /****************************************************************************
1054 Get an 8.3 directory entry.
1055 ****************************************************************************/
1057 static bool smbd_dirptr_8_3_match_fn(TALLOC_CTX
*ctx
,
1063 connection_struct
*conn
= (connection_struct
*)private_data
;
1065 if ((strcmp(mask
,"*.*") == 0) ||
1066 mask_match_search(dname
, mask
, false) ||
1067 mangle_mask_match(conn
, dname
, mask
)) {
1071 if (!mangle_is_8_3(dname
, false, conn
->params
)) {
1072 bool ok
= name_to_8_3(dname
, mname
, false,
1082 *_fname
= talloc_strdup(ctx
, fname
);
1083 if (*_fname
== NULL
) {
1093 static bool smbd_dirptr_8_3_mode_fn(TALLOC_CTX
*ctx
,
1095 struct smb_filename
*smb_fname
,
1098 connection_struct
*conn
= (connection_struct
*)private_data
;
1100 if (!VALID_STAT(smb_fname
->st
)) {
1101 if ((SMB_VFS_STAT(conn
, smb_fname
)) != 0) {
1102 DEBUG(5,("smbd_dirptr_8_3_mode_fn: "
1103 "Couldn't stat [%s]. Error "
1105 smb_fname_str_dbg(smb_fname
),
1111 *_mode
= dos_mode(conn
, smb_fname
);
1115 bool get_dir_entry(TALLOC_CTX
*ctx
,
1116 struct dptr_struct
*dirptr
,
1122 struct timespec
*_date
,
1126 connection_struct
*conn
= dirptr
->conn
;
1128 struct smb_filename
*smb_fname
= NULL
;
1133 ok
= smbd_dirptr_get_entry(ctx
,
1139 smbd_dirptr_8_3_match_fn
,
1140 smbd_dirptr_8_3_mode_fn
,
1150 *_fname
= talloc_move(ctx
, &fname
);
1151 *_size
= smb_fname
->st
.st_ex_size
;
1153 *_date
= smb_fname
->st
.st_ex_mtime
;
1154 TALLOC_FREE(smb_fname
);
1158 /*******************************************************************
1159 Check to see if a user can read a file. This is only approximate,
1160 it is used as part of the "hide unreadable" option. Don't
1161 use it for anything security sensitive.
1162 ********************************************************************/
1164 static bool user_can_read_file(connection_struct
*conn
,
1165 struct smb_filename
*smb_fname
)
1168 * Never hide files from the root user.
1169 * We use (uid_t)0 here not sec_initial_uid()
1170 * as make test uses a single user context.
1173 if (get_current_uid(conn
) == (uid_t
)0) {
1177 return can_access_file_acl(conn
, smb_fname
, FILE_READ_DATA
);
1180 /*******************************************************************
1181 Check to see if a user can write a file (and only files, we do not
1182 check dirs on this one). This is only approximate,
1183 it is used as part of the "hide unwriteable" option. Don't
1184 use it for anything security sensitive.
1185 ********************************************************************/
1187 static bool user_can_write_file(connection_struct
*conn
,
1188 const struct smb_filename
*smb_fname
)
1191 * Never hide files from the root user.
1192 * We use (uid_t)0 here not sec_initial_uid()
1193 * as make test uses a single user context.
1196 if (get_current_uid(conn
) == (uid_t
)0) {
1200 SMB_ASSERT(VALID_STAT(smb_fname
->st
));
1202 /* Pseudo-open the file */
1204 if(S_ISDIR(smb_fname
->st
.st_ex_mode
)) {
1208 return can_write_to_file(conn
, smb_fname
);
1211 /*******************************************************************
1212 Is a file a "special" type ?
1213 ********************************************************************/
1215 static bool file_is_special(connection_struct
*conn
,
1216 const struct smb_filename
*smb_fname
)
1219 * Never hide files from the root user.
1220 * We use (uid_t)0 here not sec_initial_uid()
1221 * as make test uses a single user context.
1224 if (get_current_uid(conn
) == (uid_t
)0) {
1228 SMB_ASSERT(VALID_STAT(smb_fname
->st
));
1230 if (S_ISREG(smb_fname
->st
.st_ex_mode
) ||
1231 S_ISDIR(smb_fname
->st
.st_ex_mode
) ||
1232 S_ISLNK(smb_fname
->st
.st_ex_mode
))
1238 /*******************************************************************
1239 Should the file be seen by the client?
1240 NOTE: A successful return is no guarantee of the file's existence.
1241 ********************************************************************/
1243 bool is_visible_file(connection_struct
*conn
, const char *dir_path
,
1244 const char *name
, SMB_STRUCT_STAT
*pst
, bool use_veto
)
1246 bool hide_unreadable
= lp_hideunreadable(SNUM(conn
));
1247 bool hide_unwriteable
= lp_hideunwriteable_files(SNUM(conn
));
1248 bool hide_special
= lp_hide_special_files(SNUM(conn
));
1250 struct smb_filename
*smb_fname_base
= NULL
;
1254 if ((strcmp(".",name
) == 0) || (strcmp("..",name
) == 0)) {
1255 return True
; /* . and .. are always visible. */
1258 /* If it's a vetoed file, pretend it doesn't even exist */
1259 if (use_veto
&& IS_VETO_PATH(conn
, name
)) {
1260 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name
));
1264 if (hide_unreadable
|| hide_unwriteable
|| hide_special
) {
1265 entry
= talloc_asprintf(talloc_tos(), "%s/%s", dir_path
, name
);
1271 /* Create an smb_filename with stream_name == NULL. */
1272 status
= create_synthetic_smb_fname(talloc_tos(), entry
, NULL
,
1273 pst
, &smb_fname_base
);
1274 if (!NT_STATUS_IS_OK(status
)) {
1279 /* If the file name does not exist, there's no point checking
1280 * the configuration options. We succeed, on the basis that the
1281 * checks *might* have passed if the file was present.
1283 if (!VALID_STAT(*pst
)) {
1284 if (SMB_VFS_STAT(conn
, smb_fname_base
) != 0) {
1288 *pst
= smb_fname_base
->st
;
1292 /* Honour _hide unreadable_ option */
1293 if (hide_unreadable
&&
1294 !user_can_read_file(conn
, smb_fname_base
)) {
1295 DEBUG(10,("is_visible_file: file %s is unreadable.\n",
1300 /* Honour _hide unwriteable_ option */
1301 if (hide_unwriteable
&& !user_can_write_file(conn
,
1303 DEBUG(10,("is_visible_file: file %s is unwritable.\n",
1308 /* Honour _hide_special_ option */
1309 if (hide_special
&& file_is_special(conn
, smb_fname_base
)) {
1310 DEBUG(10,("is_visible_file: file %s is special.\n",
1319 TALLOC_FREE(smb_fname_base
);
1324 static int smb_Dir_destructor(struct smb_Dir
*dirp
)
1328 if (dirp
->conn
->sconn
) {
1329 files_struct
*fsp
= file_find_fd(dirp
->conn
->sconn
,
1332 /* The call below closes the underlying fd. */
1337 SMB_VFS_CLOSEDIR(dirp
->conn
,dirp
->dir
);
1339 if (dirp
->conn
->sconn
) {
1340 dirp
->conn
->sconn
->searches
.dirhandles_open
--;
1345 /*******************************************************************
1347 ********************************************************************/
1349 struct smb_Dir
*OpenDir(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
,
1354 struct smb_Dir
*dirp
= talloc_zero(mem_ctx
, struct smb_Dir
);
1355 struct smbd_server_connection
*sconn
= conn
->sconn
;
1362 dirp
->name_cache_size
= lp_directory_name_cache_size(SNUM(conn
));
1364 dirp
->dir_path
= talloc_strdup(dirp
, name
);
1365 if (!dirp
->dir_path
) {
1371 sconn
->searches
.dirhandles_open
++;
1373 talloc_set_destructor(dirp
, smb_Dir_destructor
);
1375 dirp
->dir
= SMB_VFS_OPENDIR(conn
, dirp
->dir_path
, mask
, attr
);
1377 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp
->dir_path
,
1389 /*******************************************************************
1390 Open a directory from an fsp.
1391 ********************************************************************/
1393 static struct smb_Dir
*OpenDir_fsp(TALLOC_CTX
*mem_ctx
, connection_struct
*conn
,
1398 struct smb_Dir
*dirp
= talloc_zero(mem_ctx
, struct smb_Dir
);
1399 struct smbd_server_connection
*sconn
= conn
->sconn
;
1406 dirp
->name_cache_size
= lp_directory_name_cache_size(SNUM(conn
));
1408 dirp
->dir_path
= talloc_strdup(dirp
, fsp
->fsp_name
->base_name
);
1409 if (!dirp
->dir_path
) {
1415 sconn
->searches
.dirhandles_open
++;
1417 talloc_set_destructor(dirp
, smb_Dir_destructor
);
1419 if (fsp
->is_directory
&& fsp
->fh
->fd
!= -1) {
1420 dirp
->dir
= SMB_VFS_FDOPENDIR(fsp
, mask
, attr
);
1421 if (dirp
->dir
== NULL
) {
1422 DEBUG(10,("OpenDir_fsp: SMB_VFS_FDOPENDIR on %s returned "
1426 if (errno
!= ENOSYS
) {
1432 if (dirp
->dir
== NULL
) {
1433 /* FDOPENDIR didn't work. Use OPENDIR instead. */
1434 dirp
->dir
= SMB_VFS_OPENDIR(conn
, dirp
->dir_path
, mask
, attr
);
1438 DEBUG(5,("OpenDir_fsp: Can't open %s. %s\n", dirp
->dir_path
,
1451 /*******************************************************************
1452 Read from a directory.
1453 Return directory entry, current offset, and optional stat information.
1454 Don't check for veto or invisible files.
1455 ********************************************************************/
1457 const char *ReadDirName(struct smb_Dir
*dirp
, long *poffset
,
1458 SMB_STRUCT_STAT
*sbuf
, char **ptalloced
)
1461 char *talloced
= NULL
;
1462 connection_struct
*conn
= dirp
->conn
;
1464 /* Cheat to allow . and .. to be the first entries returned. */
1465 if (((*poffset
== START_OF_DIRECTORY_OFFSET
) ||
1466 (*poffset
== DOT_DOT_DIRECTORY_OFFSET
)) && (dirp
->file_number
< 2))
1468 if (dirp
->file_number
== 0) {
1470 *poffset
= dirp
->offset
= START_OF_DIRECTORY_OFFSET
;
1473 *poffset
= dirp
->offset
= DOT_DOT_DIRECTORY_OFFSET
;
1475 dirp
->file_number
++;
1478 } else if (*poffset
== END_OF_DIRECTORY_OFFSET
) {
1479 *poffset
= dirp
->offset
= END_OF_DIRECTORY_OFFSET
;
1482 /* A real offset, seek to it. */
1483 SeekDir(dirp
, *poffset
);
1486 while ((n
= vfs_readdirname(conn
, dirp
->dir
, sbuf
, &talloced
))) {
1487 /* Ignore . and .. - we've already returned them. */
1489 if ((n
[1] == '\0') || (n
[1] == '.' && n
[2] == '\0')) {
1490 TALLOC_FREE(talloced
);
1494 *poffset
= dirp
->offset
= SMB_VFS_TELLDIR(conn
, dirp
->dir
);
1495 *ptalloced
= talloced
;
1496 dirp
->file_number
++;
1499 *poffset
= dirp
->offset
= END_OF_DIRECTORY_OFFSET
;
1504 /*******************************************************************
1505 Rewind to the start.
1506 ********************************************************************/
1508 void RewindDir(struct smb_Dir
*dirp
, long *poffset
)
1510 SMB_VFS_REWINDDIR(dirp
->conn
, dirp
->dir
);
1511 dirp
->file_number
= 0;
1512 dirp
->offset
= START_OF_DIRECTORY_OFFSET
;
1513 *poffset
= START_OF_DIRECTORY_OFFSET
;
1516 /*******************************************************************
1518 ********************************************************************/
1520 void SeekDir(struct smb_Dir
*dirp
, long offset
)
1522 if (offset
!= dirp
->offset
) {
1523 if (offset
== START_OF_DIRECTORY_OFFSET
) {
1524 RewindDir(dirp
, &offset
);
1526 * Ok we should really set the file number here
1527 * to 1 to enable ".." to be returned next. Trouble
1528 * is I'm worried about callers using SeekDir(dirp,0)
1529 * as equivalent to RewindDir(). So leave this alone
1532 } else if (offset
== DOT_DOT_DIRECTORY_OFFSET
) {
1533 RewindDir(dirp
, &offset
);
1535 * Set the file number to 2 - we want to get the first
1536 * real file entry (the one we return after "..")
1537 * on the next ReadDir.
1539 dirp
->file_number
= 2;
1540 } else if (offset
== END_OF_DIRECTORY_OFFSET
) {
1541 ; /* Don't seek in this case. */
1543 SMB_VFS_SEEKDIR(dirp
->conn
, dirp
->dir
, offset
);
1545 dirp
->offset
= offset
;
1549 /*******************************************************************
1550 Tell a dir position.
1551 ********************************************************************/
1553 long TellDir(struct smb_Dir
*dirp
)
1555 return(dirp
->offset
);
1558 /*******************************************************************
1559 Add an entry into the dcache.
1560 ********************************************************************/
1562 void DirCacheAdd(struct smb_Dir
*dirp
, const char *name
, long offset
)
1564 struct name_cache_entry
*e
;
1566 if (dirp
->name_cache_size
== 0) {
1570 if (dirp
->name_cache
== NULL
) {
1571 dirp
->name_cache
= talloc_zero_array(
1572 dirp
, struct name_cache_entry
, dirp
->name_cache_size
);
1574 if (dirp
->name_cache
== NULL
) {
1579 dirp
->name_cache_index
= (dirp
->name_cache_index
+1) %
1580 dirp
->name_cache_size
;
1581 e
= &dirp
->name_cache
[dirp
->name_cache_index
];
1582 TALLOC_FREE(e
->name
);
1583 e
->name
= talloc_strdup(dirp
, name
);
1587 /*******************************************************************
1588 Find an entry by name. Leave us at the offset after it.
1589 Don't check for veto or invisible files.
1590 ********************************************************************/
1592 bool SearchDir(struct smb_Dir
*dirp
, const char *name
, long *poffset
)
1595 const char *entry
= NULL
;
1596 char *talloced
= NULL
;
1597 connection_struct
*conn
= dirp
->conn
;
1599 /* Search back in the name cache. */
1600 if (dirp
->name_cache_size
&& dirp
->name_cache
) {
1601 for (i
= dirp
->name_cache_index
; i
>= 0; i
--) {
1602 struct name_cache_entry
*e
= &dirp
->name_cache
[i
];
1603 if (e
->name
&& (conn
->case_sensitive
? (strcmp(e
->name
, name
) == 0) : strequal(e
->name
, name
))) {
1604 *poffset
= e
->offset
;
1605 SeekDir(dirp
, e
->offset
);
1609 for (i
= dirp
->name_cache_size
- 1; i
> dirp
->name_cache_index
; i
--) {
1610 struct name_cache_entry
*e
= &dirp
->name_cache
[i
];
1611 if (e
->name
&& (conn
->case_sensitive
? (strcmp(e
->name
, name
) == 0) : strequal(e
->name
, name
))) {
1612 *poffset
= e
->offset
;
1613 SeekDir(dirp
, e
->offset
);
1619 /* Not found in the name cache. Rewind directory and start from scratch. */
1620 SMB_VFS_REWINDDIR(conn
, dirp
->dir
);
1621 dirp
->file_number
= 0;
1622 *poffset
= START_OF_DIRECTORY_OFFSET
;
1623 while ((entry
= ReadDirName(dirp
, poffset
, NULL
, &talloced
))) {
1624 if (conn
->case_sensitive
? (strcmp(entry
, name
) == 0) : strequal(entry
, name
)) {
1625 TALLOC_FREE(talloced
);
1628 TALLOC_FREE(talloced
);
1633 /*****************************************************************
1634 Is this directory empty ?
1635 *****************************************************************/
1637 NTSTATUS
smbd_can_delete_directory(struct connection_struct
*conn
,
1638 const char *dirname
)
1640 NTSTATUS status
= NT_STATUS_OK
;
1642 const char *dname
= NULL
;
1643 char *talloced
= NULL
;
1645 struct smb_Dir
*dir_hnd
= OpenDir(talloc_tos(), conn
,
1649 return map_nt_error_from_unix(errno
);
1652 while ((dname
= ReadDirName(dir_hnd
, &dirpos
, &st
, &talloced
))) {
1653 /* Quick check for "." and ".." */
1654 if (dname
[0] == '.') {
1655 if (!dname
[1] || (dname
[1] == '.' && !dname
[2])) {
1656 TALLOC_FREE(talloced
);
1661 if (!is_visible_file(conn
, dirname
, dname
, &st
, True
)) {
1662 TALLOC_FREE(talloced
);
1666 DEBUG(10,("can_delete_directory: got name %s - can't delete\n",
1668 status
= NT_STATUS_DIRECTORY_NOT_EMPTY
;
1671 TALLOC_FREE(talloced
);
1672 TALLOC_FREE(dir_hnd
);