#include "includes.h"
typedef struct _dptr_struct {
struct _dptr_struct *next, *prev;
int dnum;
uint16 spid;
connection_struct *conn;
void *ptr;
BOOL expect_close;
char *wcard;
uint16 attr;
char *path;
} dptr_struct;
static struct bitmap *dptr_bmap;
static dptr_struct *dirptrs;
static int dptrs_open = 0;
#define INVALID_DPTR_KEY (-3)
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(dptr_struct *dptr)
{
if (dptr->ptr) {
DEBUG(4,("Idling dptr dnum %d\n",dptr->dnum));
dptrs_open--;
CloseDir(dptr->ptr);
dptr->ptr = NULL;
}
}
static void dptr_idleoldest(void)
{
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) {
if (dptr->ptr) {
dptr_idle(dptr);
return;
}
}
}
static dptr_struct *dptr_get(int key, BOOL forclose)
{
dptr_struct *dptr;
for(dptr = dirptrs; dptr; dptr = dptr->next) {
if(dptr->dnum == key) {
if (!forclose && !dptr->ptr) {
if (dptrs_open >= MAX_OPEN_DIRECTORIES)
dptr_idleoldest();
DEBUG(4,("Reopening dptr key %d\n",key));
if ((dptr->ptr = OpenDir(dptr->conn, dptr->path, True)))
dptrs_open++;
}
DLIST_PROMOTE(dirptrs,dptr);
return dptr;
}
}
return(NULL);
}
static void *dptr_ptr(int key)
{
dptr_struct *dptr = dptr_get(key, False);
if (dptr)
return(dptr->ptr);
return(NULL);
}
char *dptr_path(int key)
{
dptr_struct *dptr = dptr_get(key, False);
if (dptr)
return(dptr->path);
return(NULL);
}
char *dptr_wcard(int key)
{
dptr_struct *dptr = dptr_get(key, False);
if (dptr)
return(dptr->wcard);
return(NULL);
}
BOOL dptr_set_wcard(int key, char *wcard)
{
dptr_struct *dptr = dptr_get(key, False);
if (dptr) {
dptr->wcard = wcard;
return True;
}
return False;
}
BOOL dptr_set_attr(int key, uint16 attr)
{
dptr_struct *dptr = dptr_get(key, False);
if (dptr) {
dptr->attr = attr;
return True;
}
return False;
}
uint16 dptr_attr(int key)
{
dptr_struct *dptr = dptr_get(key, False);
if (dptr)
return(dptr->attr);
return(0);
}
static void dptr_close_internal(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->ptr) {
CloseDir(dptr->ptr);
dptrs_open--;
}
SAFE_FREE(dptr->wcard);
string_set(&dptr->path,"");
SAFE_FREE(dptr);
}
void dptr_close(int *key)
{
dptr_struct *dptr;
if(*key == INVALID_DPTR_KEY)
return;
if (*key == -1) {
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)
{
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)
{
dptr_struct *dptr;
for(dptr = dirptrs; dptr; dptr = dptr->next) {
if (dptr->conn == conn && dptr->ptr)
dptr_idle(dptr);
}
}
void dptr_closepath(char *path,uint16 spid)
{
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 BOOL start_dir(connection_struct *conn, pstring directory)
{
const char *dir2;
DEBUG(5,("start_dir dir=%s\n",directory));
if (!check_name(directory,conn))
return(False);
dir2 = directory;
if (! *dir2)
dir2 = ".";
conn->dirptr = OpenDir(conn, directory, True);
if (conn->dirptr) {
dptrs_open++;
string_set(&conn->dirpath,directory);
return(True);
}
return(False);
}
static void dptr_close_oldest(BOOL old)
{
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;
}
}
}
int dptr_create(connection_struct *conn, pstring path, BOOL old_handle, BOOL expect_close,uint16 spid)
{
dptr_struct *dptr;
if (!start_dir(conn,path))
return(-2);
if (dptrs_open >= MAX_OPEN_DIRECTORIES)
dptr_idleoldest();
dptr = SMB_MALLOC_P(dptr_struct);
if(!dptr) {
DEBUG(0,("malloc fail in dptr_create.\n"));
return -1;
}
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);
return -1;
}
}
} 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);
return -1;
}
}
}
bitmap_set(dptr_bmap, dptr->dnum);
dptr->dnum += 1;
dptr->ptr = conn->dirptr;
string_set(&dptr->path,path);
dptr->conn = conn;
dptr->spid = spid;
dptr->expect_close = expect_close;
dptr->wcard = NULL;
dptr->attr = 0;
DLIST_ADD(dirptrs, dptr);
DEBUG(3,("creating new dirptr %d for path %s, expect_close = %d\n",
dptr->dnum,path,expect_close));
return(dptr->dnum);
}
BOOL dptr_fill(char *buf1,unsigned int key)
{
unsigned char *buf = (unsigned char *)buf1;
void *p = dptr_ptr(key);
uint32 offset;
if (!p) {
DEBUG(1,("filling null dirptr %d\n",key));
return(False);
}
offset = TellDir(p);
DEBUG(6,("fill on key %u dirptr 0x%lx now at %d\n",key,
(long)p,(int)offset));
buf[0] = key;
SIVAL(buf,1,offset | DPTR_MASK);
return(True);
}
void *dptr_fetch(char *buf,int *num)
{
unsigned int key = *(unsigned char *)buf;
void *p = dptr_ptr(key);
uint32 offset;
if (!p) {
DEBUG(3,("fetched null dirptr %d\n",key));
return(NULL);
}
*num = key;
offset = IVAL(buf,1)&~DPTR_MASK;
SeekDir(p,offset);
DEBUG(3,("fetching dirptr %d for path %s at offset %d\n",
key,dptr_path(key),offset));
return(p);
}
void *dptr_fetch_lanman2(int dptr_num)
{
void *p = dptr_ptr(dptr_num);
if (!p) {
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(p);
}
BOOL dir_check_ftype(connection_struct *conn,int mode,SMB_STRUCT_STAT *st,int dirtype)
{
int 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,SNUM(conn));
return mask_match(filename,mask,False);
}
BOOL get_dir_entry(connection_struct *conn,char *mask,int dirtype, pstring fname,
SMB_OFF_T *size,int *mode,time_t *date,BOOL check_descend)
{
const char *dname;
BOOL found = False;
SMB_STRUCT_STAT sbuf;
pstring path;
pstring pathreal;
BOOL isrootdir;
pstring filename;
BOOL needslash;
*path = *pathreal = *filename = 0;
isrootdir = (strequal(conn->dirpath,"./") ||
strequal(conn->dirpath,".") ||
strequal(conn->dirpath,"/"));
needslash = ( conn->dirpath[strlen(conn->dirpath) -1] != '/');
if (!conn->dirptr)
return(False);
while (!found) {
dname = ReadDirName(conn->dirptr);
DEBUG(6,("readdir on dirptr 0x%lx now at offset %d\n",
(long)conn->dirptr,TellDir(conn->dirptr)));
if (dname == NULL)
return(False);
pstrcpy(filename,dname);
if ((strcmp(mask,"*.*") == 0) ||
mask_match(filename,mask,False) ||
mangle_mask_match(conn,filename,mask)) {
if (isrootdir && (strequal(filename,"..") || strequal(filename,".")))
continue;
if (!mangle_is_8_3(filename, False))
mangle_map(filename,True,False,SNUM(conn));
pstrcpy(fname,filename);
*path = 0;
pstrcpy(path,conn->dirpath);
if(needslash)
pstrcat(path,"/");
pstrcpy(pathreal,path);
pstrcat(path,fname);
pstrcat(pathreal,dname);
if (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,&sbuf,dirtype)) {
DEBUG(5,("[%s] attribs didn't match %x\n",filename,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;
}
}
return(found);
}
typedef struct {
int pos;
int numentries;
int mallocsize;
char *data;
char *current;
} Dir;
static BOOL user_can_read_file(connection_struct *conn, char *name, SMB_STRUCT_STAT *pst)
{
extern struct current_user current_user;
SEC_DESC *psd = NULL;
size_t sd_size;
files_struct *fsp;
int smb_action;
NTSTATUS status;
uint32 access_granted;
if (conn->admin_user)
return True;
if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0))
return False;
if(S_ISDIR(pst->st_mode))
fsp = open_directory(conn, name, pst, 0, SET_DENY_MODE(DENY_NONE), (FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN),
&smb_action);
else
fsp = open_file_stat(conn, name, pst);
if (!fsp)
return False;
sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fd,
(OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
close_file(fsp, True);
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)
{
extern struct current_user current_user;
SEC_DESC *psd = NULL;
size_t sd_size;
files_struct *fsp;
int smb_action;
int access_mode;
NTSTATUS status;
uint32 access_granted;
if (conn->admin_user)
return True;
if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0))
return False;
if(S_ISDIR(pst->st_mode))
return True;
else
fsp = open_file_shared1(conn, name, pst, FILE_WRITE_ATTRIBUTES, SET_DENY_MODE(DENY_NONE),
(FILE_FAIL_IF_NOT_EXIST|FILE_EXISTS_OPEN), FILE_ATTRIBUTE_NORMAL, INTERNAL_OPEN_ONLY,
&access_mode, &smb_action);
if (!fsp)
return False;
sd_size = SMB_VFS_FGET_NT_ACL(fsp, fsp->fd,
(OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
close_file(fsp, False);
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;
if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, name, pst) != 0))
return True;
if (S_ISREG(pst->st_mode) || S_ISDIR(pst->st_mode) || S_ISLNK(pst->st_mode))
return False;
return True;
}
void *OpenDir(connection_struct *conn, const char *name, BOOL use_veto)
{
Dir *dirp;
const char *n;
DIR *p = SMB_VFS_OPENDIR(conn,name);
int used=0;
if (!p)
return(NULL);
dirp = SMB_MALLOC_P(Dir);
if (!dirp) {
DEBUG(0,("Out of memory in OpenDir\n"));
SMB_VFS_CLOSEDIR(conn,p);
return(NULL);
}
dirp->pos = dirp->numentries = dirp->mallocsize = 0;
dirp->data = dirp->current = NULL;
while (True) {
int l;
BOOL normal_entry = True;
SMB_STRUCT_STAT st;
char *entry = NULL;
if (used == 0) {
n = ".";
normal_entry = False;
} else if (used == 2) {
n = "..";
normal_entry = False;
} else {
n = vfs_readdirname(conn, p);
if (n == NULL)
break;
if ((strcmp(".",n) == 0) ||(strcmp("..",n) == 0))
continue;
normal_entry = True;
}
ZERO_STRUCT(st);
l = strlen(n)+1;
if (normal_entry && use_veto && conn && IS_VETO_PATH(conn, n))
continue;
if (normal_entry && conn && lp_hideunreadable(SNUM(conn))) {
int ret=0;
if (entry || asprintf(&entry, "%s/%s/%s", conn->origpath, name, n) > 0) {
ret = user_can_read_file(conn, entry, &st);
}
if (!ret) {
SAFE_FREE(entry);
continue;
}
}
if (normal_entry && conn && lp_hideunwriteable_files(SNUM(conn))) {
int ret=0;
if (entry || asprintf(&entry, "%s/%s/%s", conn->origpath, name, n) > 0) {
ret = user_can_write_file(conn, entry, &st);
}
if (!ret) {
SAFE_FREE(entry);
continue;
}
}
if (normal_entry && conn && lp_hide_special_files(SNUM(conn))) {
int ret=0;
if (entry || asprintf(&entry, "%s/%s/%s", conn->origpath, name, n) > 0) {
ret = file_is_special(conn, entry, &st);
}
if (ret) {
SAFE_FREE(entry);
continue;
}
}
SAFE_FREE(entry);
if (used + l > dirp->mallocsize) {
int s = MAX(used+l,used+2000);
char *r;
r = (char *)SMB_REALLOC(dirp->data,s);
if (!r) {
DEBUG(0,("Out of memory in OpenDir\n"));
break;
}
dirp->data = r;
dirp->mallocsize = s;
dirp->current = dirp->data;
}
safe_strcpy_base(dirp->data+used,n, dirp->data, dirp->mallocsize);
used += l;
dirp->numentries++;
}
SMB_VFS_CLOSEDIR(conn,p);
return((void *)dirp);
}
void CloseDir(void *p)
{
if (!p)
return;
SAFE_FREE(((Dir *)p)->data);
SAFE_FREE(p);
}
const char *ReadDirName(void *p)
{
char *ret;
Dir *dirp = (Dir *)p;
if (!dirp || !dirp->current || dirp->pos >= dirp->numentries)
return(NULL);
ret = dirp->current;
dirp->current = skip_string(dirp->current,1);
dirp->pos++;
return(ret);
}
BOOL SeekDir(void *p,int pos)
{
Dir *dirp = (Dir *)p;
if (!dirp)
return(False);
if (pos < dirp->pos) {
dirp->current = dirp->data;
dirp->pos = 0;
}
while (dirp->pos < pos && ReadDirName(p))
;
return (dirp->pos == pos);
}
int TellDir(void *p)
{
Dir *dirp = (Dir *)p;
if (!dirp)
return(-1);
return(dirp->pos);
}