2 Unix SMB/CIFS implementation.
3 Directory handling routines
4 Copyright (C) Andrew Tridgell 1992-1998
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 This module implements directory related functions for Samba.
27 extern struct current_user current_user
;
29 /* "Special" directory offsets. */
30 #define END_OF_DIRECTORY_OFFSET ((long)-1)
31 #define START_OF_DIRECTORY_OFFSET ((long)0)
32 #define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
34 /* Make directory handle internals available. */
36 #define NAME_CACHE_SIZE 100
38 struct name_cache_entry
{
44 connection_struct
*conn
;
48 struct name_cache_entry
*name_cache
;
49 unsigned int name_cache_index
;
50 unsigned int file_number
;
54 struct dptr_struct
*next
, *prev
;
57 struct connection_struct
*conn
;
58 struct smb_Dir
*dir_hnd
;
63 BOOL has_wild
; /* Set to true if the wcard entry has MS wildcard characters in it. */
64 BOOL did_stat
; /* Optimisation for non-wcard searches. */
67 static struct bitmap
*dptr_bmap
;
68 static struct dptr_struct
*dirptrs
;
69 static int dirhandles_open
= 0;
71 #define INVALID_DPTR_KEY (-3)
73 /****************************************************************************
75 ****************************************************************************/
77 void make_dir_struct(char *buf
, const char *mask
, const char *fname
,SMB_OFF_T size
,uint32 mode
,time_t date
, BOOL uc
)
84 if ((mode
& aDIR
) != 0)
88 if ((p
= strchr_m(mask2
,'.')) != NULL
) {
90 push_ascii(buf
+1,mask2
,8, 0);
91 push_ascii(buf
+9,p
+1,3, 0);
94 push_ascii(buf
+1,mask2
,11, 0);
96 memset(buf
+21,'\0',DIR_STRUCT_SIZE
-21);
98 srv_put_dos_date(buf
,22,date
);
99 SSVAL(buf
,26,size
& 0xFFFF);
100 SSVAL(buf
,28,(size
>> 16)&0xFFFF);
101 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
102 Strange, but verified on W2K3. Needed for OS/2. JRA. */
103 push_ascii(buf
+30,fname
,12, uc
? STR_UPPER
: 0);
104 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf
+30, fname
));
107 /****************************************************************************
108 Initialise the dir bitmap.
109 ****************************************************************************/
111 void init_dptrs(void)
113 static BOOL dptrs_init
=False
;
118 dptr_bmap
= bitmap_allocate(MAX_DIRECTORY_HANDLES
);
121 exit_server("out of memory in init_dptrs");
126 /****************************************************************************
127 Idle a dptr - the directory is closed but the control info is kept.
128 ****************************************************************************/
130 static void dptr_idle(struct dptr_struct
*dptr
)
133 DEBUG(4,("Idling dptr dnum %d\n",dptr
->dnum
));
134 CloseDir(dptr
->dir_hnd
);
135 dptr
->dir_hnd
= NULL
;
139 /****************************************************************************
140 Idle the oldest dptr.
141 ****************************************************************************/
143 static void dptr_idleoldest(void)
145 struct dptr_struct
*dptr
;
148 * Go to the end of the list.
150 for(dptr
= dirptrs
; dptr
&& dptr
->next
; dptr
= dptr
->next
)
154 DEBUG(0,("No dptrs available to idle ?\n"));
159 * Idle the oldest pointer.
162 for(; dptr
; dptr
= dptr
->prev
) {
170 /****************************************************************************
171 Get the struct dptr_struct for a dir index.
172 ****************************************************************************/
174 static struct dptr_struct
*dptr_get(int key
, BOOL forclose
)
176 struct dptr_struct
*dptr
;
178 for(dptr
= dirptrs
; dptr
; dptr
= dptr
->next
) {
179 if(dptr
->dnum
== key
) {
180 if (!forclose
&& !dptr
->dir_hnd
) {
181 if (dirhandles_open
>= MAX_OPEN_DIRECTORIES
)
183 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key
));
184 if (!(dptr
->dir_hnd
= OpenDir(dptr
->conn
, dptr
->path
, dptr
->wcard
, dptr
->attr
))) {
185 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr
->path
,
190 DLIST_PROMOTE(dirptrs
,dptr
);
197 /****************************************************************************
198 Get the dir path for a dir index.
199 ****************************************************************************/
201 char *dptr_path(int key
)
203 struct dptr_struct
*dptr
= dptr_get(key
, False
);
209 /****************************************************************************
210 Get the dir wcard for a dir index.
211 ****************************************************************************/
213 char *dptr_wcard(int key
)
215 struct dptr_struct
*dptr
= dptr_get(key
, False
);
221 /****************************************************************************
222 Get the dir attrib for a dir index.
223 ****************************************************************************/
225 uint16
dptr_attr(int key
)
227 struct dptr_struct
*dptr
= dptr_get(key
, False
);
233 /****************************************************************************
234 Close a dptr (internal func).
235 ****************************************************************************/
237 static void dptr_close_internal(struct dptr_struct
*dptr
)
239 DEBUG(4,("closing dptr key %d\n",dptr
->dnum
));
241 DLIST_REMOVE(dirptrs
, dptr
);
244 * Free the dnum in the bitmap. Remember the dnum value is always
245 * biased by one with respect to the bitmap.
248 if(bitmap_query( dptr_bmap
, dptr
->dnum
- 1) != True
) {
249 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
253 bitmap_clear(dptr_bmap
, dptr
->dnum
- 1);
256 CloseDir(dptr
->dir_hnd
);
259 /* Lanman 2 specific code */
260 SAFE_FREE(dptr
->wcard
);
261 string_set(&dptr
->path
,"");
265 /****************************************************************************
266 Close a dptr given a key.
267 ****************************************************************************/
269 void dptr_close(int *key
)
271 struct dptr_struct
*dptr
;
273 if(*key
== INVALID_DPTR_KEY
)
276 /* OS/2 seems to use -1 to indicate "close all directories" */
278 struct dptr_struct
*next
;
279 for(dptr
= dirptrs
; dptr
; dptr
= next
) {
281 dptr_close_internal(dptr
);
283 *key
= INVALID_DPTR_KEY
;
287 dptr
= dptr_get(*key
, True
);
290 DEBUG(0,("Invalid key %d given to dptr_close\n", *key
));
294 dptr_close_internal(dptr
);
296 *key
= INVALID_DPTR_KEY
;
299 /****************************************************************************
300 Close all dptrs for a cnum.
301 ****************************************************************************/
303 void dptr_closecnum(connection_struct
*conn
)
305 struct dptr_struct
*dptr
, *next
;
306 for(dptr
= dirptrs
; dptr
; dptr
= next
) {
308 if (dptr
->conn
== conn
)
309 dptr_close_internal(dptr
);
313 /****************************************************************************
314 Idle all dptrs for a cnum.
315 ****************************************************************************/
317 void dptr_idlecnum(connection_struct
*conn
)
319 struct dptr_struct
*dptr
;
320 for(dptr
= dirptrs
; dptr
; dptr
= dptr
->next
) {
321 if (dptr
->conn
== conn
&& dptr
->dir_hnd
)
326 /****************************************************************************
327 Close a dptr that matches a given path, only if it matches the spid also.
328 ****************************************************************************/
330 void dptr_closepath(char *path
,uint16 spid
)
332 struct dptr_struct
*dptr
, *next
;
333 for(dptr
= dirptrs
; dptr
; dptr
= next
) {
335 if (spid
== dptr
->spid
&& strequal(dptr
->path
,path
))
336 dptr_close_internal(dptr
);
340 /****************************************************************************
341 Try and close the oldest handle not marked for
342 expect close in the hope that the client has
343 finished with that one.
344 ****************************************************************************/
346 static void dptr_close_oldest(BOOL old
)
348 struct dptr_struct
*dptr
;
351 * Go to the end of the list.
353 for(dptr
= dirptrs
; dptr
&& dptr
->next
; dptr
= dptr
->next
)
357 DEBUG(0,("No old dptrs available to close oldest ?\n"));
362 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
363 * does not have expect_close set. If 'old' is false, close
364 * one of the new dnum handles.
367 for(; dptr
; dptr
= dptr
->prev
) {
368 if ((old
&& (dptr
->dnum
< 256) && !dptr
->expect_close
) ||
369 (!old
&& (dptr
->dnum
> 255))) {
370 dptr_close_internal(dptr
);
376 /****************************************************************************
377 Create a new dir ptr. If the flag old_handle is true then we must allocate
378 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
379 one byte long. If old_handle is false we allocate from the range
380 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
381 a directory handle is never zero.
382 wcard must not be zero.
383 ****************************************************************************/
385 NTSTATUS
dptr_create(connection_struct
*conn
, pstring path
, BOOL old_handle
, BOOL expect_close
,uint16 spid
,
386 const char *wcard
, BOOL wcard_has_wild
, uint32 attr
, struct dptr_struct
**dptr_ret
)
388 struct dptr_struct
*dptr
= NULL
;
389 struct smb_Dir
*dir_hnd
;
393 DEBUG(5,("dptr_create dir=%s\n", path
));
396 return NT_STATUS_INVALID_PARAMETER
;
399 status
= check_name(conn
,path
);
400 if (!NT_STATUS_IS_OK(status
)) {
404 /* use a const pointer from here on */
409 dir_hnd
= OpenDir(conn
, dir2
, wcard
, attr
);
411 return map_nt_error_from_unix(errno
);
414 string_set(&conn
->dirpath
,dir2
);
416 if (dirhandles_open
>= MAX_OPEN_DIRECTORIES
) {
420 dptr
= SMB_MALLOC_P(struct dptr_struct
);
422 DEBUG(0,("malloc fail in dptr_create.\n"));
424 return NT_STATUS_NO_MEMORY
;
432 * This is an old-style SMBsearch request. Ensure the
433 * value we return will fit in the range 1-255.
436 dptr
->dnum
= bitmap_find(dptr_bmap
, 0);
438 if(dptr
->dnum
== -1 || dptr
->dnum
> 254) {
441 * Try and close the oldest handle not marked for
442 * expect close in the hope that the client has
443 * finished with that one.
446 dptr_close_oldest(True
);
448 /* Now try again... */
449 dptr
->dnum
= bitmap_find(dptr_bmap
, 0);
450 if(dptr
->dnum
== -1 || dptr
->dnum
> 254) {
451 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr
->dnum
));
454 return NT_STATUS_TOO_MANY_OPENED_FILES
;
460 * This is a new-style trans2 request. Allocate from
461 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
464 dptr
->dnum
= bitmap_find(dptr_bmap
, 255);
466 if(dptr
->dnum
== -1 || dptr
->dnum
< 255) {
469 * Try and close the oldest handle close in the hope that
470 * the client has finished with that one. This will only
471 * happen in the case of the Win98 client bug where it leaks
475 dptr_close_oldest(False
);
477 /* Now try again... */
478 dptr
->dnum
= bitmap_find(dptr_bmap
, 255);
480 if(dptr
->dnum
== -1 || dptr
->dnum
< 255) {
481 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr
->dnum
));
484 return NT_STATUS_TOO_MANY_OPENED_FILES
;
489 bitmap_set(dptr_bmap
, dptr
->dnum
);
491 dptr
->dnum
+= 1; /* Always bias the dnum by one - no zero dnums allowed. */
493 string_set(&dptr
->path
,dir2
);
495 dptr
->dir_hnd
= dir_hnd
;
497 dptr
->expect_close
= expect_close
;
498 dptr
->wcard
= SMB_STRDUP(wcard
);
500 bitmap_clear(dptr_bmap
, dptr
->dnum
- 1);
503 return NT_STATUS_NO_MEMORY
;
505 if (lp_posix_pathnames() || (wcard
[0] == '.' && wcard
[1] == 0)) {
506 dptr
->has_wild
= True
;
508 dptr
->has_wild
= wcard_has_wild
;
513 DLIST_ADD(dirptrs
, dptr
);
515 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
516 dptr
->dnum
,path
,expect_close
));
524 /****************************************************************************
525 Wrapper functions to access the lower level directory handles.
526 ****************************************************************************/
528 int dptr_CloseDir(struct dptr_struct
*dptr
)
530 DLIST_REMOVE(dirptrs
, dptr
);
531 return CloseDir(dptr
->dir_hnd
);
534 void dptr_SeekDir(struct dptr_struct
*dptr
, long offset
)
536 SeekDir(dptr
->dir_hnd
, offset
);
539 long dptr_TellDir(struct dptr_struct
*dptr
)
541 return TellDir(dptr
->dir_hnd
);
544 BOOL
dptr_has_wild(struct dptr_struct
*dptr
)
546 return dptr
->has_wild
;
549 int dptr_dnum(struct dptr_struct
*dptr
)
554 /****************************************************************************
555 Return the next visible file name, skipping veto'd and invisible files.
556 ****************************************************************************/
558 static const char *dptr_normal_ReadDirName(struct dptr_struct
*dptr
, long *poffset
, SMB_STRUCT_STAT
*pst
)
560 /* Normal search for the next file. */
562 while ((name
= ReadDirName(dptr
->dir_hnd
, poffset
)) != NULL
) {
563 if (is_visible_file(dptr
->conn
, dptr
->path
, name
, pst
, True
)) {
570 /****************************************************************************
571 Return the next visible file name, skipping veto'd and invisible files.
572 ****************************************************************************/
574 const char *dptr_ReadDirName(struct dptr_struct
*dptr
, long *poffset
, SMB_STRUCT_STAT
*pst
)
576 SET_STAT_INVALID(*pst
);
578 if (dptr
->has_wild
) {
579 return dptr_normal_ReadDirName(dptr
, poffset
, pst
);
582 /* If poffset is -1 then we know we returned this name before and we have
583 no wildcards. We're at the end of the directory. */
584 if (*poffset
== END_OF_DIRECTORY_OFFSET
) {
588 if (!dptr
->did_stat
) {
591 /* We know the stored wcard contains no wildcard characters. See if we can match
592 with a stat call. If we can't, then set did_stat to true to
593 ensure we only do this once and keep searching. */
595 dptr
->did_stat
= True
;
597 /* First check if it should be visible. */
598 if (!is_visible_file(dptr
->conn
, dptr
->path
, dptr
->wcard
, pst
, True
)) {
599 /* This only returns False if the file was found, but
600 is explicitly not visible. Set us to end of directory,
601 but return NULL as we know we can't ever find it. */
602 dptr
->dir_hnd
->offset
= *poffset
= END_OF_DIRECTORY_OFFSET
;
606 if (VALID_STAT(*pst
)) {
607 /* We need to set the underlying dir_hnd offset to -1 also as
608 this function is usually called with the output from TellDir. */
609 dptr
->dir_hnd
->offset
= *poffset
= END_OF_DIRECTORY_OFFSET
;
613 pstrcpy(pathreal
,dptr
->path
);
614 pstrcat(pathreal
,"/");
615 pstrcat(pathreal
,dptr
->wcard
);
617 if (SMB_VFS_STAT(dptr
->conn
,pathreal
,pst
) == 0) {
618 /* We need to set the underlying dir_hnd offset to -1 also as
619 this function is usually called with the output from TellDir. */
620 dptr
->dir_hnd
->offset
= *poffset
= END_OF_DIRECTORY_OFFSET
;
623 /* If we get any other error than ENOENT or ENOTDIR
624 then the file exists we just can't stat it. */
625 if (errno
!= ENOENT
&& errno
!= ENOTDIR
) {
626 /* We need to set the underlying dir_hdn offset to -1 also as
627 this function is usually called with the output from TellDir. */
628 dptr
->dir_hnd
->offset
= *poffset
= END_OF_DIRECTORY_OFFSET
;
633 /* In case sensitive mode we don't search - we know if it doesn't exist
634 with a stat we will fail. */
636 if (dptr
->conn
->case_sensitive
) {
637 /* We need to set the underlying dir_hnd offset to -1 also as
638 this function is usually called with the output from TellDir. */
639 dptr
->dir_hnd
->offset
= *poffset
= END_OF_DIRECTORY_OFFSET
;
643 return dptr_normal_ReadDirName(dptr
, poffset
, pst
);
646 /****************************************************************************
647 Search for a file by name, skipping veto'ed and not visible files.
648 ****************************************************************************/
650 BOOL
dptr_SearchDir(struct dptr_struct
*dptr
, const char *name
, long *poffset
, SMB_STRUCT_STAT
*pst
)
652 SET_STAT_INVALID(*pst
);
654 if (!dptr
->has_wild
&& (dptr
->dir_hnd
->offset
== END_OF_DIRECTORY_OFFSET
)) {
655 /* This is a singleton directory and we're already at the end. */
656 *poffset
= END_OF_DIRECTORY_OFFSET
;
660 return SearchDir(dptr
->dir_hnd
, name
, poffset
);
663 /****************************************************************************
664 Add the name we're returning into the underlying cache.
665 ****************************************************************************/
667 void dptr_DirCacheAdd(struct dptr_struct
*dptr
, const char *name
, long offset
)
669 DirCacheAdd(dptr
->dir_hnd
, name
, offset
);
672 /****************************************************************************
673 Fill the 5 byte server reserved dptr field.
674 ****************************************************************************/
676 BOOL
dptr_fill(char *buf1
,unsigned int key
)
678 unsigned char *buf
= (unsigned char *)buf1
;
679 struct dptr_struct
*dptr
= dptr_get(key
, False
);
682 DEBUG(1,("filling null dirptr %d\n",key
));
685 offset
= (uint32
)TellDir(dptr
->dir_hnd
);
686 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key
,
687 (long)dptr
->dir_hnd
,(int)offset
));
693 /****************************************************************************
694 Fetch the dir ptr and seek it given the 5 byte server field.
695 ****************************************************************************/
697 struct dptr_struct
*dptr_fetch(char *buf
,int *num
)
699 unsigned int key
= *(unsigned char *)buf
;
700 struct dptr_struct
*dptr
= dptr_get(key
, False
);
705 DEBUG(3,("fetched null dirptr %d\n",key
));
709 offset
= IVAL(buf
,1);
710 if (offset
== (uint32
)-1) {
711 seekoff
= END_OF_DIRECTORY_OFFSET
;
713 seekoff
= (long)offset
;
715 SeekDir(dptr
->dir_hnd
,seekoff
);
716 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
717 key
,dptr_path(key
),(int)seekoff
));
721 /****************************************************************************
723 ****************************************************************************/
725 struct dptr_struct
*dptr_fetch_lanman2(int dptr_num
)
727 struct dptr_struct
*dptr
= dptr_get(dptr_num
, False
);
730 DEBUG(3,("fetched null dirptr %d\n",dptr_num
));
733 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num
,dptr_path(dptr_num
)));
737 /****************************************************************************
738 Check that a file matches a particular file type.
739 ****************************************************************************/
741 BOOL
dir_check_ftype(connection_struct
*conn
, uint32 mode
, uint32 dirtype
)
745 /* Check the "may have" search bits. */
746 if (((mode
& ~dirtype
) & (aHIDDEN
| aSYSTEM
| aDIR
)) != 0)
749 /* Check the "must have" bits, which are the may have bits shifted eight */
750 /* If must have bit is set, the file/dir can not be returned in search unless the matching
751 file attribute is set */
752 mask
= ((dirtype
>> 8) & (aDIR
|aARCH
|aRONLY
|aHIDDEN
|aSYSTEM
)); /* & 0x37 */
754 if((mask
& (mode
& (aDIR
|aARCH
|aRONLY
|aHIDDEN
|aSYSTEM
))) == mask
) /* check if matching attribute present */
763 static BOOL
mangle_mask_match(connection_struct
*conn
, fstring filename
, char *mask
)
765 mangle_map(filename
,True
,False
,conn
->params
);
766 return mask_match_search(filename
,mask
,False
);
769 /****************************************************************************
770 Get an 8.3 directory entry.
771 ****************************************************************************/
773 BOOL
get_dir_entry(connection_struct
*conn
,char *mask
,uint32 dirtype
, pstring fname
,
774 SMB_OFF_T
*size
,uint32
*mode
,time_t *date
,BOOL check_descend
)
778 SMB_STRUCT_STAT sbuf
;
784 *path
= *pathreal
= *filename
= 0;
786 needslash
= ( conn
->dirpath
[strlen(conn
->dirpath
) -1] != '/');
792 long curoff
= dptr_TellDir(conn
->dirptr
);
793 dname
= dptr_ReadDirName(conn
->dirptr
, &curoff
, &sbuf
);
795 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
796 (long)conn
->dirptr
,TellDir(conn
->dirptr
->dir_hnd
)));
801 pstrcpy(filename
,dname
);
803 /* notice the special *.* handling. This appears to be the only difference
804 between the wildcard handling in this routine and in the trans2 routines.
805 see masktest for a demo
807 if ((strcmp(mask
,"*.*") == 0) ||
808 mask_match_search(filename
,mask
,False
) ||
809 mangle_mask_match(conn
,filename
,mask
)) {
811 if (!mangle_is_8_3(filename
, False
, conn
->params
))
812 mangle_map(filename
,True
,False
,
815 pstrcpy(fname
,filename
);
817 pstrcpy(path
,conn
->dirpath
);
820 pstrcpy(pathreal
,path
);
822 pstrcat(pathreal
,dname
);
823 if (!VALID_STAT(sbuf
) && (SMB_VFS_STAT(conn
, pathreal
, &sbuf
)) != 0) {
824 DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",path
, strerror(errno
) ));
828 *mode
= dos_mode(conn
,pathreal
,&sbuf
);
830 if (!dir_check_ftype(conn
,*mode
,dirtype
)) {
831 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename
,(unsigned int)*mode
,(unsigned int)dirtype
));
835 *size
= sbuf
.st_size
;
836 *date
= sbuf
.st_mtime
;
838 DEBUG(3,("get_dir_entry mask=[%s] found %s fname=%s\n",mask
, pathreal
,fname
));
842 DirCacheAdd(conn
->dirptr
->dir_hnd
, dname
, curoff
);
849 /*******************************************************************
850 Check to see if a user can read a file. This is only approximate,
851 it is used as part of the "hide unreadable" option. Don't
852 use it for anything security sensitive.
853 ********************************************************************/
855 static BOOL
user_can_read_file(connection_struct
*conn
, char *name
, SMB_STRUCT_STAT
*pst
)
857 SEC_DESC
*psd
= NULL
;
861 uint32 access_granted
;
864 * If user is a member of the Admin group
865 * we never hide files from them.
868 if (conn
->admin_user
) {
872 /* If we can't stat it does not show it */
873 if (!VALID_STAT(*pst
) && (SMB_VFS_STAT(conn
, name
, pst
) != 0)) {
874 DEBUG(10,("user_can_read_file: SMB_VFS_STAT failed for file %s with error %s\n",
875 name
, strerror(errno
) ));
879 /* Pseudo-open the file (note - no fd's created). */
881 if(S_ISDIR(pst
->st_mode
)) {
882 status
= open_directory(conn
, name
, pst
,
884 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
886 0, /* no create options. */
889 status
= open_file_stat(conn
, name
, pst
, &fsp
);
892 if (!NT_STATUS_IS_OK(status
)) {
896 /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
897 sd_size
= SMB_VFS_FGET_NT_ACL(fsp
, fsp
->fh
->fd
,
898 (OWNER_SECURITY_INFORMATION
|GROUP_SECURITY_INFORMATION
|DACL_SECURITY_INFORMATION
), &psd
);
899 close_file(fsp
, NORMAL_CLOSE
);
901 /* No access if SD get failed. */
906 return se_access_check(psd
, current_user
.nt_user_token
, FILE_READ_DATA
,
907 &access_granted
, &status
);
910 /*******************************************************************
911 Check to see if a user can write a file (and only files, we do not
912 check dirs on this one). This is only approximate,
913 it is used as part of the "hide unwriteable" option. Don't
914 use it for anything security sensitive.
915 ********************************************************************/
917 static BOOL
user_can_write_file(connection_struct
*conn
, char *name
, SMB_STRUCT_STAT
*pst
)
919 SEC_DESC
*psd
= NULL
;
924 uint32 access_granted
;
927 * If user is a member of the Admin group
928 * we never hide files from them.
931 if (conn
->admin_user
) {
935 /* If we can't stat it does not show it */
936 if (!VALID_STAT(*pst
) && (SMB_VFS_STAT(conn
, name
, pst
) != 0)) {
940 /* Pseudo-open the file */
942 if(S_ISDIR(pst
->st_mode
)) {
945 status
= open_file_ntcreate(conn
, name
, pst
,
946 FILE_WRITE_ATTRIBUTES
,
947 FILE_SHARE_READ
|FILE_SHARE_WRITE
,
950 FILE_ATTRIBUTE_NORMAL
,
955 if (!NT_STATUS_IS_OK(status
)) {
959 /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
960 sd_size
= SMB_VFS_FGET_NT_ACL(fsp
, fsp
->fh
->fd
,
961 (OWNER_SECURITY_INFORMATION
|GROUP_SECURITY_INFORMATION
|DACL_SECURITY_INFORMATION
), &psd
);
962 close_file(fsp
, NORMAL_CLOSE
);
964 /* No access if SD get failed. */
968 return se_access_check(psd
, current_user
.nt_user_token
, FILE_WRITE_DATA
,
969 &access_granted
, &status
);
972 /*******************************************************************
973 Is a file a "special" type ?
974 ********************************************************************/
976 static BOOL
file_is_special(connection_struct
*conn
, char *name
, SMB_STRUCT_STAT
*pst
)
979 * If user is a member of the Admin group
980 * we never hide files from them.
983 if (conn
->admin_user
)
986 /* If we can't stat it does not show it */
987 if (!VALID_STAT(*pst
) && (SMB_VFS_STAT(conn
, name
, pst
) != 0))
990 if (S_ISREG(pst
->st_mode
) || S_ISDIR(pst
->st_mode
) || S_ISLNK(pst
->st_mode
))
996 /*******************************************************************
997 Should the file be seen by the client ?
998 ********************************************************************/
1000 BOOL
is_visible_file(connection_struct
*conn
, const char *dir_path
, const char *name
, SMB_STRUCT_STAT
*pst
, BOOL use_veto
)
1002 BOOL hide_unreadable
= lp_hideunreadable(SNUM(conn
));
1003 BOOL hide_unwriteable
= lp_hideunwriteable_files(SNUM(conn
));
1004 BOOL hide_special
= lp_hide_special_files(SNUM(conn
));
1006 SET_STAT_INVALID(*pst
);
1008 if ((strcmp(".",name
) == 0) || (strcmp("..",name
) == 0)) {
1009 return True
; /* . and .. are always visible. */
1012 /* If it's a vetoed file, pretend it doesn't even exist */
1013 if (use_veto
&& IS_VETO_PATH(conn
, name
)) {
1014 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name
));
1018 if (hide_unreadable
|| hide_unwriteable
|| hide_special
) {
1021 if (asprintf(&entry
, "%s/%s", dir_path
, name
) == -1) {
1025 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1026 if (lp_host_msdfs() &&
1027 lp_msdfs_root(SNUM(conn
)) &&
1028 /* We get away with NULL talloc ctx here as
1029 we're not interested in the link contents
1030 so we have nothing to free. */
1031 is_msdfs_link(NULL
, conn
, entry
, NULL
, NULL
, NULL
)) {
1036 /* Honour _hide unreadable_ option */
1037 if (hide_unreadable
&& !user_can_read_file(conn
, entry
, pst
)) {
1038 DEBUG(10,("is_visible_file: file %s is unreadable.\n", entry
));
1042 /* Honour _hide unwriteable_ option */
1043 if (hide_unwriteable
&& !user_can_write_file(conn
, entry
, pst
)) {
1044 DEBUG(10,("is_visible_file: file %s is unwritable.\n", entry
));
1048 /* Honour _hide_special_ option */
1049 if (hide_special
&& file_is_special(conn
, entry
, pst
)) {
1050 DEBUG(10,("is_visible_file: file %s is special.\n", entry
));
1059 /*******************************************************************
1061 ********************************************************************/
1063 struct smb_Dir
*OpenDir(connection_struct
*conn
, const char *name
, const char *mask
, uint32 attr
)
1065 struct smb_Dir
*dirp
= SMB_MALLOC_P(struct smb_Dir
);
1073 dirp
->dir_path
= SMB_STRDUP(name
);
1074 if (!dirp
->dir_path
) {
1077 dirp
->dir
= SMB_VFS_OPENDIR(conn
, dirp
->dir_path
, mask
, attr
);
1079 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp
->dir_path
, strerror(errno
) ));
1083 dirp
->name_cache
= SMB_CALLOC_ARRAY(struct name_cache_entry
, NAME_CACHE_SIZE
);
1084 if (!dirp
->name_cache
) {
1095 SMB_VFS_CLOSEDIR(conn
,dirp
->dir
);
1097 SAFE_FREE(dirp
->dir_path
);
1098 SAFE_FREE(dirp
->name_cache
);
1105 /*******************************************************************
1107 ********************************************************************/
1109 int CloseDir(struct smb_Dir
*dirp
)
1114 ret
= SMB_VFS_CLOSEDIR(dirp
->conn
,dirp
->dir
);
1116 SAFE_FREE(dirp
->dir_path
);
1117 if (dirp
->name_cache
) {
1118 for (i
= 0; i
< NAME_CACHE_SIZE
; i
++) {
1119 SAFE_FREE(dirp
->name_cache
[i
].name
);
1122 SAFE_FREE(dirp
->name_cache
);
1128 /*******************************************************************
1129 Read from a directory. Also return current offset.
1130 Don't check for veto or invisible files.
1131 ********************************************************************/
1133 const char *ReadDirName(struct smb_Dir
*dirp
, long *poffset
)
1136 connection_struct
*conn
= dirp
->conn
;
1138 /* Cheat to allow . and .. to be the first entries returned. */
1139 if (((*poffset
== START_OF_DIRECTORY_OFFSET
) || (*poffset
== DOT_DOT_DIRECTORY_OFFSET
)) && (dirp
->file_number
< 2)) {
1140 if (dirp
->file_number
== 0) {
1142 *poffset
= dirp
->offset
= START_OF_DIRECTORY_OFFSET
;
1144 *poffset
= dirp
->offset
= DOT_DOT_DIRECTORY_OFFSET
;
1147 dirp
->file_number
++;
1149 } else if (*poffset
== END_OF_DIRECTORY_OFFSET
) {
1150 *poffset
= dirp
->offset
= END_OF_DIRECTORY_OFFSET
;
1153 /* A real offset, seek to it. */
1154 SeekDir(dirp
, *poffset
);
1157 while ((n
= vfs_readdirname(conn
, dirp
->dir
))) {
1158 /* Ignore . and .. - we've already returned them. */
1160 if ((n
[1] == '\0') || (n
[1] == '.' && n
[2] == '\0')) {
1164 *poffset
= dirp
->offset
= SMB_VFS_TELLDIR(conn
, dirp
->dir
);
1165 dirp
->file_number
++;
1168 *poffset
= dirp
->offset
= END_OF_DIRECTORY_OFFSET
;
1172 /*******************************************************************
1173 Rewind to the start.
1174 ********************************************************************/
1176 void RewindDir(struct smb_Dir
*dirp
, long *poffset
)
1178 SMB_VFS_REWINDDIR(dirp
->conn
, dirp
->dir
);
1179 dirp
->file_number
= 0;
1180 dirp
->offset
= START_OF_DIRECTORY_OFFSET
;
1181 *poffset
= START_OF_DIRECTORY_OFFSET
;
1184 /*******************************************************************
1186 ********************************************************************/
1188 void SeekDir(struct smb_Dir
*dirp
, long offset
)
1190 if (offset
!= dirp
->offset
) {
1191 if (offset
== START_OF_DIRECTORY_OFFSET
) {
1192 RewindDir(dirp
, &offset
);
1194 * Ok we should really set the file number here
1195 * to 1 to enable ".." to be returned next. Trouble
1196 * is I'm worried about callers using SeekDir(dirp,0)
1197 * as equivalent to RewindDir(). So leave this alone
1200 } else if (offset
== DOT_DOT_DIRECTORY_OFFSET
) {
1201 RewindDir(dirp
, &offset
);
1203 * Set the file number to 2 - we want to get the first
1204 * real file entry (the one we return after "..")
1205 * on the next ReadDir.
1207 dirp
->file_number
= 2;
1208 } else if (offset
== END_OF_DIRECTORY_OFFSET
) {
1209 ; /* Don't seek in this case. */
1211 SMB_VFS_SEEKDIR(dirp
->conn
, dirp
->dir
, offset
);
1213 dirp
->offset
= offset
;
1217 /*******************************************************************
1218 Tell a dir position.
1219 ********************************************************************/
1221 long TellDir(struct smb_Dir
*dirp
)
1223 return(dirp
->offset
);
1226 /*******************************************************************
1227 Add an entry into the dcache.
1228 ********************************************************************/
1230 void DirCacheAdd(struct smb_Dir
*dirp
, const char *name
, long offset
)
1232 struct name_cache_entry
*e
;
1234 dirp
->name_cache_index
= (dirp
->name_cache_index
+1) % NAME_CACHE_SIZE
;
1235 e
= &dirp
->name_cache
[dirp
->name_cache_index
];
1237 e
->name
= SMB_STRDUP(name
);
1241 /*******************************************************************
1242 Find an entry by name. Leave us at the offset after it.
1243 Don't check for veto or invisible files.
1244 ********************************************************************/
1246 BOOL
SearchDir(struct smb_Dir
*dirp
, const char *name
, long *poffset
)
1250 connection_struct
*conn
= dirp
->conn
;
1252 /* Search back in the name cache. */
1253 for (i
= dirp
->name_cache_index
; i
>= 0; i
--) {
1254 struct name_cache_entry
*e
= &dirp
->name_cache
[i
];
1255 if (e
->name
&& (conn
->case_sensitive
? (strcmp(e
->name
, name
) == 0) : strequal(e
->name
, name
))) {
1256 *poffset
= e
->offset
;
1257 SeekDir(dirp
, e
->offset
);
1261 for (i
= NAME_CACHE_SIZE
-1; i
> dirp
->name_cache_index
; i
--) {
1262 struct name_cache_entry
*e
= &dirp
->name_cache
[i
];
1263 if (e
->name
&& (conn
->case_sensitive
? (strcmp(e
->name
, name
) == 0) : strequal(e
->name
, name
))) {
1264 *poffset
= e
->offset
;
1265 SeekDir(dirp
, e
->offset
);
1270 /* Not found in the name cache. Rewind directory and start from scratch. */
1271 SMB_VFS_REWINDDIR(conn
, dirp
->dir
);
1272 dirp
->file_number
= 0;
1273 *poffset
= START_OF_DIRECTORY_OFFSET
;
1274 while ((entry
= ReadDirName(dirp
, poffset
))) {
1275 if (conn
->case_sensitive
? (strcmp(entry
, name
) == 0) : strequal(entry
, name
)) {