files_struct * fsp, int fd, void * data, size_t count, SMB_OFF_T offset) { if (g_readbuf) { prime_cache(handle, fsp, fd, offset, count); } return SMB_VFS_NEXT_PREAD(handle, fsp, fd, data, count, offset); } static vfs_op_tuple cprime_ops [] = { {SMB_VFS_OP(cprime_sendfile), SMB_VFS_OP_SENDFILE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cprime_pread), SMB_VFS_OP_PREAD, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cprime_read), SMB_VFS_OP_READ, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cprime_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; /* ------------------------------------------------------------------------- * Samba module initialisation entry point. * ------------------------------------------------------------------------- */
{ int ret = -1; ret = SMB_VFS_NEXT_FSTAT(handle, fsp, fd, sbuf); if (ret == 0) { if (S_ISDIR(sbuf->st_mode)) { sbuf->st_mode = S_IFDIR | S_IRWXU; } else { sbuf->st_mode = S_IRWXU; } sbuf->st_uid = current_user.ut.uid; sbuf->st_gid = current_user.ut.gid; } return ret; } /* VFS operations structure */ static vfs_op_tuple fake_perms_ops[] = { {SMB_VFS_OP(fake_perms_stat), SMB_VFS_OP_STAT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(fake_perms_fstat), SMB_VFS_OP_FSTAT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; NTSTATUS vfs_fake_perms_init(void); NTSTATUS vfs_fake_perms_init(void) { return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fake_perms", fake_perms_ops); }
{ uint32 num = 3; uint32 i; shadow_copy_data->num_volumes = num; if (labels) { shadow_copy_data->labels = (SHADOW_COPY_LABEL *)talloc_zero(shadow_copy_data->mem_ctx,(num)*sizeof(SHADOW_COPY_LABEL)); for (i=0;i<num;i++) { snprintf(shadow_copy_data->labels[i], sizeof(SHADOW_COPY_LABEL), "@GMT-2003.08.05-12.%02u.00",i); } } else { shadow_copy_data->labels = NULL; } return 0; } /* VFS operations structure */ static vfs_op_tuple shadow_copy_test_ops[] = { {SMB_VFS_OP(test_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; NTSTATUS init_module(void) { return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "shadow_copy_test", shadow_copy_test_ops); }
static int audit_open(vfs_handle_struct *handle, const char *fname, files_struct *fsp, int flags, mode_t mode); static int audit_close(vfs_handle_struct *handle, files_struct *fsp); static int audit_rename(vfs_handle_struct *handle, const char *oldname, const char *newname); static int audit_unlink(vfs_handle_struct *handle, const char *path); static int audit_chmod(vfs_handle_struct *handle, const char *path, mode_t mode); static int audit_chmod_acl(vfs_handle_struct *handle, const char *name, mode_t mode); static int audit_fchmod(vfs_handle_struct *handle, files_struct *fsp, mode_t mode); static int audit_fchmod_acl(vfs_handle_struct *handle, files_struct *fsp, mode_t mode); /* VFS operations */ static vfs_op_tuple audit_op_tuples[] = { /* Disk operations */ {SMB_VFS_OP(audit_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(audit_disconnect), SMB_VFS_OP_DISCONNECT, SMB_VFS_LAYER_LOGGER}, /* Directory operations */ {SMB_VFS_OP(audit_opendir), SMB_VFS_OP_OPENDIR, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(audit_mkdir), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(audit_rmdir), SMB_VFS_OP_RMDIR, SMB_VFS_LAYER_LOGGER}, /* File operations */ {SMB_VFS_OP(audit_open), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(audit_close), SMB_VFS_OP_CLOSE, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(audit_rename), SMB_VFS_OP_RENAME, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(audit_unlink), SMB_VFS_OP_UNLINK, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(audit_chmod), SMB_VFS_OP_CHMOD, SMB_VFS_LAYER_LOGGER},
static int greyhole_open(vfs_handle_struct *handle, const char *fname, files_struct *fsp, int flags, mode_t mode); static ssize_t greyhole_write(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t count); static ssize_t greyhole_pwrite(vfs_handle_struct *handle, files_struct *fsp, const void *data, size_t count, SMB_OFF_T offset); static ssize_t greyhole_recvfile(vfs_handle_struct *handle, int fromfd, files_struct *tofsp, SMB_OFF_T offset, size_t n); static int greyhole_aio_write(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_AIOCB *aiocb); static int greyhole_close(vfs_handle_struct *handle, files_struct *fsp); static int greyhole_rename(vfs_handle_struct *handle, const char *oldname, const char *newname); static int greyhole_unlink(vfs_handle_struct *handle, const char *path); /* VFS operations */ static vfs_op_tuple greyhole_op_tuples[] = { /* Disk operations */ {SMB_VFS_OP(greyhole_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_LOGGER}, /* Directory operations */ {SMB_VFS_OP(greyhole_mkdir), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(greyhole_rmdir), SMB_VFS_OP_RMDIR, SMB_VFS_LAYER_LOGGER}, /* File operations */ {SMB_VFS_OP(greyhole_open), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(greyhole_write), SMB_VFS_OP_WRITE, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(greyhole_pwrite), SMB_VFS_OP_PWRITE, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(greyhole_recvfile), SMB_VFS_OP_RECVFILE, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(greyhole_aio_write), SMB_VFS_OP_AIO_WRITE, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(greyhole_close), SMB_VFS_OP_CLOSE, SMB_VFS_LAYER_LOGGER}, {SMB_VFS_OP(greyhole_rename), SMB_VFS_OP_RENAME, SMB_VFS_LAYER_LOGGER},
} handle->data = (void *)rhd; handle->free_data = free_readahead_data; return SMB_VFS_NEXT_CONNECT(handle, service, user); } /******************************************************************* Functions we're replacing. We don't replace read as it isn't used from smbd to read file data. *******************************************************************/ static vfs_op_tuple readahead_ops [] = { {SMB_VFS_OP(readahead_sendfile), SMB_VFS_OP_SENDFILE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(readahead_pread), SMB_VFS_OP_PREAD, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(readahead_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; /******************************************************************* Module initialization boilerplate. *******************************************************************/ NTSTATUS vfs_readahead_init(void); NTSTATUS vfs_readahead_init(void) { return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "readahead", readahead_ops); }
const char *user) { const char *spc; spc = lp_parm_const_string(SNUM(handle->conn), "afsacl", "space", "%"); if (spc != NULL) space_replacement = spc[0]; return SMB_VFS_NEXT_CONNECT(handle, service, user); } /* VFS operations structure */ static vfs_op_tuple afsacl_ops[] = { {SMB_VFS_OP(afsacl_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(afsacl_fget_nt_acl), SMB_VFS_OP_FGET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(afsacl_get_nt_acl), SMB_VFS_OP_GET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(afsacl_fset_nt_acl), SMB_VFS_OP_FSET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(afsacl_set_nt_acl), SMB_VFS_OP_SET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; NTSTATUS vfs_afsacl_init(void); NTSTATUS vfs_afsacl_init(void) {
DEBUG(3, ("ATALK: %s has passed..\n", orig_path)); goto exit_chown; } chown(adbl_path, uid, gid); exit_chown: talloc_destroy(ctx); return ret; } static vfs_op_tuple atalk_ops[] = { /* Directory operations */ {SMB_VFS_OP(atalk_opendir), SMB_VFS_OP_OPENDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(atalk_rmdir), SMB_VFS_OP_RMDIR, SMB_VFS_LAYER_TRANSPARENT}, /* File operations */ {SMB_VFS_OP(atalk_rename), SMB_VFS_OP_RENAME, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(atalk_unlink), SMB_VFS_OP_UNLINK, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(atalk_chmod), SMB_VFS_OP_CHMOD, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(atalk_chown), SMB_VFS_OP_CHOWN, SMB_VFS_LAYER_TRANSPARENT}, /* Finish VFS operations definition */ {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; NTSTATUS vfs_netatalk_init(void)
#define ALLOC_CHECK(ptr, label) do { if ((ptr) == NULL) { DEBUG(0, ("recycle.bin: out of memory!\n")); errno = ENOMEM; goto label; } } while(0) static int vfs_recycle_debug_level = DBGC_VFS; #undef DBGC_CLASS #define DBGC_CLASS vfs_recycle_debug_level static int recycle_connect(vfs_handle_struct *handle, const char *service, const char *user); static void recycle_disconnect(vfs_handle_struct *handle); static int recycle_unlink(vfs_handle_struct *handle, const char *name); static vfs_op_tuple recycle_ops[] = { /* Disk operations */ {SMB_VFS_OP(recycle_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(recycle_disconnect), SMB_VFS_OP_DISCONNECT, SMB_VFS_LAYER_TRANSPARENT}, /* File operations */ {SMB_VFS_OP(recycle_unlink), SMB_VFS_OP_UNLINK, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; static int recycle_connect(vfs_handle_struct *handle, const char *service, const char *user) { DEBUG(10,("recycle_connect() connect to service[%s] as user[%s].\n", service,user)); return SMB_VFS_NEXT_CONNECT(handle, service, user); }
return -1; } snprintf(tlabels[shadow_copy_data->num_volumes++], sizeof(*tlabels), "%s",d->d_name); shadow_copy_data->labels = tlabels; } SMB_VFS_NEXT_CLOSEDIR(handle,fsp->conn,p); return 0; } /* VFS operations structure */ static vfs_op_tuple shadow_copy_ops[] = { {SMB_VFS_OP(shadow_copy_opendir), SMB_VFS_OP_OPENDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(shadow_copy_readdir), SMB_VFS_OP_READDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(shadow_copy_closedir), SMB_VFS_OP_CLOSEDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(shadow_copy_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; NTSTATUS vfs_shadow_copy_init(void) { NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "shadow_copy", shadow_copy_ops); if (!NT_STATUS_IS_OK(ret)) return ret;
} static int cap_fsetxattr(vfs_handle_struct *handle, struct files_struct *fsp,int fd, const char *name, const void *value, size_t size, int flags) { pstring capname; capencode(capname, name); return SMB_VFS_NEXT_FSETXATTR(handle, fsp, fd, capname, value, size, flags); } /* VFS operations structure */ static vfs_op_tuple cap_op_tuples[] = { /* Disk operations */ {SMB_VFS_OP(cap_disk_free), SMB_VFS_OP_DISK_FREE, SMB_VFS_LAYER_TRANSPARENT}, /* Directory operations */ {SMB_VFS_OP(cap_opendir), SMB_VFS_OP_OPENDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cap_readdir), SMB_VFS_OP_READDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cap_mkdir), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cap_rmdir), SMB_VFS_OP_RMDIR, SMB_VFS_LAYER_TRANSPARENT}, /* File operations */ {SMB_VFS_OP(cap_open), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cap_rename), SMB_VFS_OP_RENAME, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cap_stat), SMB_VFS_OP_STAT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cap_lstat), SMB_VFS_OP_LSTAT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(cap_unlink), SMB_VFS_OP_UNLINK, SMB_VFS_LAYER_TRANSPARENT},
DEBUGADD(10, (" * id: %d\n", solaris_acl[check_which].a_id)); DEBUGADD(10, (" * perm: 0o%o\n", solaris_acl[check_which].a_perm)); } return False; } return True; } /* VFS operations structure */ static vfs_op_tuple solarisacl_op_tuples[] = { /* Disk operations */ {SMB_VFS_OP(solarisacl_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(solarisacl_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(solarisacl_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(solarisacl_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD, SMB_VFS_LAYER_TRANSPARENT},
} static uint32_t onefs_fs_capabilities(struct vfs_handle_struct *handle) { uint32_t result = 0; if (!lp_parm_bool(SNUM(handle->conn), PARM_ONEFS_TYPE, PARM_IGNORE_STREAMS, PARM_IGNORE_STREAMS_DEFAULT)) { result |= FILE_NAMED_STREAMS; } return result | SMB_VFS_NEXT_FS_CAPABILITIES(handle); } static vfs_op_tuple onefs_ops[] = { {SMB_VFS_OP(onefs_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(onefs_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(onefs_opendir), SMB_VFS_OP_OPENDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(onefs_readdir), SMB_VFS_OP_READDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(onefs_seekdir), SMB_VFS_OP_SEEKDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(onefs_telldir), SMB_VFS_OP_TELLDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(onefs_rewinddir), SMB_VFS_OP_REWINDDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(onefs_mkdir), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_OPAQUE},
SMB_OFF_T *psize; int ret = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, fd, offset); /* Maintain the allocated space even in the face of truncates. If the * truncate succeeded, we know that the current file size is the size * the caller requested. */ if (ret == 0 ) { if ((psize = VFS_FETCH_FSP_EXTENSION(handle, fsp))) { preallocate_space(fd, offset, *psize); } } return ret; } static vfs_op_tuple prealloc_op_tuples[] = { {SMB_VFS_OP(prealloc_open), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(prealloc_ftruncate), SMB_VFS_OP_FTRUNCATE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(prealloc_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT}, {NULL, SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; NTSTATUS vfs_prealloc_init(void); NTSTATUS vfs_prealloc_init(void) { return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, MODULE, prealloc_op_tuples); }
ret = SMB_VFS_NEXT_SYS_ACL_SET_FD(handle, fsp, theacl); if (ret == -1) { return -1; } acl_tdb_delete(handle, db, &sbuf); return 0; } /* VFS operations structure */ static vfs_op_tuple skel_op_tuples[] = { {SMB_VFS_OP(connect_acl_tdb), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(mkdir_acl_tdb), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(rmdir_acl_tdb), SMB_VFS_OP_RMDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(open_acl_tdb), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(unlink_acl_tdb), SMB_VFS_OP_UNLINK, SMB_VFS_LAYER_TRANSPARENT}, /* NT File ACL operations */ {SMB_VFS_OP(fget_nt_acl_tdb),SMB_VFS_OP_FGET_NT_ACL,SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(get_nt_acl_tdb), SMB_VFS_OP_GET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(fset_nt_acl_tdb),SMB_VFS_OP_FSET_NT_ACL,SMB_VFS_LAYER_TRANSPARENT}, /* POSIX ACL operations. */ {SMB_VFS_OP(sys_acl_set_file_tdb), SMB_VFS_OP_SYS_ACL_SET_FILE, SMB_VFS_LAYER_TRANSPARENT},
DEBUG(1,("tsmsm_set_offline: Running [%s] returned %d\n", command, result)); } TALLOC_FREE(command); return result; } static uint32_t tsmsm_fs_capabilities(struct vfs_handle_struct *handle) { return SMB_VFS_NEXT_FS_CAPABILITIES(handle) | FILE_SUPPORTS_REMOTE_STORAGE | FILE_SUPPORTS_REPARSE_POINTS; } static vfs_op_tuple vfs_tsmsm_ops[] = { /* Disk operations */ {SMB_VFS_OP(tsmsm_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(tsmsm_fs_capabilities), SMB_VFS_OP_FS_CAPABILITIES, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(tsmsm_aio_force), SMB_VFS_OP_AIO_FORCE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(tsmsm_aio_return), SMB_VFS_OP_AIO_RETURN, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(tsmsm_pread), SMB_VFS_OP_PREAD, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(tsmsm_pwrite), SMB_VFS_OP_PWRITE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(tsmsm_sendfile), SMB_VFS_OP_SENDFILE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(tsmsm_is_offline), SMB_VFS_OP_IS_OFFLINE, SMB_VFS_LAYER_OPAQUE},
return result; target[result] = '\0'; if ((strncmp(target, "msdfs:", strlen("msdfs:")) == 0) && (strchr_m(target, '@') != NULL)) { if (!expand_msdfs_target(conn, target)) { errno = ENOENT; return -1; } } safe_strcpy(buf, target, bufsiz-1); return strlen(buf); } /* VFS operations structure */ static vfs_op_tuple expand_msdfs_ops[] = { { SMB_VFS_OP(expand_msdfs_readlink), SMB_VFS_OP_READLINK, SMB_VFS_LAYER_TRANSPARENT }, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; NTSTATUS vfs_expand_msdfs_init(void) { return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "expand_msdfs", expand_msdfs_ops); }
if (ret == -1) { return -1; } become_root(); SMB_VFS_FREMOVEXATTR(fsp, XATTR_NTACL_NAME); unbecome_root(); return ret; } /* VFS operations structure */ static vfs_op_tuple skel_op_tuples[] = { {SMB_VFS_OP(mkdir_acl_xattr), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(open_acl_xattr), SMB_VFS_OP_OPEN, SMB_VFS_LAYER_TRANSPARENT}, /* NT File ACL operations */ {SMB_VFS_OP(fget_nt_acl_xattr),SMB_VFS_OP_FGET_NT_ACL,SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(get_nt_acl_xattr), SMB_VFS_OP_GET_NT_ACL, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(fset_nt_acl_xattr),SMB_VFS_OP_FSET_NT_ACL,SMB_VFS_LAYER_TRANSPARENT}, /* POSIX ACL operations. */ {SMB_VFS_OP(sys_acl_set_file_xattr), SMB_VFS_OP_SYS_ACL_SET_FILE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(sys_acl_set_fd_xattr), SMB_VFS_OP_SYS_ACL_SET_FD, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} };
DEBUG(10,("Exiting aixacl_sys_acl_set_fd\n")); return rc; } int aixacl_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path) { return 0; /* otherwise you can't set acl at upper level */ } /* VFS operations structure */ static vfs_op_tuple aixacl_op_tuples[] = { /* Disk operations */ {SMB_VFS_OP(aixacl_sys_acl_get_file), SMB_VFS_OP_SYS_ACL_GET_FILE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(aixacl_sys_acl_get_fd), SMB_VFS_OP_SYS_ACL_GET_FD, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(aixacl_sys_acl_set_file), SMB_VFS_OP_SYS_ACL_SET_FILE, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(aixacl_sys_acl_set_fd), SMB_VFS_OP_SYS_ACL_SET_FD, SMB_VFS_LAYER_TRANSPARENT},
{ return vfswrap_is_offline(NULL, path, sbuf); } static int skel_set_offline(struct vfs_handle_struct *handle, const char *path) { return vfswrap_set_offline(NULL, path); } /* VFS operations structure */ static vfs_op_tuple skel_op_tuples[] = { /* Disk operations */ {SMB_VFS_OP(skel_connect), SMB_VFS_OP_CONNECT, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_disconnect), SMB_VFS_OP_DISCONNECT, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_disk_free), SMB_VFS_OP_DISK_FREE, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_get_quota), SMB_VFS_OP_GET_QUOTA, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_set_quota), SMB_VFS_OP_SET_QUOTA, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_get_shadow_copy_data), SMB_VFS_OP_GET_SHADOW_COPY_DATA,SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_statvfs), SMB_VFS_OP_STATVFS, SMB_VFS_LAYER_OPAQUE}, /* Directory operations */ {SMB_VFS_OP(skel_opendir), SMB_VFS_OP_OPENDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_readdir), SMB_VFS_OP_READDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_seekdir), SMB_VFS_OP_SEEKDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_telldir), SMB_VFS_OP_TELLDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_rewinddir), SMB_VFS_OP_REWINDDIR, SMB_VFS_LAYER_OPAQUE}, {SMB_VFS_OP(skel_mkdir), SMB_VFS_OP_MKDIR, SMB_VFS_LAYER_OPAQUE},
static void dirsort_rewinddir(vfs_handle_struct *handle, SMB_STRUCT_DIR *dirp) { struct dirsort_privates *data = NULL; SMB_VFS_HANDLE_GET_DATA(handle, data, struct dirsort_privates, return); data->pos = 0; } /* VFS operations structure */ static vfs_op_tuple dirsort_op_tuples[] = { /* Directory operations */ {SMB_VFS_OP(dirsort_opendir), SMB_VFS_OP_OPENDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(dirsort_readdir), SMB_VFS_OP_READDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(dirsort_seekdir), SMB_VFS_OP_SEEKDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(dirsort_telldir), SMB_VFS_OP_TELLDIR, SMB_VFS_LAYER_TRANSPARENT}, {SMB_VFS_OP(dirsort_rewinddir), SMB_VFS_OP_REWINDDIR, SMB_VFS_LAYER_TRANSPARENT}, {NULL, SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP} }; NTSTATUS vfs_dirsort_init(void)