#include "includes.h"
extern struct current_user current_user;
#define END_OF_DIRECTORY_OFFSET ((long)-1)
#define START_OF_DIRECTORY_OFFSET ((long)0)
#define DOT_DOT_DIRECTORY_OFFSET ((long)0x80000000)
#define NAME_CACHE_SIZE 100
struct name_cache_entry {
char *name;
long offset;
};
struct smb_Dir {
connection_struct *conn;
SMB_STRUCT_DIR *dir;
long offset;
char *dir_path;
struct name_cache_entry *name_cache;
unsigned int name_cache_index;
unsigned int file_number;
};
struct dptr_struct {
struct dptr_struct *next, *prev;
int dnum;
uint16 spid;
struct connection_struct *conn;
struct smb_Dir *dir_hnd;
BOOL expect_close;
char *wcard;
uint32 attr;
char *path;
BOOL has_wild;
BOOL did_stat;
};
static struct bitmap *dptr_bmap;
static struct dptr_struct *dirptrs;
static int dirhandles_open = 0;
#define INVALID_DPTR_KEY (-3)
void make_dir_struct(char *buf, const char *mask, const char *fname,SMB_OFF_T size,uint32 mode,time_t date, BOOL uc)
{
char *p;
pstring mask2;
pstrcpy(mask2,mask);
if ((mode & aDIR) != 0)
size = 0;
memset(buf+1,' ',11);
if ((p = strchr_m(mask2,'.')) != NULL) {
*p = 0;
push_ascii(buf+1,mask2,8, 0);
push_ascii(buf+9,p+1,3, 0);
*p = '.';
} else
push_ascii(buf+1,mask2,11, 0);
memset(buf+21,'\0',DIR_STRUCT_SIZE-21);
SCVAL(buf,21,mode);
srv_put_dos_date(buf,22,date);
SSVAL(buf,26,size & 0xFFFF);
SSVAL(buf,28,(size >> 16)&0xFFFF);
push_ascii(buf+30,fname,12, uc ? STR_UPPER : 0);
DEBUG(8,("put name [%s] from [%s] into dir struct\n",buf+30, fname));
}
void init_dptrs(void)
{
static BOOL dptrs_init=False;
if (dptrs_init)
return;
dptr_bmap = bitmap_allocate(MAX_DIRECTORY_HANDLES);
if (!dptr_bmap)
exit_server("out of memory in init_dptrs");
dptrs_init = True;
}
static void dptr_idle(struct dptr_struct *dptr)
{
if (dptr->dir_hnd) {
DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
CloseDir(dptr->dir_hnd);
dptr->dir_hnd = NULL;
}
}
static void dptr_idleoldest(void)
{
struct dptr_struct *dptr;
for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
;
if(!dptr) {
DEBUG(0,("No dptrs available to idle ?\n"));
return;
}
for(; dptr; dptr = dptr->prev) {
dptr_idle(dptr);
return;
}
}
static struct dptr_struct *dptr_get(int key, BOOL forclose)
{
struct dptr_struct *dptr;
for(dptr = dirptrs; dptr; dptr = dptr->next) {
if(dptr->dnum == key) {
if (!forclose && !dptr->dir_hnd) {
if (dirhandles_open >= MAX_OPEN_DIRECTORIES)
dptr_idleoldest();
DEBUG(4,("dptr_get: Reopening dptr key %d\n",key));
if (!(dptr->dir_hnd = OpenDir(dptr->conn, dptr->path, dptr->wcard, dptr->attr))) {
DEBUG(4,("dptr_get: Failed to open %s (%s)\n",dptr->path,
strerror(errno)));
return False;
}
}
DLIST_PROMOTE(dirptrs,dptr);
return dptr;
}
}
return(NULL);
}
char *dptr_path(int key)
{
struct dptr_struct *dptr = dptr_get(key, False);
if (dptr)
return(dptr->path);
return(NULL);
}
char *dptr_wcard(int key)
{
struct dptr_struct *dptr = dptr_get(key, False);
if (dptr)
return(dptr->wcard);
return(NULL);
}
uint16 dptr_attr(int key)
{
struct dptr_struct *dptr = dptr_get(key, False);
if (dptr)
return(dptr->attr);
return(0);
}
static void dptr_close_internal(struct dptr_struct *dptr)
{
DEBUG(4,("closing dptr key %d\n",dptr->dnum));
DLIST_REMOVE(dirptrs, dptr);
if(bitmap_query( dptr_bmap, dptr->dnum - 1) != True) {
DEBUG(0,("dptr_close_internal : Error - closing dnum = %d and bitmap not set !\n",
dptr->dnum ));
}
bitmap_clear(dptr_bmap, dptr->dnum - 1);
if (dptr->dir_hnd) {
CloseDir(dptr->dir_hnd);
}
SAFE_FREE(dptr->wcard);
string_set(&dptr->path,"");
SAFE_FREE(dptr);
}
void dptr_close(int *key)
{
struct dptr_struct *dptr;
if(*key == INVALID_DPTR_KEY)
return;
if (*key == -1) {
struct dptr_struct *next;
for(dptr = dirptrs; dptr; dptr = next) {
next = dptr->next;
dptr_close_internal(dptr);
}
*key = INVALID_DPTR_KEY;
return;
}
dptr = dptr_get(*key, True);
if (!dptr) {
DEBUG(0,("Invalid key %d given to dptr_close\n", *key));
return;
}
dptr_close_internal(dptr);
*key = INVALID_DPTR_KEY;
}
void dptr_closecnum(connection_struct *conn)
{
struct dptr_struct *dptr, *next;
for(dptr = dirptrs; dptr; dptr = next) {
next = dptr->next;
if (dptr->conn == conn)
dptr_close_internal(dptr);
}
}
void dptr_idlecnum(connection_struct *conn)
{
struct dptr_struct *dptr;
for(dptr = dirptrs; dptr; dptr = dptr->next) {
if (dptr->conn == conn) {
dptr_idle(dptr);
}
}
}
void dptr_closepath(char *path,uint16 spid)
{
struct dptr_struct *dptr, *next;
for(dptr = dirptrs; dptr; dptr = next) {
next = dptr->next;
if (spid == dptr->spid && strequal(dptr->path,path)) {
dptr_close_internal(dptr);
}
}
}
static void dptr_close_oldest(BOOL old)
{
struct dptr_struct *dptr;
for(dptr = dirptrs; dptr && dptr->next; dptr = dptr->next)
;
if(!dptr) {
DEBUG(0,("No old dptrs available to close oldest ?\n"));
return;
}
for(; dptr; dptr = dptr->prev) {
if ((old && (dptr->dnum < 256) && !dptr->expect_close) ||
(!old && (dptr->dnum > 255))) {
dptr_close_internal(dptr);
return;
}
}
}
NTSTATUS dptr_create(connection_struct *conn, pstring path, BOOL old_handle, BOOL expect_close,uint16 spid,
const char *wcard, BOOL wcard_has_wild, uint32 attr, struct dptr_struct **dptr_ret)
{
struct dptr_struct *dptr = NULL;
struct smb_Dir *dir_hnd;
const char *dir2;
NTSTATUS status;
DEBUG(5,("dptr_create dir=%s\n", path));
if (!wcard) {
return NT_STATUS_INVALID_PARAMETER;
}
status = check_name(conn,path);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
dir2 = path;
if (!*dir2)
dir2 = ".";
dir_hnd = OpenDir(conn, dir2, wcard, attr);
if (!dir_hnd) {
return map_nt_error_from_unix(errno);
}
string_set(&conn->dirpath,dir2);
if (dirhandles_open >= MAX_OPEN_DIRECTORIES) {
dptr_idleoldest();
}
dptr = SMB_MALLOC_P(struct dptr_struct);
if(!dptr) {
DEBUG(0,("malloc fail in dptr_create.\n"));
CloseDir(dir_hnd);
return NT_STATUS_NO_MEMORY;
}
ZERO_STRUCTP(dptr);
if(old_handle) {
dptr->dnum = bitmap_find(dptr_bmap, 0);
if(dptr->dnum == -1 || dptr->dnum > 254) {
dptr_close_oldest(True);
dptr->dnum = bitmap_find(dptr_bmap, 0);
if(dptr->dnum == -1 || dptr->dnum > 254) {
DEBUG(0,("dptr_create: returned %d: Error - all old dirptrs in use ?\n", dptr->dnum));
SAFE_FREE(dptr);
CloseDir(dir_hnd);
return NT_STATUS_TOO_MANY_OPENED_FILES;
}
}
} else {
dptr->dnum = bitmap_find(dptr_bmap, 255);
if(dptr->dnum == -1 || dptr->dnum < 255) {
dptr_close_oldest(False);
dptr->dnum = bitmap_find(dptr_bmap, 255);
if(dptr->dnum == -1 || dptr->dnum < 255) {
DEBUG(0,("dptr_create: returned %d: Error - all new dirptrs in use ?\n", dptr->dnum));
SAFE_FREE(dptr);
CloseDir(dir_hnd);
return NT_STATUS_TOO_MANY_OPENED_FILES;
}
}
}
bitmap_set(dptr_bmap, dptr->dnum);
dptr->dnum += 1;
string_set(&dptr->path,dir2);
dptr->conn = conn;
dptr->dir_hnd = dir_hnd;
dptr->spid = spid;
dptr->expect_close = expect_close;
dptr->wcard = SMB_STRDUP(wcard);
if (!dptr->wcard) {
bitmap_clear(dptr_bmap, dptr->dnum - 1);
SAFE_FREE(dptr);
CloseDir(dir_hnd);
return NT_STATUS_NO_MEMORY;
}
if (lp_posix_pathnames() || (wcard[0] == '.' && wcard[1] == 0)) {
dptr->has_wild = True;
} else {
dptr->has_wild = wcard_has_wild;
}
dptr->attr = attr;
DLIST_ADD(dirptrs, dptr);
DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
dptr->dnum,path,expect_close));
*dptr_ret = dptr;
return NT_STATUS_OK;
}
int dptr_CloseDir(struct dptr_struct *dptr)
{
DLIST_REMOVE(dirptrs, dptr);
return CloseDir(dptr->dir_hnd);
}
void dptr_SeekDir(struct dptr_struct *dptr, long offset)
{
SeekDir(dptr->dir_hnd, offset);
}
long dptr_TellDir(struct dptr_struct *dptr)
{
return TellDir(dptr->dir_hnd);
}
BOOL dptr_has_wild(struct dptr_struct *dptr)
{
return dptr->has_wild;
}
int dptr_dnum(struct dptr_struct *dptr)
{
return dptr->dnum;
}
static const char *dptr_normal_ReadDirName(struct dptr_struct *dptr, long *poffset, SMB_STRUCT_STAT *pst)
{
const char *name;
while ((name = ReadDirName(dptr->dir_hnd, poffset)) != NULL) {
if (is_visible_file(dptr->conn, dptr->path, name, pst, True)) {
return name;
}
}
return NULL;
}
const char *dptr_ReadDirName(struct dptr_struct *dptr, long *poffset, SMB_STRUCT_STAT *pst)
{
SET_STAT_INVALID(*pst);
if (dptr->has_wild) {
return dptr_normal_ReadDirName(dptr, poffset, pst);
}
if (*poffset == END_OF_DIRECTORY_OFFSET) {
return NULL;
}
if (!dptr->did_stat) {
pstring pathreal;
dptr->did_stat = True;
if (!is_visible_file(dptr->conn, dptr->path, dptr->wcard, pst, True)) {
dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
return NULL;
}
if (VALID_STAT(*pst)) {
dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
return dptr->wcard;
}
pstrcpy(pathreal,dptr->path);
pstrcat(pathreal,"/");
pstrcat(pathreal,dptr->wcard);
if (SMB_VFS_STAT(dptr->conn,pathreal,pst) == 0) {
dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
return dptr->wcard;
} else {
if (errno != ENOENT && errno != ENOTDIR) {
dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
return dptr->wcard;
}
}
if (dptr->conn->case_sensitive ||
!(dptr->conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) {
dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
return NULL;
}
}
if (dptr->dir_hnd->dir == NULL) {
dptr->dir_hnd->offset = *poffset = END_OF_DIRECTORY_OFFSET;
return NULL;
}
return dptr_normal_ReadDirName(dptr, poffset, pst);
}
BOOL dptr_SearchDir(struct dptr_struct *dptr, const char *name, long *poffset, SMB_STRUCT_STAT *pst)
{
SET_STAT_INVALID(*pst);
if (!dptr->has_wild && (dptr->dir_hnd->offset == END_OF_DIRECTORY_OFFSET)) {
*poffset = END_OF_DIRECTORY_OFFSET;
return False;
}
return SearchDir(dptr->dir_hnd, name, poffset);
}
void dptr_DirCacheAdd(struct dptr_struct *dptr, const char *name, long offset)
{
DirCacheAdd(dptr->dir_hnd, name, offset);
}
BOOL dptr_fill(char *buf1,unsigned int key)
{
unsigned char *buf = (unsigned char *)buf1;
struct dptr_struct *dptr = dptr_get(key, False);
uint32 offset;
if (!dptr) {
DEBUG(1,("filling null dirptr %d\n",key));
return(False);
}
offset = (uint32)TellDir(dptr->dir_hnd);
DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
(long)dptr->dir_hnd,(int)offset));
buf[0] = key;
SIVAL(buf,1,offset);
return(True);
}
struct dptr_struct *dptr_fetch(char *buf,int *num)
{
unsigned int key = *(unsigned char *)buf;
struct dptr_struct *dptr = dptr_get(key, False);
uint32 offset;
long seekoff;
if (!dptr) {
DEBUG(3,("fetched null dirptr %d\n",key));
return(NULL);
}
*num = key;
offset = IVAL(buf,1);
if (offset == (uint32)-1) {
seekoff = END_OF_DIRECTORY_OFFSET;
} else {
seekoff = (long)offset;
}
SeekDir(dptr->dir_hnd,seekoff);
DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
key,dptr_path(key),(int)seekoff));
return(dptr);
}
struct dptr_struct *dptr_fetch_lanman2(int dptr_num)
{
struct dptr_struct *dptr = dptr_get(dptr_num, False);
if (!dptr) {
DEBUG(3,("fetched null dirptr %d\n",dptr_num));
return(NULL);
}
DEBUG(3,("fetching dirptr %d for path %s\n",dptr_num,dptr_path(dptr_num)));
return(dptr);
}
BOOL dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
{
uint32 mask;
if (((mode & ~dirtype) & (aHIDDEN | aSYSTEM | aDIR)) != 0)
return False;
mask = ((dirtype >> 8) & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM));
if(mask) {
if((mask & (mode & (aDIR|aARCH|aRONLY|aHIDDEN|aSYSTEM))) == mask)
return True;
else
return False;
}
return True;
}
static BOOL mangle_mask_match(connection_struct *conn, fstring filename, char *mask)
{
mangle_map(filename,True,False,conn->params);
return mask_match_search(filename,mask,False);
}
BOOL get_dir_entry(connection_struct *conn,char *mask,uint32 dirtype, pstring fname,
SMB_OFF_T *size,uint32 *mode,time_t *date,BOOL check_descend)
{
const char *dname;
BOOL found = False;
SMB_STRUCT_STAT sbuf;
pstring path;
pstring pathreal;
pstring filename;
BOOL needslash;
*path = *pathreal = *filename = 0;
needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
if (!conn->dirptr)
return(False);
while (!found) {
long curoff = dptr_TellDir(conn->dirptr);
dname = dptr_ReadDirName(conn->dirptr, &curoff, &sbuf);
DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
(long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
if (dname == NULL)
return(False);
pstrcpy(filename,dname);
if ((strcmp(mask,"*.*") == 0) ||
mask_match_search(filename,mask,False) ||
mangle_mask_match(conn,filename,mask)) {
if (!mangle_is_8_3(filename, False, conn->params))
mangle_map(filename,True,False,
conn->params);
pstrcpy(fname,filename);
*path = 0;
pstrcpy(path,conn->dirpath);
if(needslash)
pstrcat(path,"/");
pstrcpy(pathreal,path);
pstrcat(path,fname);
pstrcat(pathreal,dname);
if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn, pathreal, &sbuf)) != 0) {
DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",path, strerror(errno) ));
continue;
}
*mode = dos_mode(conn,pathreal,&sbuf);
if (!dir_check_ftype(conn,*mode,dirtype)) {
DEBUG(5,("[%s] attribs 0x%x didn't match 0x%x\n",filename,(unsigned int)*mode,(unsigned int)dirtype));
continue;
}
*size = sbuf.st_size;
*date = sbuf.st_mtime;
DEBUG(3,("get_dir_entry mask=[%s] found %s fname=%s\n",mask, pathreal,fname));
found = True;
DirCacheAdd(conn->dirptr->dir_hnd, dname, curoff);
}
}
return(found);
}
static BOOL user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
{
SEC_DESC *psd = NULL;
size_t sd_size;
files_struct *fsp;
NTSTATUS status;
uint32 access_granted;
if (conn->admin_user) {
return True;
}
SMB_ASSERT(VALID_STAT(*pst));
if(S_ISDIR(pst->st_mode)) {
status = open_directory(conn, name, pst,
READ_CONTROL_ACCESS,
FILE_SHARE_READ|FILE_SHARE_WRITE,
FILE_OPEN,
0,
FILE_ATTRIBUTE_DIRECTORY,
NULL, &fsp);
} else {
status = open_file_stat(conn, name, pst, &fsp);
}
if (!NT_STATUS_IS_OK(status)) {
return False;
}
sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fh->fd,
(OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
close_file(fsp, NORMAL_CLOSE);
if (!sd_size) {
return False;
}
return se_access_check(psd, current_user.nt_user_token, FILE_READ_DATA,
&access_granted, &status);
}
static BOOL user_can_write_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
{
SEC_DESC *psd = NULL;
size_t sd_size;
files_struct *fsp;
int info;
NTSTATUS status;
uint32 access_granted;
if (conn->admin_user) {
return True;
}
SMB_ASSERT(VALID_STAT(*pst));
if(S_ISDIR(pst->st_mode)) {
return True;
} else {
status = open_file_ntcreate(conn, name, pst,
FILE_WRITE_ATTRIBUTES,
FILE_SHARE_READ|FILE_SHARE_WRITE,
FILE_OPEN,
0,
FILE_ATTRIBUTE_NORMAL,
INTERNAL_OPEN_ONLY,
&info, &fsp);
}
if (!NT_STATUS_IS_OK(status)) {
return False;
}
sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fh->fd,
(OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
close_file(fsp, NORMAL_CLOSE);
if (!sd_size)
return False;
return se_access_check(psd, current_user.nt_user_token, FILE_WRITE_DATA,
&access_granted, &status);
}
static BOOL file_is_special(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
{
if (conn->admin_user)
return False;
SMB_ASSERT(VALID_STAT(*pst));
if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
return False;
return True;
}
BOOL is_visible_file(connection_struct *conn, const char *dir_path, const char *name, SMB_STRUCT_STAT *pst, BOOL use_veto)
{
BOOL hide_unreadable = lp_hideunreadable(SNUM(conn));
BOOL hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
BOOL hide_special = lp_hide_special_files(SNUM(conn));
SET_STAT_INVALID(*pst);
if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
return True;
}
if (use_veto && IS_VETO_PATH(conn, name)) {
DEBUG(10,("is_visible_file: file %s is vetoed.\n", name ));
return False;
}
if (hide_unreadable || hide_unwriteable || hide_special) {
pstring link_target;
char *entry = NULL;
if (asprintf(&entry, "%s/%s", dir_path, name) == -1) {
return False;
}
if (lp_host_msdfs() &&
lp_msdfs_root(SNUM(conn)) &&
is_msdfs_link(conn, entry, link_target, NULL)) {
SAFE_FREE(entry);
return True;
}
if (SMB_VFS_STAT(conn, entry, pst) != 0) {
SAFE_FREE(entry);
return True;
}
if (hide_unreadable && !user_can_read_file(conn, entry, pst)) {
DEBUG(10,("is_visible_file: file %s is unreadable.\n", entry ));
SAFE_FREE(entry);
return False;
}
if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
DEBUG(10,("is_visible_file: file %s is unwritable.\n", entry ));
SAFE_FREE(entry);
return False;
}
if (hide_special && file_is_special(conn, entry, pst)) {
DEBUG(10,("is_visible_file: file %s is special.\n", entry ));
SAFE_FREE(entry);
return False;
}
SAFE_FREE(entry);
}
return True;
}
struct smb_Dir *OpenDir(connection_struct *conn, const char *path, const char *mask, uint32 attr)
{
struct smb_Dir *dirp = SMB_MALLOC_P(struct smb_Dir);
if (!dirp) {
return NULL;
}
ZERO_STRUCTP(dirp);
dirp->conn = conn;
dirp->dir_path = SMB_STRDUP(path);
if (!dirp->dir_path) {
goto fail;
}
dirp->dir = SMB_VFS_OPENDIR(conn, dirp->dir_path, mask, attr);
if (!dirp->dir) {
if (errno == ENOENT || errno == ENOTDIR ||
mask == NULL || ms_has_wild(mask)) {
DEBUG(5, ("OpenDir: can't open directory '%s': %s\n",
dirp->dir_path, strerror(errno) ));
goto fail;
}
DEBUG(5, ("OpenDir: can't open directory '%s': %s, continuing\n",
dirp->dir_path, strerror(errno) ));
}
dirp->name_cache = SMB_CALLOC_ARRAY(struct name_cache_entry, NAME_CACHE_SIZE);
if (!dirp->name_cache) {
goto fail;
}
dirhandles_open++;
return dirp;
fail:
if (dirp) {
if (dirp->dir) {
SMB_VFS_CLOSEDIR(conn,dirp->dir);
}
SAFE_FREE(dirp->dir_path);
SAFE_FREE(dirp->name_cache);
SAFE_FREE(dirp);
}
return NULL;
}
int CloseDir(struct smb_Dir *dirp)
{
int i, ret = 0;
if (dirp->dir) {
ret = SMB_VFS_CLOSEDIR(dirp->conn,dirp->dir);
}
SAFE_FREE(dirp->dir_path);
if (dirp->name_cache) {
for (i = 0; i < NAME_CACHE_SIZE; i++) {
SAFE_FREE(dirp->name_cache[i].name);
}
}
SAFE_FREE(dirp->name_cache);
SAFE_FREE(dirp);
dirhandles_open--;
return ret;
}
const char *ReadDirName(struct smb_Dir *dirp, long *poffset)
{
const char *n;
connection_struct *conn = dirp->conn;
SMB_ASSERT(dirp->dir != NULL);
if (((*poffset == START_OF_DIRECTORY_OFFSET) || (*poffset == DOT_DOT_DIRECTORY_OFFSET)) && (dirp->file_number < 2)) {
if (dirp->file_number == 0) {
n = ".";
*poffset = dirp->offset = START_OF_DIRECTORY_OFFSET;
} else {
*poffset = dirp->offset = DOT_DOT_DIRECTORY_OFFSET;
n = "..";
}
dirp->file_number++;
return n;
} else if (*poffset == END_OF_DIRECTORY_OFFSET) {
*poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
return NULL;
} else {
SeekDir(dirp, *poffset);
}
while ((n = vfs_readdirname(conn, dirp->dir))) {
if (*n == '.') {
if ((n[1] == '\0') || (n[1] == '.' && n[2] == '\0')) {
continue;
}
}
*poffset = dirp->offset = SMB_VFS_TELLDIR(conn, dirp->dir);
dirp->file_number++;
return n;
}
*poffset = dirp->offset = END_OF_DIRECTORY_OFFSET;
return NULL;
}
void RewindDir(struct smb_Dir *dirp, long *poffset)
{
SMB_ASSERT(dirp->dir != NULL);
SMB_VFS_REWINDDIR(dirp->conn, dirp->dir);
dirp->file_number = 0;
dirp->offset = START_OF_DIRECTORY_OFFSET;
*poffset = START_OF_DIRECTORY_OFFSET;
}
void SeekDir(struct smb_Dir *dirp, long offset)
{
SMB_ASSERT(dirp->dir != NULL);
if (offset != dirp->offset) {
if (offset == START_OF_DIRECTORY_OFFSET) {
RewindDir(dirp, &offset);
} else if (offset == DOT_DOT_DIRECTORY_OFFSET) {
RewindDir(dirp, &offset);
dirp->file_number = 2;
} else if (offset == END_OF_DIRECTORY_OFFSET) {
;
} else {
SMB_VFS_SEEKDIR(dirp->conn, dirp->dir, offset);
}
dirp->offset = offset;
}
}
long TellDir(struct smb_Dir *dirp)
{
return(dirp->offset);
}
void DirCacheAdd(struct smb_Dir *dirp, const char *name, long offset)
{
struct name_cache_entry *e;
dirp->name_cache_index = (dirp->name_cache_index+1) % NAME_CACHE_SIZE;
e = &dirp->name_cache[dirp->name_cache_index];
SAFE_FREE(e->name);
e->name = SMB_STRDUP(name);
e->offset = offset;
}
BOOL SearchDir(struct smb_Dir *dirp, const char *name, long *poffset)
{
int i;
const char *entry;
connection_struct *conn = dirp->conn;
SMB_ASSERT(dirp->dir != NULL);
for (i = dirp->name_cache_index; i >= 0; i--) {
struct name_cache_entry *e = &dirp->name_cache[i];
if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
*poffset = e->offset;
SeekDir(dirp, e->offset);
return True;
}
}
for (i = NAME_CACHE_SIZE-1; i > dirp->name_cache_index; i--) {
struct name_cache_entry *e = &dirp->name_cache[i];
if (e->name && (conn->case_sensitive ? (strcmp(e->name, name) == 0) : strequal(e->name, name))) {
*poffset = e->offset;
SeekDir(dirp, e->offset);
return True;
}
}
SMB_VFS_REWINDDIR(conn, dirp->dir);
dirp->file_number = 0;
*poffset = START_OF_DIRECTORY_OFFSET;
while ((entry = ReadDirName(dirp, poffset))) {
if (conn->case_sensitive ? (strcmp(entry, name) == 0) : strequal(entry, name)) {
return True;
}
}
return False;
}
NTSTATUS can_delete_directory(struct connection_struct *conn,
const char *dirname)
{
NTSTATUS status = NT_STATUS_OK;
long dirpos = 0;
const char *dname;
struct smb_Dir *dir_hnd = OpenDir(conn, dirname, NULL, 0);
if (!dir_hnd) {
return map_nt_error_from_unix(errno);
}
while ((dname = ReadDirName(dir_hnd,&dirpos))) {
SMB_STRUCT_STAT st;
if (dname[0] == '.') {
if (!dname[1] || (dname[1] == '.' && !dname[2])) {
continue;
}
}
if (!is_visible_file(conn, dirname, dname, &st, True)) {
continue;
}
DEBUG(10,("can_delete_directory: got name %s - can't delete\n", dname ));
status = NT_STATUS_DIRECTORY_NOT_EMPTY;
break;
}
CloseDir(dir_hnd);
return status;
}