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/>.
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 struct name_cache_entry {
42 connection_struct *conn;
46 size_t name_cache_size;
47 struct name_cache_entry *name_cache;
48 unsigned int name_cache_index;
49 unsigned int file_number;
53 struct dptr_struct *next, *prev;
56 struct connection_struct *conn;
57 struct smb_Dir *dir_hnd;
62 BOOL has_wild; /* Set to true if the wcard entry has MS wildcard characters in it. */
63 BOOL did_stat; /* Optimisation for non-wcard searches. */
66 static struct bitmap *dptr_bmap;
67 static struct dptr_struct *dirptrs;
68 static int dirhandles_open = 0;
70 #define INVALID_DPTR_KEY (-3)
72 /****************************************************************************
74 ****************************************************************************/
76 BOOL make_dir_struct(TALLOC_CTX *ctx,
86 char *mask2 = talloc_strdup(ctx, mask);
92 if ((mode & aDIR) != 0) {
97 if ((p = strchr_m(mask2,'.')) != NULL) {
99 push_ascii(buf+1,mask2,8, 0);
100 push_ascii(buf+9,p+1,3, 0);
103 push_ascii(buf+1,mask2,11, 0);
106 memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
108 srv_put_dos_date(buf,22,date);
109 SSVAL(buf,26,size & 0xFFFF);
110 SSVAL(buf,28,(size >> 16)&0xFFFF);
111 /* We only uppercase if FLAGS2_LONG_PATH_COMPONENTS is zero in the input buf.
112 Strange, but verified on W2K3. Needed for OS/2. JRA. */
113 push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
114 DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
118 /****************************************************************************
119 Initialise the dir bitmap.
120 ****************************************************************************/
122 void init_dptrs(void)
124 static BOOL dptrs_init=False;
129 dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
132 exit_server("out of memory in init_dptrs");
137 /****************************************************************************
138 Idle a dptr - the directory is closed but the control info is kept.
139 ****************************************************************************/
141 static void dptr_idle(struct dptr_struct *dptr)
144 DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
145 CloseDir(dptr->dir_hnd);
146 dptr->dir_hnd = NULL;
150 /****************************************************************************
151 Idle the oldest dptr.
152 ****************************************************************************/
154 static void dptr_idleoldest(void)
156 struct dptr_struct *dptr;
159 * Go to the end of the list.
161 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
165 DEBUG(0,("No dptrs available to idle ?\n"));
170 * Idle the oldest pointer.
173 for(; dptr; dptr = dptr->prev) {
181 /****************************************************************************
182 Get the struct dptr_struct for a dir index.
183 ****************************************************************************/
185 static struct dptr_struct *dptr_get(int key, BOOL forclose)
187 struct dptr_struct *dptr;
189 for(dptr = dirptrs; dptr; dptr = dptr->next) {
190 if(dptr->dnum == key) {
191 if (!forclose && !dptr->dir_hnd) {
192 if (dirhandles_open >= MAX_OPEN_DIRECTORIES)
194 DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
195 if (!(dptr->dir_hnd = OpenDir(dptr->conn, dptr->path, dptr->wcard, dptr->attr))) {
196 DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
201 DLIST_PROMOTE(dirptrs,dptr);
208 /****************************************************************************
209 Get the dir path for a dir index.
210 ****************************************************************************/
212 char *dptr_path(int key)
214 struct dptr_struct *dptr = dptr_get(key, False);
220 /****************************************************************************
221 Get the dir wcard for a dir index.
222 ****************************************************************************/
224 char *dptr_wcard(int key)
226 struct dptr_struct *dptr = dptr_get(key, False);
232 /****************************************************************************
233 Get the dir attrib for a dir index.
234 ****************************************************************************/
236 uint16 dptr_attr(int key)
238 struct dptr_struct *dptr = dptr_get(key, False);
244 /****************************************************************************
245 Close a dptr (internal func).
246 ****************************************************************************/
248 static void dptr_close_internal(struct dptr_struct *dptr)
250 DEBUG(4,("closing dptr key %d\n",dptr->dnum));
252 DLIST_REMOVE(dirptrs, dptr);
255 * Free the dnum in the bitmap. Remember the dnum value is always
256 * biased by one with respect to the bitmap.
259 if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
260 DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
264 bitmap_clear(dptr_bmap, dptr->dnum - 1);
267 CloseDir(dptr->dir_hnd);
270 /* Lanman 2 specific code */
271 SAFE_FREE(dptr->wcard);
272 string_set(&dptr->path,"");
276 /****************************************************************************
277 Close a dptr given a key.
278 ****************************************************************************/
280 void dptr_close(int *key)
282 struct dptr_struct *dptr;
284 if(*key == INVALID_DPTR_KEY)
287 /* OS/2 seems to use -1 to indicate "close all directories" */
289 struct dptr_struct *next;
290 for(dptr = dirptrs; dptr; dptr = next) {
292 dptr_close_internal(dptr);
294 *key = INVALID_DPTR_KEY;
298 dptr = dptr_get(*key, True);
301 DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
305 dptr_close_internal(dptr);
307 *key = INVALID_DPTR_KEY;
310 /****************************************************************************
311 Close all dptrs for a cnum.
312 ****************************************************************************/
314 void dptr_closecnum(connection_struct *conn)
316 struct dptr_struct *dptr, *next;
317 for(dptr = dirptrs; dptr; dptr = next) {
319 if (dptr->conn == conn)
320 dptr_close_internal(dptr);
324 /****************************************************************************
325 Idle all dptrs for a cnum.
326 ****************************************************************************/
328 void dptr_idlecnum(connection_struct *conn)
330 struct dptr_struct *dptr;
331 for(dptr = dirptrs; dptr; dptr = dptr->next) {
332 if (dptr->conn == conn && dptr->dir_hnd)
337 /****************************************************************************
338 Close a dptr that matches a given path, only if it matches the spid also.
339 ****************************************************************************/
341 void dptr_closepath(char *path,uint16 spid)
343 struct dptr_struct *dptr, *next;
344 for(dptr = dirptrs; dptr; dptr = next) {
346 if (spid == dptr->spid && strequal(dptr->path,path))
347 dptr_close_internal(dptr);
351 /****************************************************************************
352 Try and close the oldest handle not marked for
353 expect close in the hope that the client has
354 finished with that one.
355 ****************************************************************************/
357 static void dptr_close_oldest(BOOL old)
359 struct dptr_struct *dptr;
362 * Go to the end of the list.
364 for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
368 DEBUG(0,("No old dptrs available to close oldest ?\n"));
373 * If 'old' is true, close the oldest oldhandle dnum (ie. 1 < dnum < 256) that
374 * does not have expect_close set. If 'old' is false, close
375 * one of the new dnum handles.
378 for(; dptr; dptr = dptr->prev) {
379 if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
380 (!old && (dptr->dnum > 255))) {
381 dptr_close_internal(dptr);
387 /****************************************************************************
388 Create a new dir ptr. If the flag old_handle is true then we must allocate
389 from the bitmap range 0 - 255 as old SMBsearch directory handles are only
390 one byte long. If old_handle is false we allocate from the range
391 256 - MAX_DIRECTORY_HANDLES. We bias the number we return by 1 to ensure
392 a directory handle is never zero.
393 wcard must not be zero.
394 ****************************************************************************/
396 NTSTATUS dptr_create(connection_struct *conn, const char *path, BOOL old_handle, BOOL expect_close,uint16 spid,
397 const char *wcard, BOOL wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
399 struct dptr_struct *dptr = NULL;
400 struct smb_Dir *dir_hnd;
403 DEBUG(5,("dptr_create dir=%s\n", path));
406 return NT_STATUS_INVALID_PARAMETER;
409 status = check_name(conn,path);
410 if (!NT_STATUS_IS_OK(status)) {
414 dir_hnd = OpenDir(conn, path, wcard, attr);
416 return map_nt_error_from_unix(errno);
419 string_set(&conn->dirpath,path);
421 if (dirhandles_open >= MAX_OPEN_DIRECTORIES) {
425 dptr = SMB_MALLOC_P(struct dptr_struct);
427 DEBUG(0,("malloc fail in dptr_create.\n"));
429 return NT_STATUS_NO_MEMORY;
437 * This is an old-style SMBsearch request. Ensure the
438 * value we return will fit in the range 1-255.
441 dptr->dnum = bitmap_find(dptr_bmap, 0);
443 if(dptr->dnum == -1 || dptr->dnum > 254) {
446 * Try and close the oldest handle not marked for
447 * expect close in the hope that the client has
448 * finished with that one.
451 dptr_close_oldest(True);
453 /* Now try again... */
454 dptr->dnum = bitmap_find(dptr_bmap, 0);
455 if(dptr->dnum == -1 || dptr->dnum > 254) {
456 DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
459 return NT_STATUS_TOO_MANY_OPENED_FILES;
465 * This is a new-style trans2 request. Allocate from
466 * a range that will return 256 - MAX_DIRECTORY_HANDLES.
469 dptr->dnum = bitmap_find(dptr_bmap, 255);
471 if(dptr->dnum == -1 || dptr->dnum < 255) {
474 * Try and close the oldest handle close in the hope that
475 * the client has finished with that one. This will only
476 * happen in the case of the Win98 client bug where it leaks
480 dptr_close_oldest(False);
482 /* Now try again... */
483 dptr->dnum = bitmap_find(dptr_bmap, 255);
485 if(dptr->dnum == -1 || dptr->dnum < 255) {
486 DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
489 return NT_STATUS_TOO_MANY_OPENED_FILES;
494 bitmap_set(dptr_bmap, dptr->dnum);
496 dptr->dnum += 1; /* Always bias the dnum by one - no zero dnums allowed. */
498 string_set(&dptr->path,path);
500 dptr->dir_hnd = dir_hnd;
502 dptr->expect_close = expect_close;
503 dptr->wcard = SMB_STRDUP(wcard);
505 bitmap_clear(dptr_bmap, dptr->dnum - 1);
508 return NT_STATUS_NO_MEMORY;
510 if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
511 dptr->has_wild = True;
513 dptr->has_wild = wcard_has_wild;
518 DLIST_ADD(dirptrs, dptr);
520 DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
521 dptr->dnum,path,expect_close));
529 /****************************************************************************
530 Wrapper functions to access the lower level directory handles.
531 ****************************************************************************/
533 int dptr_CloseDir(struct dptr_struct *dptr)
535 DLIST_REMOVE(dirptrs, dptr);
536 return CloseDir(dptr->dir_hnd);
539 void dptr_SeekDir(struct dptr_struct *dptr, long offset)
541 SeekDir(dptr->dir_hnd, offset);
544 long dptr_TellDir(struct dptr_struct *dptr)
546 return TellDir(dptr->dir_hnd);
549 BOOL dptr_has_wild(struct dptr_struct *dptr)
551 return dptr->has_wild;
554 int dptr_dnum(struct dptr_struct *dptr)
559 /****************************************************************************
560 Return the next visible file name, skipping veto'd and invisible files.
561 ****************************************************************************/
563 static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr, long *poffset, SMB_STRUCT_STAT *pst)
565 /* Normal search for the next file. */
567 while ((name = ReadDirName(dptr->dir_hnd, poffset)) != NULL) {
568 if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
575 /****************************************************************************
576 Return the next visible file name, skipping veto'd and invisible files.
577 ****************************************************************************/
579 const char *dptr_ReadDirName(TALLOC_CTX *ctx,
580 struct dptr_struct *dptr,
582 SMB_STRUCT_STAT *pst)
584 SET_STAT_INVALID(*pst);
586 if (dptr->has_wild) {
587 return dptr_normal_ReadDirName(dptr, poffset, pst);
590 /* If poffset is -1 then we know we returned this name before and we have
591 no wildcards. We're at the end of the directory. */
592 if (*poffset == END_OF_DIRECTORY_OFFSET) {
596 if (!dptr->did_stat) {
597 char *pathreal = NULL;
599 /* We know the stored wcard contains no wildcard characters. See if we can match
600 with a stat call. If we can't, then set did_stat to true to
601 ensure we only do this once and keep searching. */
603 dptr->did_stat = True;
605 /* First check if it should be visible. */
606 if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard, pst, True)) {
607 /* This only returns False if the file was found, but
608 is explicitly not visible. Set us to end of directory,
609 but return NULL as we know we can't ever find it. */
610 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
614 if (VALID_STAT(*pst)) {
615 /* We need to set the underlying dir_hnd offset to -1 also as
616 this function is usually called with the output from TellDir. */
617 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
621 pathreal = talloc_asprintf(ctx,
629 if (SMB_VFS_STAT(dptr->conn,pathreal,pst) == 0) {
630 /* We need to set the underlying dir_hnd offset to -1 also as
631 this function is usually called with the output from TellDir. */
632 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
633 TALLOC_FREE(pathreal);
636 /* If we get any other error than ENOENT or ENOTDIR
637 then the file exists we just can't stat it. */
638 if (errno != ENOENT && errno != ENOTDIR) {
639 /* We need to set the underlying dir_hdn offset to -1 also as
640 this function is usually called with the output from TellDir. */
641 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
642 TALLOC_FREE(pathreal);
647 TALLOC_FREE(pathreal);
649 /* In case sensitive mode we don't search - we know if it doesn't exist
650 with a stat we will fail. */
652 if (dptr->conn->case_sensitive) {
653 /* We need to set the underlying dir_hnd offset to -1 also as
654 this function is usually called with the output from TellDir. */
655 dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
659 return dptr_normal_ReadDirName(dptr, poffset, pst);
662 /****************************************************************************
663 Search for a file by name, skipping veto'ed and not visible files.
664 ****************************************************************************/
666 BOOL dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
668 SET_STAT_INVALID(*pst);
670 if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
671 /* This is a singleton directory and we're already at the end. */
672 *poffset = END_OF_DIRECTORY_OFFSET;
676 return SearchDir(dptr->dir_hnd, name, poffset);
679 /****************************************************************************
680 Add the name we're returning into the underlying cache.
681 ****************************************************************************/
683 void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
685 DirCacheAdd(dptr->dir_hnd, name, offset);
688 /****************************************************************************
689 Fill the 5 byte server reserved dptr field.
690 ****************************************************************************/
692 BOOL dptr_fill(char *buf1,unsigned int key)
694 unsigned char *buf = (unsigned char *)buf1;
695 struct dptr_struct *dptr = dptr_get(key, False);
698 DEBUG(1,("filling null dirptr %d\n",key));
701 offset = (uint32)TellDir(dptr->dir_hnd);
702 DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
703 (long)dptr->dir_hnd,(int)offset));
709 /****************************************************************************
710 Fetch the dir ptr and seek it given the 5 byte server field.
711 ****************************************************************************/
713 struct dptr_struct *dptr_fetch(char *buf,int *num)
715 unsigned int key = *(unsigned char *)buf;
716 struct dptr_struct *dptr = dptr_get(key, False);
721 DEBUG(3,("fetched null dirptr %d\n",key));
725 offset = IVAL(buf,1);
726 if (offset == (uint32)-1) {
727 seekoff = END_OF_DIRECTORY_OFFSET;
729 seekoff = (long)offset;
731 SeekDir(dptr->dir_hnd,seekoff);
732 DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
733 key,dptr_path(key),(int)seekoff));
737 /****************************************************************************
739 ****************************************************************************/
741 struct dptr_struct *dptr_fetch_lanman2(int dptr_num)
743 struct dptr_struct *dptr = dptr_get(dptr_num, False);
746 DEBUG(3,("fetched null dirptr %d\n",dptr_num));
749 DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
753 /****************************************************************************
754 Check that a file matches a particular file type.
755 ****************************************************************************/
757 BOOL dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
761 /* Check the "may have" search bits. */
762 if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
765 /* Check the "must have" bits, which are the may have bits shifted eight */
766 /* If must have bit is set, the file/dir can not be returned in search unless the matching
767 file attribute is set */
768 mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM)); /* & 0x37 */
770 if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask) /* check if matching attribute present */
779 static BOOL mangle_mask_match(connection_struct *conn,
780 const char *filename,
785 if (!name_to_8_3(filename,mname,False,conn->params)) {
788 return mask_match_search(mname,mask,False);
791 /****************************************************************************
792 Get an 8.3 directory entry.
793 ****************************************************************************/
795 BOOL get_dir_entry(TALLOC_CTX *ctx,
796 connection_struct *conn,
805 const char *dname = NULL;
807 SMB_STRUCT_STAT sbuf;
808 char *pathreal = NULL;
809 const char *filename = NULL;
812 *pp_fname_out = NULL;
814 needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
821 long curoff = dptr_TellDir(conn->dirptr);
822 dname = dptr_ReadDirName(ctx, conn->dirptr, &curoff, &sbuf);
824 DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
825 (long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
833 /* notice the special *.* handling. This appears to be the only difference
834 between the wildcard handling in this routine and in the trans2 routines.
835 see masktest for a demo
837 if ((strcmp(mask,"*.*") == 0) ||
838 mask_match_search(filename,mask,False) ||
839 mangle_mask_match(conn,filename,mask)) {
842 if (!mangle_is_8_3(filename, False, conn->params)) {
843 if (!name_to_8_3(filename,mname,False,
851 pathreal = talloc_asprintf(ctx,
856 pathreal = talloc_asprintf(ctx,
865 if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn, pathreal, &sbuf)) != 0) {
866 DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",
867 pathreal, strerror(errno) ));
868 TALLOC_FREE(pathreal);
872 *mode = dos_mode(conn,pathreal,&sbuf);
874 if (!dir_check_ftype(conn,*mode,dirtype)) {
875 DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
876 TALLOC_FREE(pathreal);
880 *size = sbuf.st_size;
881 *date = sbuf.st_mtime;
883 DEBUG(3,("get_dir_entry mask=[%s] found %s "
892 *pp_fname_out = talloc_strdup(ctx, filename);
893 if (!*pp_fname_out) {
897 DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
898 TALLOC_FREE(pathreal);
905 /*******************************************************************
906 Check to see if a user can read a file. This is only approximate,
907 it is used as part of the "hide unreadable" option. Don't
908 use it for anything security sensitive.
909 ********************************************************************/
911 static BOOL user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
913 SEC_DESC *psd = NULL;
917 uint32 access_granted;
920 * If user is a member of the Admin group
921 * we never hide files from them.
924 if (conn->admin_user) {
928 /* If we can't stat it does not show it */
929 if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0)) {
930 DEBUG(10,("user_can_read_file: SMB_VFS_STAT failed for file %s with error %s\n",
931 name, strerror(errno) ));
935 /* Pseudo-open the file (note - no fd's created). */
937 if(S_ISDIR(pst->st_mode)) {
938 status = open_directory(conn, NULL, name, pst,
940 FILE_SHARE_READ|FILE_SHARE_WRITE,
942 0, /* no create options. */
943 FILE_ATTRIBUTE_DIRECTORY,
946 status = open_file_stat(conn, NULL, name, pst, &fsp);
949 if (!NT_STATUS_IS_OK(status)) {
953 /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
954 sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fh->fd,
955 (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
956 close_file(fsp, NORMAL_CLOSE);
958 /* No access if SD get failed. */
963 return se_access_check(psd, current_user.nt_user_token, FILE_READ_DATA,
964 &access_granted, &status);
967 /*******************************************************************
968 Check to see if a user can write a file (and only files, we do not
969 check dirs on this one). This is only approximate,
970 it is used as part of the "hide unwriteable" option. Don't
971 use it for anything security sensitive.
972 ********************************************************************/
974 static BOOL user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
976 SEC_DESC *psd = NULL;
981 uint32 access_granted;
984 * If user is a member of the Admin group
985 * we never hide files from them.
988 if (conn->admin_user) {
992 /* If we can't stat it does not show it */
993 if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0)) {
997 /* Pseudo-open the file */
999 if(S_ISDIR(pst->st_mode)) {
1002 status = open_file_ntcreate(conn, NULL, name, pst,
1003 FILE_WRITE_ATTRIBUTES,
1004 FILE_SHARE_READ|FILE_SHARE_WRITE,
1007 FILE_ATTRIBUTE_NORMAL,
1012 if (!NT_STATUS_IS_OK(status)) {
1016 /* Get NT ACL -allocated in main loop talloc context. No free needed here. */
1017 sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fh->fd,
1018 (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
1019 close_file(fsp, NORMAL_CLOSE);
1021 /* No access if SD get failed. */
1025 return se_access_check(psd, current_user.nt_user_token, FILE_WRITE_DATA,
1026 &access_granted, &status);
1029 /*******************************************************************
1030 Is a file a "special" type ?
1031 ********************************************************************/
1033 static BOOL file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
1036 * If user is a member of the Admin group
1037 * we never hide files from them.
1040 if (conn->admin_user)
1043 /* If we can't stat it does not show it */
1044 if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0))
1047 if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
1053 /*******************************************************************
1054 Should the file be seen by the client ?
1055 ********************************************************************/
1057 BOOL is_visible_file(connection_struct *conn, const char *dir_path, const char *name, SMB_STRUCT_STAT *pst, BOOL use_veto)
1059 BOOL hide_unreadable = lp_hideunreadable(SNUM(conn));
1060 BOOL hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
1061 BOOL hide_special = lp_hide_special_files(SNUM(conn));
1063 SET_STAT_INVALID(*pst);
1065 if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
1066 return True; /* . and .. are always visible. */
1069 /* If it's a vetoed file, pretend it doesn't even exist */
1070 if (use_veto && IS_VETO_PATH(conn, name)) {
1071 DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
1075 if (hide_unreadable || hide_unwriteable || hide_special) {
1078 if (asprintf(&entry, "%s/%s", dir_path, name) == -1) {
1082 /* If it's a dfs symlink, ignore _hide xxxx_ options */
1083 if (lp_host_msdfs() &&
1084 lp_msdfs_root(SNUM(conn)) &&
1085 is_msdfs_link(conn, entry, NULL)) {
1090 /* Honour _hide unreadable_ option */
1091 if (hide_unreadable && !user_can_read_file(conn, entry, pst)) {
1092 DEBUG(10,("is_visible_file: file %s is unreadable.\n", entry ));
1096 /* Honour _hide unwriteable_ option */
1097 if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
1098 DEBUG(10,("is_visible_file: file %s is unwritable.\n", entry ));
1102 /* Honour _hide_special_ option */
1103 if (hide_special && file_is_special(conn, entry, pst)) {
1104 DEBUG(10,("is_visible_file: file %s is special.\n", entry ));
1113 /*******************************************************************
1115 ********************************************************************/
1117 struct smb_Dir *OpenDir(connection_struct *conn, const char *name, const char *mask, uint32 attr)
1119 struct smb_Dir *dirp = SMB_MALLOC_P(struct smb_Dir);
1127 dirp->name_cache_size = lp_directory_name_cache_size(SNUM(conn));
1129 dirp->dir_path = SMB_STRDUP(name);
1130 if (!dirp->dir_path) {
1133 dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
1135 DEBUG(5,("OpenDir: Can't open %s. %s\n", dirp->dir_path, strerror(errno) ));
1139 if (dirp->name_cache_size) {
1140 dirp->name_cache = SMB_CALLOC_ARRAY(struct name_cache_entry,
1141 dirp->name_cache_size);
1142 if (!dirp->name_cache) {
1146 dirp->name_cache = NULL;
1156 SMB_VFS_CLOSEDIR(conn,dirp->dir);
1158 SAFE_FREE(dirp->dir_path);
1159 SAFE_FREE(dirp->name_cache);
1166 /*******************************************************************
1168 ********************************************************************/
1170 int CloseDir(struct smb_Dir *dirp)
1175 ret = SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
1177 SAFE_FREE(dirp->dir_path);
1178 if (dirp->name_cache) {
1179 for (i = 0; i < dirp->name_cache_size; i++) {
1180 SAFE_FREE(dirp->name_cache[i].name);
1183 SAFE_FREE(dirp->name_cache);
1189 /*******************************************************************
1190 Read from a directory. Also return current offset.
1191 Don't check for veto or invisible files.
1192 ********************************************************************/
1194 const char *ReadDirName(struct smb_Dir *dirp, long *poffset)
1197 connection_struct *conn = dirp->conn;
1199 /* Cheat to allow . and .. to be the first entries returned. */
1200 if (((*poffset == START_OF_DIRECTORY_OFFSET) || (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2)) {
1201 if (dirp->file_number == 0) {
1203 *poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
1205 *poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
1208 dirp->file_number++;
1210 } else if (*poffset == END_OF_DIRECTORY_OFFSET) {
1211 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1214 /* A real offset, seek to it. */
1215 SeekDir(dirp, *poffset);
1218 while ((n = vfs_readdirname(conn, dirp->dir))) {
1219 /* Ignore . and .. - we've already returned them. */
1221 if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
1225 *poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
1226 dirp->file_number++;
1229 *poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
1233 /*******************************************************************
1234 Rewind to the start.
1235 ********************************************************************/
1237 void RewindDir(struct smb_Dir *dirp, long *poffset)
1239 SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
1240 dirp->file_number = 0;
1241 dirp->offset = START_OF_DIRECTORY_OFFSET;
1242 *poffset = START_OF_DIRECTORY_OFFSET;
1245 /*******************************************************************
1247 ********************************************************************/
1249 void SeekDir(struct smb_Dir *dirp, long offset)
1251 if (offset != dirp->offset) {
1252 if (offset == START_OF_DIRECTORY_OFFSET) {
1253 RewindDir(dirp, &offset);
1255 * Ok we should really set the file number here
1256 * to 1 to enable ".." to be returned next. Trouble
1257 * is I'm worried about callers using SeekDir(dirp,0)
1258 * as equivalent to RewindDir(). So leave this alone
1261 } else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
1262 RewindDir(dirp, &offset);
1264 * Set the file number to 2 - we want to get the first
1265 * real file entry (the one we return after "..")
1266 * on the next ReadDir.
1268 dirp->file_number = 2;
1269 } else if (offset == END_OF_DIRECTORY_OFFSET) {
1270 ; /* Don't seek in this case. */
1272 SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
1274 dirp->offset = offset;
1278 /*******************************************************************
1279 Tell a dir position.
1280 ********************************************************************/
1282 long TellDir(struct smb_Dir *dirp)
1284 return(dirp->offset);
1287 /*******************************************************************
1288 Add an entry into the dcache.
1289 ********************************************************************/
1291 void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
1293 struct name_cache_entry *e;
1295 if (!dirp->name_cache_size || !dirp->name_cache) {
1299 dirp->name_cache_index = (dirp->name_cache_index+1) %
1300 dirp->name_cache_size;
1301 e = &dirp->name_cache[dirp->name_cache_index];
1303 e->name = SMB_STRDUP(name);
1307 /*******************************************************************
1308 Find an entry by name. Leave us at the offset after it.
1309 Don't check for veto or invisible files.
1310 ********************************************************************/
1312 BOOL SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
1316 connection_struct *conn = dirp->conn;
1318 /* Search back in the name cache. */
1319 if (dirp->name_cache_size && dirp->name_cache) {
1320 for (i = dirp->name_cache_index; i >= 0; i--) {
1321 struct name_cache_entry *e = &dirp->name_cache[i];
1322 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1323 *poffset = e->offset;
1324 SeekDir(dirp, e->offset);
1328 for (i = dirp->name_cache_size - 1; i > dirp->name_cache_index; i--) {
1329 struct name_cache_entry *e = &dirp->name_cache[i];
1330 if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
1331 *poffset = e->offset;
1332 SeekDir(dirp, e->offset);
1338 /* Not found in the name cache. Rewind directory and start from scratch. */
1339 SMB_VFS_REWINDDIR(conn, dirp->dir);
1340 dirp->file_number = 0;
1341 *poffset = START_OF_DIRECTORY_OFFSET;
1342 while ((entry = ReadDirName(dirp, poffset))) {
1343 if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
1350 /*****************************************************************
1351 Is this directory empty ?
1352 *****************************************************************/
1354 NTSTATUS can_delete_directory(struct connection_struct *conn,
1355 const char *dirname)
1357 NTSTATUS status = NT_STATUS_OK;
1360 struct smb_Dir *dir_hnd = OpenDir(conn, dirname, NULL, 0);
1363 return map_nt_error_from_unix(errno);
1366 while ((dname = ReadDirName(dir_hnd,&dirpos))) {
1369 /* Quick check for "." and ".." */
1370 if (dname[0] == '.') {
1371 if (!dname[1] || (dname[1] == '.' && !dname[2])) {
1376 if (!is_visible_file(conn, dirname, dname, &st, True)) {
1380 DEBUG(10,("can_delete_directory: got name %s - can't delete\n", dname ));
1381 status = NT_STATUS_DIRECTORY_NOT_EMPTY;