#include "nfs4_acls.h"
#include "vfs_gpfs.h"
+struct gpfs_config_data {
+ bool sharemodes;
+ bool leases;
+};
+
+
static int vfs_gpfs_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
- uint32 share_mode)
+ uint32 share_mode, uint32 access_mask)
{
- START_PROFILE(syscall_kernel_flock);
+ struct gpfs_config_data *config;
+
+ SMB_VFS_HANDLE_GET_DATA(handle, config,
+ struct gpfs_config_data,
+ return -1);
- kernel_flock(fsp->fh->fd, share_mode);
+ START_PROFILE(syscall_kernel_flock);
- if (!set_gpfs_sharemode(fsp, fsp->access_mask, fsp->share_access)) {
+ kernel_flock(fsp->fh->fd, share_mode, access_mask);
+ if (config->sharemodes
+ && !set_gpfs_sharemode(fsp, access_mask, fsp->share_access)) {
return -1;
-
}
END_PROFILE(syscall_kernel_flock);
static int vfs_gpfs_close(vfs_handle_struct *handle, files_struct *fsp)
{
- if ((fsp->fh != NULL) && (fsp->fh->fd != -1)) {
+
+ struct gpfs_config_data *config;
+
+ SMB_VFS_HANDLE_GET_DATA(handle, config,
+ struct gpfs_config_data,
+ return -1);
+
+ if (config->sharemodes && (fsp->fh != NULL) && (fsp->fh->fd != -1)) {
set_gpfs_sharemode(fsp, 0, 0);
}
static int vfs_gpfs_setlease(vfs_handle_struct *handle, files_struct *fsp,
int leasetype)
{
- int ret;
+ struct gpfs_config_data *config;
+ int ret=0;
+
+ SMB_VFS_HANDLE_GET_DATA(handle, config,
+ struct gpfs_config_data,
+ return -1);
START_PROFILE(syscall_linux_setlease);
- if ( linux_set_lease_sighandler(fsp->fh->fd) == -1)
+ if (linux_set_lease_sighandler(fsp->fh->fd) == -1)
return -1;
- ret = set_gpfs_lease(fsp->fh->fd,leasetype);
+ if (config->leases) {
+ ret = set_gpfs_lease(fsp->fh->fd,leasetype);
+ }
- if ( ret < 0 ) {
+ if (ret < 0) {
/* This must have come from GPFS not being available */
/* or some other error, hence call the default */
ret = linux_setlease(fsp->fh->fd, leasetype);
int result;
*ppdesc = NULL;
- result = gpfs_get_nfs4_acl(fsp->fsp_name, &pacl);
+ result = gpfs_get_nfs4_acl(fsp->fsp_name->base_name, &pacl);
if (result == 0)
return smb_fget_nt_acl_nfs4(fsp, security_info, ppdesc, pacl);
"merge_writeappend", True)) {
DEBUG(2, ("vfs_gpfs.c: file [%s]: ACE contains "
"WRITE^APPEND, setting WRITE|APPEND\n",
- fsp->fsp_name));
+ fsp_str_dbg(fsp)));
gace->aceMask |= ACE4_MASK_WRITE|ACE4_MASK_APPEND;
}
gacl->acl_nace++;
}
- ret = smbd_gpfs_putacl(fsp->fsp_name, GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gacl);
+ ret = smbd_gpfs_putacl(fsp->fsp_name->base_name,
+ GPFS_PUTACL_STRUCT | GPFS_ACL_SAMBA, gacl);
if (ret != 0) {
DEBUG(8, ("gpfs_putacl failed with %s\n", strerror(errno)));
gpfs_dumpacl(8, gacl);
struct gpfs_acl *acl;
NTSTATUS result = NT_STATUS_ACCESS_DENIED;
- acl = gpfs_getacl_alloc(fsp->fsp_name, 0);
+ acl = gpfs_getacl_alloc(fsp->fsp_name->base_name, 0);
if (acl == NULL)
return result;
if (acl->acl_version&GPFS_ACL_VERSION_NFS4)
{
+ if (lp_parm_bool(fsp->conn->params->service, "gpfs",
+ "refuse_dacl_protected", false)
+ && (psd->type&SEC_DESC_DACL_PROTECTED)) {
+ DEBUG(2, ("Rejecting unsupported ACL with DACL_PROTECTED bit set\n"));
+ return NT_STATUS_NOT_SUPPORTED;
+ }
+
result = smb_set_nt_acl_nfs4(
fsp, security_info_sent, psd,
gpfsacl_process_smbacl);
pacl->acl_nace));
result = gpfs2smb_acl(pacl);
- if (result == NULL) {
- goto done;
+ if (result != NULL) {
+ errno = 0;
}
done:
static SMB_ACL_T gpfsacl_sys_acl_get_fd(vfs_handle_struct *handle,
files_struct *fsp)
{
- return gpfsacl_get_posix_acl(fsp->fsp_name, GPFS_ACL_TYPE_ACCESS);
+ return gpfsacl_get_posix_acl(fsp->fsp_name->base_name,
+ GPFS_ACL_TYPE_ACCESS);
}
static struct gpfs_acl *smb2gpfs_acl(const SMB_ACL_T pacl,
files_struct *fsp,
SMB_ACL_T theacl)
{
- return gpfsacl_sys_acl_set_file(handle, fsp->fsp_name, SMB_ACL_TYPE_ACCESS, theacl);
+ return gpfsacl_sys_acl_set_file(handle, fsp->fsp_name->base_name,
+ SMB_ACL_TYPE_ACCESS, theacl);
}
static int gpfsacl_sys_acl_delete_def_file(vfs_handle_struct *handle,
int i;
files_struct fake_fsp; /* TODO: rationalize parametrization */
SMB4ACE_T *smbace;
+ NTSTATUS status;
DEBUG(10, ("gpfsacl_emu_chmod invoked for %s mode %o\n", path, mode));
/* don't add complementary DENY ACEs here */
ZERO_STRUCT(fake_fsp);
- fake_fsp.fsp_name = (char *)path; /* no file_new is needed here */
-
+ status = create_synthetic_smb_fname(talloc_tos(), path, NULL, NULL,
+ &fake_fsp.fsp_name);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
/* put the acl */
- if (gpfsacl_process_smbacl(&fake_fsp, pacl) == False)
+ if (gpfsacl_process_smbacl(&fake_fsp, pacl) == False) {
+ TALLOC_FREE(fake_fsp.fsp_name);
return -1;
+ }
+
+ TALLOC_FREE(fake_fsp.fsp_name);
return 0; /* ok for [f]chmod */
}
static int vfs_gpfs_chmod(vfs_handle_struct *handle, const char *path, mode_t mode)
{
- SMB_STRUCT_STAT st;
- int rc;
+ struct smb_filename *smb_fname_cpath;
+ int rc;
+ NTSTATUS status;
- if (SMB_VFS_NEXT_STAT(handle, path, &st) != 0) {
- return -1;
- }
+ status = create_synthetic_smb_fname(
+ talloc_tos(), path, NULL, NULL, &smb_fname_cpath);
- /* avoid chmod() if possible, to preserve acls */
- if ((st.st_ex_mode & ~S_IFMT) == mode) {
- return 0;
- }
+ if (SMB_VFS_NEXT_STAT(handle, smb_fname_cpath) != 0) {
+ return -1;
+ }
- rc = gpfsacl_emu_chmod(path, mode);
- if (rc == 1)
- return SMB_VFS_NEXT_CHMOD(handle, path, mode);
- return rc;
+ /* avoid chmod() if possible, to preserve acls */
+ if ((smb_fname_cpath->st.st_ex_mode & ~S_IFMT) == mode) {
+ return 0;
+ }
+
+ rc = gpfsacl_emu_chmod(path, mode);
+ if (rc == 1)
+ return SMB_VFS_NEXT_CHMOD(handle, path, mode);
+ return rc;
}
static int vfs_gpfs_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode)
return 0;
}
- rc = gpfsacl_emu_chmod(fsp->fsp_name, mode);
+ rc = gpfsacl_emu_chmod(fsp->fsp_name->base_name, mode);
if (rc == 1)
return SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
return rc;
ret = set_gpfs_winattrs(CONST_DISCARD(char *, path),
GPFS_WINATTR_SET_ATTRS, &attrs);
if ( ret == -1){
+ if (errno == ENOSYS) {
+ return SMB_VFS_NEXT_SETXATTR(handle, path, name, value,
+ size, flags);
+ }
+
DEBUG(1, ("gpfs_set_xattr:Set GPFS attributes failed %d\n",ret));
return -1;
}
return 0;
}
-static size_t gpfs_get_xattr(struct vfs_handle_struct *handle, const char *path,
+static ssize_t gpfs_get_xattr(struct vfs_handle_struct *handle, const char *path,
const char *name, void *value, size_t size){
char *attrstr = value;
unsigned int dosmode = 0;
struct gpfs_winattr attrs;
int ret = 0;
+ ssize_t result;
DEBUG(10, ("gpfs_get_xattr: %s \n",path));
ret = get_gpfs_winattrs(CONST_DISCARD(char *, path), &attrs);
if ( ret == -1){
+ if (errno == ENOSYS) {
+ return SMB_VFS_NEXT_GETXATTR(handle, path, name, value,
+ size);
+ }
+
DEBUG(1, ("gpfs_get_xattr: Get GPFS attributes failed: %d\n",ret));
return -1;
}
dosmode |= FILE_ATTRIBUTE_READONLY;
}
- snprintf(attrstr, size, "0x%x", dosmode & SAMBA_ATTRIBUTES_MASK);
+ result = snprintf(attrstr, size, "0x%x",
+ dosmode & SAMBA_ATTRIBUTES_MASK) + 1;
+
DEBUG(10, ("gpfs_get_xattr: returning %s\n",attrstr));
- return size;
+ return result;
}
-static int vfs_gpfs_stat(struct vfs_handle_struct *handle, const char *fname,
- SMB_STRUCT_STAT *sbuf)
+static int vfs_gpfs_stat(struct vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
{
struct gpfs_winattr attrs;
+ char *fname = NULL;
+ NTSTATUS status;
int ret;
- ret = SMB_VFS_NEXT_STAT(handle, fname, sbuf);
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
if (ret == -1) {
return -1;
}
+ status = get_full_smb_filename(talloc_tos(), smb_fname, &fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
ret = get_gpfs_winattrs(CONST_DISCARD(char *, fname), &attrs);
+ TALLOC_FREE(fname);
if (ret == 0) {
- sbuf->st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
- sbuf->st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
+ smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
+ smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
}
return 0;
}
return 0;
}
-static int vfs_gpfs_lstat(struct vfs_handle_struct *handle, const char *path,
- SMB_STRUCT_STAT *sbuf)
+static int vfs_gpfs_lstat(struct vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
{
struct gpfs_winattr attrs;
+ char *path = NULL;
+ NTSTATUS status;
int ret;
- ret = SMB_VFS_NEXT_LSTAT(handle, path, sbuf);
+ ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
if (ret == -1) {
return -1;
}
+ status = get_full_smb_filename(talloc_tos(), smb_fname, &path);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
ret = get_gpfs_winattrs(CONST_DISCARD(char *, path), &attrs);
+ TALLOC_FREE(path);
if (ret == 0) {
- sbuf->st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
- sbuf->st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
+ smb_fname->st.st_ex_btime.tv_sec = attrs.creationTime.tv_sec;
+ smb_fname->st.st_ex_btime.tv_nsec = attrs.creationTime.tv_nsec;
}
return 0;
}
-/* VFS operations structure */
-
-static vfs_op_tuple gpfs_op_tuples[] = {
-
- { SMB_VFS_OP(vfs_gpfs_kernel_flock),
- SMB_VFS_OP_KERNEL_FLOCK,
- SMB_VFS_LAYER_OPAQUE },
-
- { SMB_VFS_OP(vfs_gpfs_setlease),
- SMB_VFS_OP_LINUX_SETLEASE,
- SMB_VFS_LAYER_OPAQUE },
-
- { SMB_VFS_OP(vfs_gpfs_get_real_filename),
- SMB_VFS_OP_GET_REAL_FILENAME,
- SMB_VFS_LAYER_OPAQUE },
+static int vfs_gpfs_ntimes(struct vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
+ struct smb_file_time *ft)
+{
- { SMB_VFS_OP(gpfsacl_fget_nt_acl),
- SMB_VFS_OP_FGET_NT_ACL,
- SMB_VFS_LAYER_TRANSPARENT },
+ struct gpfs_winattr attrs;
+ int ret;
+ char *path = NULL;
+ NTSTATUS status;
- { SMB_VFS_OP(gpfsacl_get_nt_acl),
- SMB_VFS_OP_GET_NT_ACL,
- SMB_VFS_LAYER_TRANSPARENT },
+ ret = SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
+ if(ret == -1){
+ DEBUG(1,("vfs_gpfs_ntimes: SMB_VFS_NEXT_NTIMES failed\n"));
+ return -1;
+ }
- { SMB_VFS_OP(gpfsacl_fset_nt_acl),
- SMB_VFS_OP_FSET_NT_ACL,
- SMB_VFS_LAYER_TRANSPARENT },
+ if(null_timespec(ft->create_time)){
+ DEBUG(10,("vfs_gpfs_ntimes:Create Time is NULL\n"));
+ return 0;
+ }
- { SMB_VFS_OP(gpfsacl_sys_acl_get_file),
- SMB_VFS_OP_SYS_ACL_GET_FILE,
- SMB_VFS_LAYER_TRANSPARENT },
+ status = get_full_smb_filename(talloc_tos(), smb_fname, &path);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
- { SMB_VFS_OP(gpfsacl_sys_acl_get_fd),
- SMB_VFS_OP_SYS_ACL_GET_FD,
- SMB_VFS_LAYER_TRANSPARENT },
+ attrs.winAttrs = 0;
+ attrs.creationTime.tv_sec = ft->create_time.tv_sec;
+ attrs.creationTime.tv_nsec = ft->create_time.tv_nsec;
- { SMB_VFS_OP(gpfsacl_sys_acl_set_file),
- SMB_VFS_OP_SYS_ACL_SET_FILE,
- SMB_VFS_LAYER_TRANSPARENT },
+ ret = set_gpfs_winattrs(CONST_DISCARD(char *, path),
+ GPFS_WINATTR_SET_CREATION_TIME, &attrs);
+ if(ret == -1 && errno != ENOSYS){
+ DEBUG(1,("vfs_gpfs_ntimes: set GPFS ntimes failed %d\n",ret));
+ return -1;
+ }
+ return 0;
- { SMB_VFS_OP(gpfsacl_sys_acl_set_fd),
- SMB_VFS_OP_SYS_ACL_SET_FD,
- SMB_VFS_LAYER_TRANSPARENT },
+}
- { SMB_VFS_OP(gpfsacl_sys_acl_delete_def_file),
- SMB_VFS_OP_SYS_ACL_DELETE_DEF_FILE,
- SMB_VFS_LAYER_TRANSPARENT },
+int vfs_gpfs_connect(struct vfs_handle_struct *handle, const char *service,
+ const char *user)
+{
+ struct gpfs_config_data *config;
+ int ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
- { SMB_VFS_OP(vfs_gpfs_chmod),
- SMB_VFS_OP_CHMOD,
- SMB_VFS_LAYER_TRANSPARENT },
+ if (ret < 0) {
+ return ret;
+ }
- { SMB_VFS_OP(vfs_gpfs_fchmod),
- SMB_VFS_OP_FCHMOD,
- SMB_VFS_LAYER_TRANSPARENT },
+ config = talloc_zero(handle->conn, struct gpfs_config_data);
+ if (!config) {
+ SMB_VFS_NEXT_DISCONNECT(handle);
+ DEBUG(0, ("talloc_zero() failed\n")); return -1;
+ }
- { SMB_VFS_OP(vfs_gpfs_close),
- SMB_VFS_OP_CLOSE,
- SMB_VFS_LAYER_TRANSPARENT },
+ config->sharemodes = lp_parm_bool(SNUM(handle->conn), "gpfs",
+ "sharemodes", true);
- { SMB_VFS_OP(gpfs_set_xattr),
- SMB_VFS_OP_SETXATTR,
- SMB_VFS_LAYER_TRANSPARENT },
+ config->leases = lp_parm_bool(SNUM(handle->conn), "gpfs",
+ "leases", true);
- { SMB_VFS_OP(gpfs_get_xattr),
- SMB_VFS_OP_GETXATTR,
- SMB_VFS_LAYER_TRANSPARENT },
+ SMB_VFS_HANDLE_SET_DATA(handle, config,
+ NULL, struct gpfs_config_data,
+ return -1);
- { SMB_VFS_OP(vfs_gpfs_stat),
- SMB_VFS_OP_STAT,
- SMB_VFS_LAYER_TRANSPARENT },
+ return 0;
+}
- { SMB_VFS_OP(vfs_gpfs_fstat),
- SMB_VFS_OP_FSTAT,
- SMB_VFS_LAYER_TRANSPARENT },
- { SMB_VFS_OP(vfs_gpfs_lstat),
- SMB_VFS_OP_LSTAT,
- SMB_VFS_LAYER_TRANSPARENT },
+static int vfs_gpfs_ftruncate(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ SMB_OFF_T len)
+{
+ int result;
- { SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP }
+ result = smbd_gpfs_ftrunctate(fsp->fh->fd, len);
+ if ((result == -1) && (errno == ENOSYS)) {
+ return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, len);
+ }
+ return result;
+}
+static struct vfs_fn_pointers vfs_gpfs_fns = {
+ .connect_fn = vfs_gpfs_connect,
+ .kernel_flock = vfs_gpfs_kernel_flock,
+ .linux_setlease = vfs_gpfs_setlease,
+ .get_real_filename = vfs_gpfs_get_real_filename,
+ .fget_nt_acl = gpfsacl_fget_nt_acl,
+ .get_nt_acl = gpfsacl_get_nt_acl,
+ .fset_nt_acl = gpfsacl_fset_nt_acl,
+ .sys_acl_get_file = gpfsacl_sys_acl_get_file,
+ .sys_acl_get_fd = gpfsacl_sys_acl_get_fd,
+ .sys_acl_set_file = gpfsacl_sys_acl_set_file,
+ .sys_acl_set_fd = gpfsacl_sys_acl_set_fd,
+ .sys_acl_delete_def_file = gpfsacl_sys_acl_delete_def_file,
+ .chmod = vfs_gpfs_chmod,
+ .fchmod = vfs_gpfs_fchmod,
+ .close_fn = vfs_gpfs_close,
+ .setxattr = gpfs_set_xattr,
+ .getxattr = gpfs_get_xattr,
+ .stat = vfs_gpfs_stat,
+ .fstat = vfs_gpfs_fstat,
+ .lstat = vfs_gpfs_lstat,
+ .ntimes = vfs_gpfs_ntimes,
+ .ftruncate = vfs_gpfs_ftruncate,
};
-
NTSTATUS vfs_gpfs_init(void);
NTSTATUS vfs_gpfs_init(void)
{
init_gpfs();
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "gpfs",
- gpfs_op_tuples);
+ &vfs_gpfs_fns);
}
git.samba.org / samba.git / blobdiff