#include "includes.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_VFS
struct vfs_init_function_entry {
char *name;
vfs_op_tuple *vfs_op_tuples;
struct vfs_init_function_entry *prev, *next;
};
static struct vfs_init_function_entry *backends = NULL;
struct vfs_syminfo {
char *name;
void *fptr;
};
static struct vfs_ops default_vfs = {
{
vfswrap_dummy_connect,
vfswrap_dummy_disconnect,
vfswrap_disk_free,
vfswrap_get_quota,
vfswrap_set_quota,
vfswrap_get_shadow_copy_data,
vfswrap_opendir,
vfswrap_readdir,
vfswrap_mkdir,
vfswrap_rmdir,
vfswrap_closedir,
vfswrap_open,
vfswrap_close,
vfswrap_read,
vfswrap_pread,
vfswrap_write,
vfswrap_pwrite,
vfswrap_lseek,
vfswrap_sendfile,
vfswrap_rename,
vfswrap_fsync,
vfswrap_stat,
vfswrap_fstat,
vfswrap_lstat,
vfswrap_unlink,
vfswrap_chmod,
vfswrap_fchmod,
vfswrap_chown,
vfswrap_fchown,
vfswrap_chdir,
vfswrap_getwd,
vfswrap_utime,
vfswrap_ftruncate,
vfswrap_lock,
vfswrap_symlink,
vfswrap_readlink,
vfswrap_link,
vfswrap_mknod,
vfswrap_realpath,
vfswrap_fget_nt_acl,
vfswrap_get_nt_acl,
vfswrap_fset_nt_acl,
vfswrap_set_nt_acl,
vfswrap_chmod_acl,
vfswrap_fchmod_acl,
vfswrap_sys_acl_get_entry,
vfswrap_sys_acl_get_tag_type,
vfswrap_sys_acl_get_permset,
vfswrap_sys_acl_get_qualifier,
vfswrap_sys_acl_get_file,
vfswrap_sys_acl_get_fd,
vfswrap_sys_acl_clear_perms,
vfswrap_sys_acl_add_perm,
vfswrap_sys_acl_to_text,
vfswrap_sys_acl_init,
vfswrap_sys_acl_create_entry,
vfswrap_sys_acl_set_tag_type,
vfswrap_sys_acl_set_qualifier,
vfswrap_sys_acl_set_permset,
vfswrap_sys_acl_valid,
vfswrap_sys_acl_set_file,
vfswrap_sys_acl_set_fd,
vfswrap_sys_acl_delete_def_file,
vfswrap_sys_acl_get_perm,
vfswrap_sys_acl_free_text,
vfswrap_sys_acl_free_acl,
vfswrap_sys_acl_free_qualifier,
vfswrap_getxattr,
vfswrap_lgetxattr,
vfswrap_fgetxattr,
vfswrap_listxattr,
vfswrap_llistxattr,
vfswrap_flistxattr,
vfswrap_removexattr,
vfswrap_lremovexattr,
vfswrap_fremovexattr,
vfswrap_setxattr,
vfswrap_lsetxattr,
vfswrap_fsetxattr
}
};
static struct vfs_init_function_entry *vfs_find_backend_entry(const char *name)
{
struct vfs_init_function_entry *entry = backends;
while(entry) {
if (strcmp(entry->name, name)==0) return entry;
entry = entry->next;
}
return NULL;
}
NTSTATUS smb_register_vfs(int version, const char *name, vfs_op_tuple *vfs_op_tuples)
{
struct vfs_init_function_entry *entry = backends;
if ((version != SMB_VFS_INTERFACE_VERSION)) {
DEBUG(0, ("Failed to register vfs module.\n"
"The module was compiled against SMB_VFS_INTERFACE_VERSION %d,\n"
"current SMB_VFS_INTERFACE_VERSION is %d.\n"
"Please recompile against the current Samba Version!\n",
version, SMB_VFS_INTERFACE_VERSION));
return NT_STATUS_OBJECT_TYPE_MISMATCH;
}
if (!name || !name[0] || !vfs_op_tuples) {
DEBUG(0,("smb_register_vfs() called with NULL pointer or empty name!\n"));
return NT_STATUS_INVALID_PARAMETER;
}
if (vfs_find_backend_entry(name)) {
DEBUG(0,("VFS module %s already loaded!\n", name));
return NT_STATUS_OBJECT_NAME_COLLISION;
}
entry = SMB_XMALLOC_P(struct vfs_init_function_entry);
entry->name = smb_xstrdup(name);
entry->vfs_op_tuples = vfs_op_tuples;
DLIST_ADD(backends, entry);
DEBUG(5, ("Successfully added vfs backend '%s'\n", name));
return NT_STATUS_OK;
}
static void vfs_init_default(connection_struct *conn)
{
DEBUG(3, ("Initialising default vfs hooks\n"));
memcpy(&conn->vfs.ops, &default_vfs.ops, sizeof(default_vfs.ops));
memcpy(&conn->vfs_opaque.ops, &default_vfs.ops, sizeof(default_vfs.ops));
}
BOOL vfs_init_custom(connection_struct *conn, const char *vfs_object)
{
vfs_op_tuple *ops;
char *module_name = NULL;
char *module_param = NULL, *p;
int i;
vfs_handle_struct *handle;
struct vfs_init_function_entry *entry;
if (!conn||!vfs_object||!vfs_object[0]) {
DEBUG(0,("vfs_init_custon() called with NULL pointer or emtpy vfs_object!\n"));
return False;
}
if(!backends) static_init_vfs;
DEBUG(3, ("Initialising custom vfs hooks from [%s]\n", vfs_object));
module_name = smb_xstrdup(vfs_object);
p = strchr(module_name, ':');
if (p) {
*p = 0;
module_param = p+1;
trim_char(module_param, ' ', ' ');
}
trim_char(module_name, ' ', ' ');
if((entry = vfs_find_backend_entry(module_name)) ||
(NT_STATUS_IS_OK(smb_probe_module("vfs", module_name)) &&
(entry = vfs_find_backend_entry(module_name)))) {
DEBUGADD(5,("Successfully loaded vfs module [%s] with the new modules system\n", vfs_object));
if ((ops = entry->vfs_op_tuples) == NULL) {
DEBUG(0, ("entry->vfs_op_tuples==NULL for [%s] failed\n", vfs_object));
SAFE_FREE(module_name);
return False;
}
} else {
DEBUG(0,("Can't find a vfs module [%s]\n",vfs_object));
SAFE_FREE(module_name);
return False;
}
handle = TALLOC_ZERO_P(conn->mem_ctx,vfs_handle_struct);
if (!handle) {
DEBUG(0,("talloc_zero() failed!\n"));
SAFE_FREE(module_name);
return False;
}
memcpy(&handle->vfs_next, &conn->vfs, sizeof(struct vfs_ops));
handle->conn = conn;
if (module_param) {
handle->param = talloc_strdup(conn->mem_ctx, module_param);
}
DLIST_ADD(conn->vfs_handles, handle);
for(i=0; ops[i].op != NULL; i++) {
DEBUG(5, ("Checking operation #%d (type %d, layer %d)\n", i, ops[i].type, ops[i].layer));
if(ops[i].layer == SMB_VFS_LAYER_OPAQUE) {
if(((void**)&conn->vfs_opaque.ops)[ops[i].type] == ((void**)&default_vfs.ops)[ops[i].type]) {
DEBUGADD(5, ("Making operation type %d opaque [module %s]\n", ops[i].type, vfs_object));
((void**)&conn->vfs_opaque.ops)[ops[i].type] = ops[i].op;
((vfs_handle_struct **)&conn->vfs_opaque.handles)[ops[i].type] = handle;
}
}
DEBUGADD(5, ("Accepting operation type %d from module %s\n", ops[i].type, vfs_object));
((void**)&conn->vfs.ops)[ops[i].type] = ops[i].op;
((vfs_handle_struct **)&conn->vfs.handles)[ops[i].type] = handle;
}
SAFE_FREE(module_name);
return True;
}
BOOL smbd_vfs_init(connection_struct *conn)
{
const char **vfs_objects;
unsigned int i = 0;
int j = 0;
vfs_init_default(conn);
vfs_objects = lp_vfs_objects(SNUM(conn));
if (!vfs_objects || !vfs_objects[0])
return True;
for (i=0; vfs_objects[i] ;) {
i++;
}
for (j=i-1; j >= 0; j--) {
if (!vfs_init_custom(conn, vfs_objects[j])) {
DEBUG(0, ("smbd_vfs_init: vfs_init_custom failed for %s\n", vfs_objects[j]));
return False;
}
}
return True;
}
BOOL vfs_directory_exist(connection_struct *conn, const char *dname, SMB_STRUCT_STAT *st)
{
SMB_STRUCT_STAT st2;
BOOL ret;
if (!st)
st = &st2;
if (SMB_VFS_STAT(conn,dname,st) != 0)
return(False);
ret = S_ISDIR(st->st_mode);
if(!ret)
errno = ENOTDIR;
return ret;
}
int vfs_MkDir(connection_struct *conn, const char *name, mode_t mode)
{
int ret;
SMB_STRUCT_STAT sbuf;
if(!(ret=SMB_VFS_MKDIR(conn, name, mode))) {
inherit_access_acl(conn, name, mode);
if(mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) &&
!SMB_VFS_STAT(conn,name,&sbuf) && (mode & ~sbuf.st_mode))
SMB_VFS_CHMOD(conn,name,sbuf.st_mode | (mode & ~sbuf.st_mode));
}
return ret;
}
BOOL vfs_object_exist(connection_struct *conn,const char *fname,SMB_STRUCT_STAT *sbuf)
{
SMB_STRUCT_STAT st;
if (!sbuf)
sbuf = &st;
ZERO_STRUCTP(sbuf);
if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
return(False);
return True;
}
BOOL vfs_file_exist(connection_struct *conn, const char *fname,SMB_STRUCT_STAT *sbuf)
{
SMB_STRUCT_STAT st;
if (!sbuf)
sbuf = &st;
ZERO_STRUCTP(sbuf);
if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
return False;
return(S_ISREG(sbuf->st_mode));
}
ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count)
{
size_t total=0;
while (total < byte_count)
{
ssize_t ret = SMB_VFS_READ(fsp, fsp->fd, buf + total,
byte_count - total);
if (ret == 0) return total;
if (ret == -1) {
if (errno == EINTR)
continue;
else
return -1;
}
total += ret;
}
return (ssize_t)total;
}
ssize_t vfs_pread_data(files_struct *fsp, char *buf,
size_t byte_count, SMB_OFF_T offset)
{
size_t total=0;
while (total < byte_count)
{
ssize_t ret = SMB_VFS_PREAD(fsp, fsp->fd, buf + total,
byte_count - total, offset + total);
if (ret == 0) return total;
if (ret == -1) {
if (errno == EINTR)
continue;
else
return -1;
}
total += ret;
}
return (ssize_t)total;
}
ssize_t vfs_write_data(files_struct *fsp,const char *buffer,size_t N)
{
size_t total=0;
ssize_t ret;
while (total < N) {
ret = SMB_VFS_WRITE(fsp,fsp->fd,buffer + total,N - total);
if (ret == -1)
return -1;
if (ret == 0)
return total;
total += ret;
}
return (ssize_t)total;
}
ssize_t vfs_pwrite_data(files_struct *fsp,const char *buffer,
size_t N, SMB_OFF_T offset)
{
size_t total=0;
ssize_t ret;
while (total < N) {
ret = SMB_VFS_PWRITE(fsp, fsp->fd, buffer + total,
N - total, offset + total);
if (ret == -1)
return -1;
if (ret == 0)
return total;
total += ret;
}
return (ssize_t)total;
}
int vfs_allocate_file_space(files_struct *fsp, SMB_BIG_UINT len)
{
int ret;
SMB_STRUCT_STAT st;
connection_struct *conn = fsp->conn;
SMB_BIG_UINT space_avail;
SMB_BIG_UINT bsize,dfree,dsize;
release_level_2_oplocks_on_change(fsp);
DEBUG(10,("vfs_allocate_file_space: file %s, len %.0f\n", fsp->fsp_name, (double)len ));
if (((SMB_OFF_T)len) < 0) {
DEBUG(0,("vfs_allocate_file_space: %s negative len requested.\n", fsp->fsp_name ));
return -1;
}
ret = SMB_VFS_FSTAT(fsp,fsp->fd,&st);
if (ret == -1)
return ret;
if (len == (SMB_BIG_UINT)st.st_size)
return 0;
if (len < (SMB_BIG_UINT)st.st_size) {
DEBUG(10,("vfs_allocate_file_space: file %s, shrink. Current size %.0f\n",
fsp->fsp_name, (double)st.st_size ));
flush_write_cache(fsp, SIZECHANGE_FLUSH);
if ((ret = SMB_VFS_FTRUNCATE(fsp, fsp->fd, (SMB_OFF_T)len)) != -1) {
set_filelen_write_cache(fsp, len);
}
return ret;
}
if (!lp_strict_allocate(SNUM(fsp->conn)))
return 0;
len -= st.st_size;
len /= 1024;
space_avail = SMB_VFS_DISK_FREE(conn,fsp->fsp_name,False,&bsize,&dfree,&dsize);
DEBUG(10,("vfs_allocate_file_space: file %s, grow. Current size %.0f, needed blocks = %.0f, space avail = %.0f\n",
fsp->fsp_name, (double)st.st_size, (double)len, (double)space_avail ));
if (len > space_avail) {
errno = ENOSPC;
return -1;
}
return 0;
}
int vfs_set_filelen(files_struct *fsp, SMB_OFF_T len)
{
int ret;
release_level_2_oplocks_on_change(fsp);
DEBUG(10,("vfs_set_filelen: ftruncate %s to len %.0f\n", fsp->fsp_name, (double)len));
flush_write_cache(fsp, SIZECHANGE_FLUSH);
if ((ret = SMB_VFS_FTRUNCATE(fsp, fsp->fd, len)) != -1)
set_filelen_write_cache(fsp, len);
return ret;
}
static files_struct *in_fsp;
static files_struct *out_fsp;
static ssize_t read_fn(int fd, void *buf, size_t len)
{
return SMB_VFS_READ(in_fsp, fd, buf, len);
}
static ssize_t write_fn(int fd, const void *buf, size_t len)
{
return SMB_VFS_WRITE(out_fsp, fd, buf, len);
}
SMB_OFF_T vfs_transfer_file(files_struct *in, files_struct *out, SMB_OFF_T n)
{
in_fsp = in;
out_fsp = out;
return transfer_file_internal(in_fsp->fd, out_fsp->fd, n, read_fn, write_fn);
}
char *vfs_readdirname(connection_struct *conn, void *p)
{
struct dirent *ptr= NULL;
char *dname;
if (!p)
return(NULL);
ptr = (struct dirent *)SMB_VFS_READDIR(conn,p);
if (!ptr)
return(NULL);
dname = ptr->d_name;
#ifdef NEXT2
if (telldir(p) < 0)
return(NULL);
#endif
#ifdef HAVE_BROKEN_READDIR
dname = dname - 2;
#endif
return(dname);
}
int vfs_ChDir(connection_struct *conn, const char *path)
{
int res;
static pstring LastDir="";
if (strcsequal(path,"."))
return(0);
if (*path == '/' && strcsequal(LastDir,path))
return(0);
DEBUG(4,("vfs_ChDir to %s\n",path));
res = SMB_VFS_CHDIR(conn,path);
if (!res)
pstrcpy(LastDir,path);
return(res);
}
#define MAX_GETWDCACHE (50)
static struct {
SMB_DEV_T dev;
SMB_INO_T inode;
char *dos_path;
BOOL valid;
} ino_list[MAX_GETWDCACHE];
extern BOOL use_getwd_cache;
static void array_promote(char *array,int elsize,int element)
{
char *p;
if (element == 0)
return;
p = (char *)SMB_MALLOC(elsize);
if (!p) {
DEBUG(5,("array_promote: malloc fail\n"));
return;
}
memcpy(p,array + element * elsize, elsize);
memmove(array + elsize,array,elsize*element);
memcpy(array,p,elsize);
SAFE_FREE(p);
}
char *vfs_GetWd(connection_struct *conn, char *path)
{
pstring s;
static BOOL getwd_cache_init = False;
SMB_STRUCT_STAT st, st2;
int i;
*s = 0;
if (!use_getwd_cache)
return(SMB_VFS_GETWD(conn,path));
if (!getwd_cache_init) {
getwd_cache_init = True;
for (i=0;i<MAX_GETWDCACHE;i++) {
string_set(&ino_list[i].dos_path,"");
ino_list[i].valid = False;
}
}
if (SMB_VFS_STAT(conn, ".",&st) == -1) {
DEBUG(0,("Very strange, couldn't stat \".\" path=%s\n", path));
return(SMB_VFS_GETWD(conn,path));
}
for (i=0; i<MAX_GETWDCACHE; i++) {
if (ino_list[i].valid) {
if (st.st_ino == ino_list[i].inode && st.st_dev == ino_list[i].dev) {
if (SMB_VFS_STAT(conn,ino_list[i].dos_path,&st2) == 0) {
if (st.st_ino == st2.st_ino && st.st_dev == st2.st_dev &&
(st2.st_mode & S_IFMT) == S_IFDIR) {
pstrcpy (path, ino_list[i].dos_path);
array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
return (path);
} else {
ino_list[i].valid = False;
}
}
}
}
}
if (!SMB_VFS_GETWD(conn,s)) {
DEBUG(0,("vfs_GetWd: SMB_VFS_GETWD call failed, errno %s\n",strerror(errno)));
return (NULL);
}
pstrcpy(path,s);
DEBUG(5,("vfs_GetWd %s, inode %.0f, dev %.0f\n",s,(double)st.st_ino,(double)st.st_dev));
i = MAX_GETWDCACHE - 1;
string_set(&ino_list[i].dos_path,s);
ino_list[i].dev = st.st_dev;
ino_list[i].inode = st.st_ino;
ino_list[i].valid = True;
array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
return (path);
}
BOOL canonicalize_path(connection_struct *conn, pstring path)
{
#ifdef REALPATH_TAKES_NULL
char *resolved_name = SMB_VFS_REALPATH(conn,path,NULL);
if (!resolved_name) {
return False;
}
pstrcpy(path, resolved_name);
SAFE_FREE(resolved_name);
return True;
#else
#ifdef PATH_MAX
char resolved_name_buf[PATH_MAX+1];
#else
pstring resolved_name_buf;
#endif
char *resolved_name = SMB_VFS_REALPATH(conn,path,resolved_name_buf);
if (!resolved_name) {
return False;
}
pstrcpy(path, resolved_name);
return True;
#endif
}
BOOL reduce_name(connection_struct *conn, const pstring fname)
{
#ifdef REALPATH_TAKES_NULL
BOOL free_resolved_name = True;
#else
#ifdef PATH_MAX
char resolved_name_buf[PATH_MAX+1];
#else
pstring resolved_name_buf;
#endif
BOOL free_resolved_name = False;
#endif
char *resolved_name = NULL;
size_t con_path_len = strlen(conn->connectpath);
char *p = NULL;
int saved_errno = errno;
DEBUG(3,("reduce_name [%s] [%s]\n", fname, conn->connectpath));
#ifdef REALPATH_TAKES_NULL
resolved_name = SMB_VFS_REALPATH(conn,fname,NULL);
#else
resolved_name = SMB_VFS_REALPATH(conn,fname,resolved_name_buf);
#endif
if (!resolved_name) {
switch (errno) {
case ENOTDIR:
DEBUG(3,("reduce_name: Component not a directory in getting realpath for %s\n", fname));
errno = saved_errno;
return False;
case ENOENT:
{
pstring tmp_fname;
fstring last_component;
pstrcpy(tmp_fname, fname);
p = strrchr_m(tmp_fname, '/');
if (p) {
*p++ = '\0';
fstrcpy(last_component, p);
} else {
fstrcpy(last_component, tmp_fname);
pstrcpy(tmp_fname, ".");
}
#ifdef REALPATH_TAKES_NULL
resolved_name = SMB_VFS_REALPATH(conn,tmp_fname,NULL);
#else
resolved_name = SMB_VFS_REALPATH(conn,tmp_fname,resolved_name_buf);
#endif
if (!resolved_name) {
DEBUG(3,("reduce_name: couldn't get realpath for %s\n", fname));
errno = saved_errno;
return False;
}
pstrcpy(tmp_fname, resolved_name);
pstrcat(tmp_fname, "/");
pstrcat(tmp_fname, last_component);
#ifdef REALPATH_TAKES_NULL
SAFE_FREE(resolved_name);
resolved_name = SMB_STRDUP(tmp_fname);
if (!resolved_name) {
DEBUG(0,("reduce_name: malloc fail for %s\n", tmp_fname));
errno = saved_errno;
return False;
}
#else
#ifdef PATH_MAX
safe_strcpy(resolved_name_buf, tmp_fname, PATH_MAX);
#else
pstrcpy(pstring resolved_name_buf, tmp_fname);
#endif
resolved_name = resolved_name_buf;
#endif
break;
}
default:
DEBUG(1,("reduce_name: couldn't get realpath for %s\n", fname));
errno = saved_errno;
return False;
}
}
DEBUG(10,("reduce_name realpath [%s] -> [%s]\n", fname, resolved_name));
if (*resolved_name != '/') {
DEBUG(0,("reduce_name: realpath doesn't return absolute paths !\n"));
if (free_resolved_name)
SAFE_FREE(resolved_name);
errno = saved_errno;
return False;
}
if (!lp_widelinks(SNUM(conn)) && (strncmp(conn->connectpath, resolved_name, con_path_len) != 0)) {
DEBUG(2, ("reduce_name: Bad access attempt: %s is a symlink outside the share path", fname));
if (free_resolved_name)
SAFE_FREE(resolved_name);
errno = EACCES;
return False;
}
#ifdef S_ISLNK
if (!lp_symlinks(SNUM(conn))) {
SMB_STRUCT_STAT statbuf;
if ( (SMB_VFS_LSTAT(conn,fname,&statbuf) != -1) &&
(S_ISLNK(statbuf.st_mode)) ) {
if (free_resolved_name)
SAFE_FREE(resolved_name);
DEBUG(3,("reduce_name: denied: file path name %s is a symlink\n",resolved_name));
errno = EACCES;
return False;
}
}
#endif
DEBUG(3,("reduce_name: %s reduced to %s\n", fname, p));
if (free_resolved_name)
SAFE_FREE(resolved_name);
errno = saved_errno;
return(True);
}