#endif
int ret;
- SMB_ASSERT(dirfsp == dirfsp->conn->cwd_fsp);
-
if (is_named_stream(smb_fname)) {
status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
goto err;
}
}
- referral_len = readlinkat(fsp_get_io_fd(dirfsp),
+ referral_len = readlinkat(fsp_get_pathref_fd(dirfsp),
smb_fname->base_name,
link_target,
bufsize - 1);
status = NT_STATUS_OBJECT_TYPE_MISMATCH;
} else {
status = map_nt_error_from_unix(errno);
- DBG_ERR("Error reading "
- "msdfs link %s: %s\n",
- smb_fname->base_name,
- strerror(errno));
+ if (errno == ENOENT) {
+ DBG_NOTICE("Error reading "
+ "msdfs link %s: %s\n",
+ smb_fname->base_name,
+ strerror(errno));
+ } else {
+ DBG_ERR("Error reading "
+ "msdfs link %s: %s\n",
+ smb_fname->base_name,
+ strerror(errno));
+ }
}
goto err;
}
goto err;
}
- ret = sys_lstat(smb_fname->base_name,
- &smb_fname->st,
- lp_fake_directory_create_times(SNUM(handle->conn)));
+ ret = sys_fstatat(fsp_get_pathref_fd(dirfsp),
+ smb_fname->base_name,
+ &smb_fname->st,
+ AT_SYMLINK_NOFOLLOW,
+ lp_fake_directory_create_times(SNUM(handle->conn)));
if (ret < 0) {
status = map_nt_error_from_unix(errno);
goto err;
SMB_STRUCT_STAT *sbuf)
{
struct dirent *result;
- bool do_stat = false;
bool fake_ctime = lp_fake_directory_create_times(SNUM(handle->conn));
int flags = AT_SYMLINK_NOFOLLOW;
- struct stat st;
+ SMB_STRUCT_STAT st;
int ret;
START_PROFILE(syscall_readdir);
-#if defined(HAVE_DIRFD) && defined(HAVE_FSTATAT)
- do_stat = true;
-#endif
-
result = readdir(dirp);
END_PROFILE(syscall_readdir);
*/
SET_STAT_INVALID(*sbuf);
- /* See if we can efficiently return this. */
- if (!do_stat) {
- return result;
- }
-
- ret = fstatat(dirfd(dirp),
+ ret = sys_fstatat(dirfd(dirp),
result->d_name,
&st,
- flags);
+ flags,
+ fake_ctime);
if (ret != 0) {
return result;
}
* as we don't know if they wanted the link info, or its
* target info.
*/
- if (S_ISLNK(st.st_mode) &&
+ if (S_ISLNK(st.st_ex_mode) &&
!(dirfsp->fsp_name->flags & SMB_FILENAME_POSIX_PATH))
{
return result;
}
- init_stat_ex_from_stat(sbuf, &st, fake_ctime);
+ *sbuf = st;
return result;
}
return result;
}
+static int vfswrap_fstatat(
+ struct vfs_handle_struct *handle,
+ const struct files_struct *dirfsp,
+ const struct smb_filename *smb_fname,
+ SMB_STRUCT_STAT *sbuf,
+ int flags)
+{
+ int result = -1;
+
+ START_PROFILE(syscall_fstatat);
+
+ if (is_named_stream(smb_fname)) {
+ errno = ENOENT;
+ goto out;
+ }
+
+ result = sys_fstatat(
+ fsp_get_pathref_fd(dirfsp),
+ smb_fname->base_name,
+ sbuf,
+ flags,
+ lp_fake_directory_create_times(SNUM(handle->conn)));
+ out:
+ END_PROFILE(syscall_fstatat);
+ return result;
+}
+
static NTSTATUS vfswrap_translate_name(struct vfs_handle_struct *handle,
const char *name,
enum vfs_translate_direction direction,
/**
* Return allocated parent directory and basename of path
*
- * Note: if requesting name, it is returned as talloc child of the
+ * Note: if requesting atname, it is returned as talloc child of the
* parent. Freeing the parent is thus sufficient to free both.
*/
static NTSTATUS vfswrap_parent_pathname(struct vfs_handle_struct *handle,
struct smb_filename *name = NULL;
char *p = NULL;
- parent = cp_smb_filename(frame, smb_fname_in);
+ parent = cp_smb_filename_nostream(frame, smb_fname_in);
if (parent == NULL) {
TALLOC_FREE(frame);
return NT_STATUS_NO_MEMORY;
}
- TALLOC_FREE(parent->stream_name);
SET_STAT_INVALID(parent->st);
p = strrchr_m(parent->base_name, '/'); /* Find final '/', if any */
.smb_fname = smb_fname,
};
+ if (!lp_store_dos_attributes(SNUM(dir_fsp->conn))) {
+ DBG_ERR("%s: \"smbd async dosmode\" enabled, but "
+ "\"store dos attributes\" is disabled\n",
+ dir_fsp->conn->connectpath);
+ tevent_req_nterror(req, NT_STATUS_NOT_IMPLEMENTED);
+ return tevent_req_post(req, ev);
+ }
+
subreq = SMB_VFS_GETXATTRAT_SEND(state,
ev,
dir_fsp,
static NTSTATUS vfswrap_offload_read_recv(struct tevent_req *req,
struct vfs_handle_struct *handle,
TALLOC_CTX *mem_ctx,
+ uint32_t *flags,
+ uint64_t *xferlen,
DATA_BLOB *token)
{
struct vfswrap_offload_read_state *state = tevent_req_data(
return status;
}
+ *flags = 0;
+ *xferlen = 0;
token->length = state->token.length;
token->data = talloc_move(mem_ctx, &state->token.data);
off_t dst_off;
off_t to_copy;
off_t remaining;
+ off_t copied;
size_t next_io_size;
};
state->dst_fsp = NULL;
}
+static NTSTATUS vfswrap_offload_copy_file_range(struct tevent_req *req);
static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req);
static struct tevent_req *vfswrap_offload_write_send(
return tevent_req_post(req, ev);
}
+ status = vfswrap_offload_copy_file_range(req);
+ if (NT_STATUS_IS_OK(status)) {
+ tevent_req_done(req);
+ return tevent_req_post(req, ev);
+ }
+ if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
+ tevent_req_nterror(req, status);
+ return tevent_req_post(req, ev);
+ }
+
state->buf = talloc_array(state, uint8_t, num);
if (tevent_req_nomem(state->buf, req)) {
return tevent_req_post(req, ev);
return req;
}
+static NTSTATUS vfswrap_offload_copy_file_range(struct tevent_req *req)
+{
+ struct vfswrap_offload_write_state *state = tevent_req_data(
+ req, struct vfswrap_offload_write_state);
+ struct lock_struct lck;
+ ssize_t nwritten;
+ NTSTATUS status;
+ bool same_file;
+ bool ok;
+ static bool try_copy_file_range = true;
+
+ if (!try_copy_file_range) {
+ return NT_STATUS_MORE_PROCESSING_REQUIRED;
+ }
+
+ same_file = file_id_equal(&state->src_fsp->file_id,
+ &state->dst_fsp->file_id);
+ if (same_file &&
+ sys_io_ranges_overlap(state->remaining,
+ state->src_off,
+ state->remaining,
+ state->dst_off))
+ {
+ return NT_STATUS_MORE_PROCESSING_REQUIRED;
+ }
+
+ if (fsp_is_alternate_stream(state->src_fsp) ||
+ fsp_is_alternate_stream(state->dst_fsp))
+ {
+ return NT_STATUS_MORE_PROCESSING_REQUIRED;
+ }
+
+ init_strict_lock_struct(state->src_fsp,
+ state->src_fsp->op->global->open_persistent_id,
+ state->src_off,
+ state->remaining,
+ READ_LOCK,
+ lp_posix_cifsu_locktype(state->src_fsp),
+ &lck);
+
+ ok = SMB_VFS_STRICT_LOCK_CHECK(state->src_fsp->conn,
+ state->src_fsp,
+ &lck);
+ if (!ok) {
+ return NT_STATUS_FILE_LOCK_CONFLICT;
+ }
+
+ ok = change_to_user_and_service_by_fsp(state->dst_fsp);
+ if (!ok) {
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ init_strict_lock_struct(state->dst_fsp,
+ state->dst_fsp->op->global->open_persistent_id,
+ state->dst_off,
+ state->remaining,
+ WRITE_LOCK,
+ lp_posix_cifsu_locktype(state->dst_fsp),
+ &lck);
+
+ ok = SMB_VFS_STRICT_LOCK_CHECK(state->dst_fsp->conn,
+ state->dst_fsp,
+ &lck);
+ if (!ok) {
+ return NT_STATUS_FILE_LOCK_CONFLICT;
+ }
+
+ while (state->remaining > 0) {
+ nwritten = copy_file_range(fsp_get_io_fd(state->src_fsp),
+ &state->src_off,
+ fsp_get_io_fd(state->dst_fsp),
+ &state->dst_off,
+ state->remaining,
+ 0);
+ if (nwritten == -1) {
+ DBG_DEBUG("copy_file_range src [%s]:[%jd] dst [%s]:[%jd] "
+ "n [%jd] failed: %s\n",
+ fsp_str_dbg(state->src_fsp),
+ (intmax_t)state->src_off,
+ fsp_str_dbg(state->dst_fsp),
+ (intmax_t)state->dst_off,
+ (intmax_t)state->remaining,
+ strerror(errno));
+ switch (errno) {
+ case EOPNOTSUPP:
+ case ENOSYS:
+ try_copy_file_range = false;
+ status = NT_STATUS_MORE_PROCESSING_REQUIRED;
+ break;
+ case EXDEV:
+ status = NT_STATUS_MORE_PROCESSING_REQUIRED;
+ break;
+ default:
+ status = map_nt_error_from_unix(errno);
+ if (NT_STATUS_EQUAL(
+ status,
+ NT_STATUS_MORE_PROCESSING_REQUIRED))
+ {
+ /* Avoid triggering the fallback */
+ status = NT_STATUS_INTERNAL_ERROR;
+ }
+ break;
+ }
+ return status;
+ }
+
+ if (state->remaining < nwritten) {
+ DBG_DEBUG("copy_file_range src [%s] dst [%s] "
+ "n [%jd] remaining [%jd]\n",
+ fsp_str_dbg(state->src_fsp),
+ fsp_str_dbg(state->dst_fsp),
+ (intmax_t)nwritten,
+ (intmax_t)state->remaining);
+ return NT_STATUS_INTERNAL_ERROR;
+ }
+
+ if (nwritten == 0) {
+ break;
+ }
+ state->copied += nwritten;
+ state->remaining -= nwritten;
+ }
+
+ /*
+ * Tell the req cleanup function there's no need to call
+ * change_to_user_and_service_by_fsp() on the dst handle.
+ */
+ state->dst_fsp = NULL;
+ return NT_STATUS_OK;
+}
+
static void vfswrap_offload_write_read_done(struct tevent_req *subreq);
static NTSTATUS vfswrap_offload_write_loop(struct tevent_req *req)
state->src_off,
state->next_io_size,
READ_LOCK,
+ lp_posix_cifsu_locktype(state->src_fsp),
&read_lck);
ok = SMB_VFS_STRICT_LOCK_CHECK(state->src_fsp->conn,
state->dst_off,
state->next_io_size,
WRITE_LOCK,
+ lp_posix_cifsu_locktype(state->dst_fsp),
&write_lck);
ok = SMB_VFS_STRICT_LOCK_CHECK(state->dst_fsp->conn,
tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
return;
}
+ state->copied += nwritten;
state->remaining -= nwritten;
if (state->remaining == 0) {
tevent_req_done(req);
return status;
}
- *copied = state->to_copy;
+ *copied = state->copied;
DBG_DEBUG("copy chunk copied %lu\n", (unsigned long)*copied);
tevent_req_received(req);
int result;
START_PROFILE(syscall_fchown);
- result = fchown(fsp_get_io_fd(fsp), uid, gid);
+ if (!fsp->fsp_flags.is_pathref) {
+ result = fchown(fsp_get_io_fd(fsp), uid, gid);
+ END_PROFILE(syscall_fchown);
+ return result;
+ }
+
+ if (fsp->fsp_flags.have_proc_fds) {
+ int fd = fsp_get_pathref_fd(fsp);
+ const char *p = NULL;
+ char buf[PATH_MAX];
+
+ p = sys_proc_fd_path(fd, buf, sizeof(buf));
+ if (p != NULL) {
+ result = chown(p, uid, gid);
+ } else {
+ result = -1;
+ }
+ END_PROFILE(syscall_fchown);
+ return result;
+ }
+
+ /*
+ * This is no longer a handle based call.
+ */
+ result = chown(fsp->fsp_name->base_name, uid, gid);
END_PROFILE(syscall_fchown);
return result;
#else
START_PROFILE(syscall_fntimes);
- if (is_named_stream(fsp->fsp_name)) {
+ if (fsp_is_alternate_stream(fsp)) {
errno = ENOENT;
goto out;
}
return result;
}
-static int vfswrap_kernel_flock(vfs_handle_struct *handle, files_struct *fsp,
- uint32_t share_access, uint32_t access_mask)
+static int vfswrap_filesystem_sharemode(vfs_handle_struct *handle,
+ files_struct *fsp,
+ uint32_t share_access,
+ uint32_t access_mask)
{
- START_PROFILE(syscall_kernel_flock);
- kernel_flock(fsp_get_io_fd(fsp), share_access, access_mask);
- END_PROFILE(syscall_kernel_flock);
- return 0;
+ errno = ENOTSUP;
+ return -1;
}
static int vfswrap_fcntl(vfs_handle_struct *handle, files_struct *fsp, int cmd,
return result_fname;
}
-static int vfswrap_chflags(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
+static int vfswrap_fchflags(vfs_handle_struct *handle,
+ struct files_struct *fsp,
unsigned int flags)
{
-#ifdef HAVE_CHFLAGS
- return chflags(smb_fname->base_name, flags);
+#ifdef HAVE_FCHFLAGS
+ int fd = fsp_get_pathref_fd(fsp);
+
+ if (!fsp->fsp_flags.is_pathref) {
+ return fchflags(fd, flags);
+ }
+
+ if (fsp->fsp_flags.have_proc_fds) {
+ const char *p = NULL;
+ char buf[PATH_MAX];
+
+ p = sys_proc_fd_path(fd, buf, sizeof(buf));
+ if (p == NULL) {
+ return -1;
+ }
+
+ return chflags(p, flags);
+ }
+
+ /*
+ * This is no longer a handle based call.
+ */
+ return chflags(fsp->fsp_name->base_name, flags);
#else
errno = ENOSYS;
return -1;
{
uint64_t file_id;
- if (!(psbuf->st_ex_iflags & ST_EX_IFLAG_CALCULATED_FILE_ID)) {
- return psbuf->st_ex_file_id;
- }
-
if (handle->conn->base_share_dev == psbuf->st_ex_dev) {
return (uint64_t)psbuf->st_ex_ino;
}
return NT_STATUS_OK;
}
-static int vfswrap_get_real_filename(struct vfs_handle_struct *handle,
- const struct smb_filename *path,
- const char *name,
- TALLOC_CTX *mem_ctx,
- char **found_name)
+static NTSTATUS vfswrap_get_real_filename(struct vfs_handle_struct *handle,
+ const struct smb_filename *path,
+ const char *name,
+ TALLOC_CTX *mem_ctx,
+ char **found_name)
{
/*
* Don't fall back to get_real_filename so callers can differentiate
* between a full directory scan and an actual case-insensitive stat.
*/
- errno = EOPNOTSUPP;
- return -1;
+ return NT_STATUS_NOT_SUPPORTED;
+}
+
+static NTSTATUS vfswrap_get_real_filename_at(
+ struct vfs_handle_struct *handle,
+ struct files_struct *dirfsp,
+ const char *name,
+ TALLOC_CTX *mem_ctx,
+ char **found_name)
+{
+ /*
+ * Don't fall back to get_real_filename so callers can differentiate
+ * between a full directory scan and an actual case-insensitive stat.
+ */
+ return NT_STATUS_NOT_SUPPORTED;
}
static const char *vfswrap_connectpath(struct vfs_handle_struct *handle,
return result;
}
-static NTSTATUS vfswrap_get_nt_acl_at(vfs_handle_struct *handle,
- struct files_struct *dirfsp,
- const struct smb_filename *smb_fname,
- uint32_t security_info,
- TALLOC_CTX *mem_ctx,
- struct security_descriptor **ppdesc)
-{
- NTSTATUS result;
-
- START_PROFILE(get_nt_acl_at);
-
- SMB_ASSERT(dirfsp == dirfsp->conn->cwd_fsp);
-
- result = posix_get_nt_acl(handle->conn,
- smb_fname,
- security_info,
- mem_ctx,
- ppdesc);
- END_PROFILE(get_nt_acl_at);
- return result;
-}
-
static NTSTATUS vfswrap_fset_nt_acl(vfs_handle_struct *handle, files_struct *fsp, uint32_t security_info_sent, const struct security_descriptor *psd)
{
NTSTATUS result;
return NT_STATUS_OK; /* Nothing to do here ... */
}
-static SMB_ACL_T vfswrap_sys_acl_get_file(vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- SMB_ACL_TYPE_T type,
- TALLOC_CTX *mem_ctx)
-{
- return sys_acl_get_file(handle, smb_fname, type, mem_ctx);
-}
-
static SMB_ACL_T vfswrap_sys_acl_get_fd(vfs_handle_struct *handle,
files_struct *fsp,
+ SMB_ACL_TYPE_T type,
TALLOC_CTX *mem_ctx)
{
- return sys_acl_get_fd(handle, fsp, mem_ctx);
+ return sys_acl_get_fd(handle, fsp, type, mem_ctx);
}
static int vfswrap_sys_acl_set_fd(vfs_handle_struct *handle,
SMB_ACL_TYPE_T type,
SMB_ACL_T theacl)
{
- if (!fsp->fsp_flags.is_pathref &&
- type == SMB_ACL_TYPE_ACCESS)
- {
- return sys_acl_set_fd(handle, fsp, theacl);
+ return sys_acl_set_fd(handle, fsp, type, theacl);
+}
+
+static int vfswrap_sys_acl_delete_def_fd(vfs_handle_struct *handle,
+ files_struct *fsp)
+{
+ return sys_acl_delete_def_fd(handle, fsp);
+}
+
+/****************************************************************
+ Extended attribute operations.
+*****************************************************************/
+
+static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle,
+ struct files_struct *fsp,
+ const char *name,
+ void *value,
+ size_t size)
+{
+ int fd = fsp_get_pathref_fd(fsp);
+
+ if (!fsp->fsp_flags.is_pathref) {
+ return fgetxattr(fd, name, value, size);
}
if (fsp->fsp_flags.have_proc_fds) {
- int fd = fsp_get_pathref_fd(fsp);
- struct smb_filename smb_fname;
const char *p = NULL;
char buf[PATH_MAX];
return -1;
}
- smb_fname = (struct smb_filename) {
- .base_name = buf,
- };
-
- return sys_acl_set_file(handle,
- &smb_fname,
- type,
- theacl);
+ return getxattr(p, name, value, size);
}
/*
* This is no longer a handle based call.
*/
- return sys_acl_set_file(handle,
- fsp->fsp_name,
- type,
- theacl);
-}
-
-static int vfswrap_sys_acl_delete_def_fd(vfs_handle_struct *handle,
- files_struct *fsp)
-{
- return sys_acl_delete_def_fd(handle, fsp);
-}
-
-/****************************************************************
- Extended attribute operations.
-*****************************************************************/
-
-static ssize_t vfswrap_getxattr(struct vfs_handle_struct *handle,
- const struct smb_filename *smb_fname,
- const char *name,
- void *value,
- size_t size)
-{
- return getxattr(smb_fname->base_name, name, value, size);
+ return getxattr(fsp->fsp_name->base_name, name, value, size);
}
struct vfswrap_getxattrat_state {
struct tevent_context *ev;
+ struct vfs_handle_struct *handle;
files_struct *dir_fsp;
const struct smb_filename *smb_fname;
}
*state = (struct vfswrap_getxattrat_state) {
.ev = ev,
+ .handle = handle,
.dir_fsp = dir_fsp,
.smb_fname = smb_fname,
};
{
struct vfswrap_getxattrat_state *state = tevent_req_data(
req, struct vfswrap_getxattrat_state);
- char *path = NULL;
- char *tofree = NULL;
- char pathbuf[PATH_MAX+1];
- ssize_t pathlen;
- int err;
-
- pathlen = full_path_tos(state->dir_fsp->fsp_name->base_name,
- state->smb_fname->base_name,
- pathbuf,
- sizeof(pathbuf),
- &path,
- &tofree);
- if (pathlen == -1) {
- tevent_req_error(req, ENOMEM);
- return;
- }
+ struct files_struct *fsp = metadata_fsp(state->smb_fname->fsp);
- state->xattr_size = getxattr(path,
- state->xattr_name,
- state->xattr_value,
- talloc_array_length(state->xattr_value));
- err = errno;
- TALLOC_FREE(tofree);
+ state->xattr_size = vfswrap_fgetxattr(state->handle,
+ fsp,
+ state->xattr_name,
+ state->xattr_value,
+ talloc_array_length(state->xattr_value));
if (state->xattr_size == -1) {
- tevent_req_error(req, err);
+ tevent_req_error(req, errno);
return;
}
struct timespec start_time;
struct timespec end_time;
int ret;
+ struct files_struct *fsp = metadata_fsp(state->smb_fname->fsp);
PROFILE_TIMESTAMP(&start_time);
SMBPROFILE_BYTES_ASYNC_SET_BUSY(state->profile_bytes);
goto end_profile;
}
- ret = fchdir(fsp_get_pathref_fd(state->dir_fsp));
- if (ret == -1) {
- state->xattr_size = -1;
- state->vfs_aio_state.error = errno;
- goto end_profile;
- }
-
- state->xattr_size = getxattr(state->name,
- state->xattr_name,
- state->xattr_value,
- talloc_array_length(state->xattr_value));
+ state->xattr_size = vfswrap_fgetxattr(state->handle,
+ fsp,
+ state->xattr_name,
+ state->xattr_value,
+ talloc_array_length(state->xattr_value));
if (state->xattr_size == -1) {
state->vfs_aio_state.error = errno;
}
return xattr_size;
}
-static ssize_t vfswrap_fgetxattr(struct vfs_handle_struct *handle,
- struct files_struct *fsp,
- const char *name,
- void *value,
- size_t size)
-{
- int fd = fsp_get_pathref_fd(fsp);
-
- if (!fsp->fsp_flags.is_pathref) {
- return fgetxattr(fd, name, value, size);
- }
-
- if (fsp->fsp_flags.have_proc_fds) {
- const char *p = NULL;
- char buf[PATH_MAX];
-
- p = sys_proc_fd_path(fd, buf, sizeof(buf));
- if (p == NULL) {
- return -1;
- }
-
- return getxattr(p, name, value, size);
- }
-
- /*
- * This is no longer a handle based call.
- */
- return getxattr(fsp->fsp_name->base_name, name, value, size);
-}
-
static ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size)
{
int fd = fsp_get_pathref_fd(fsp);
.stat_fn = vfswrap_stat,
.fstat_fn = vfswrap_fstat,
.lstat_fn = vfswrap_lstat,
+ .fstatat_fn = vfswrap_fstatat,
.get_alloc_size_fn = vfswrap_get_alloc_size,
.unlinkat_fn = vfswrap_unlinkat,
.fchmod_fn = vfswrap_fchmod,
.ftruncate_fn = vfswrap_ftruncate,
.fallocate_fn = vfswrap_fallocate,
.lock_fn = vfswrap_lock,
- .kernel_flock_fn = vfswrap_kernel_flock,
+ .filesystem_sharemode_fn = vfswrap_filesystem_sharemode,
.fcntl_fn = vfswrap_fcntl,
.linux_setlease_fn = vfswrap_linux_setlease,
.getlock_fn = vfswrap_getlock,
.linkat_fn = vfswrap_linkat,
.mknodat_fn = vfswrap_mknodat,
.realpath_fn = vfswrap_realpath,
- .chflags_fn = vfswrap_chflags,
+ .fchflags_fn = vfswrap_fchflags,
.file_id_create_fn = vfswrap_file_id_create,
.fs_file_id_fn = vfswrap_fs_file_id,
.fstreaminfo_fn = vfswrap_fstreaminfo,
.get_real_filename_fn = vfswrap_get_real_filename,
+ .get_real_filename_at_fn = vfswrap_get_real_filename_at,
.connectpath_fn = vfswrap_connectpath,
.brl_lock_windows_fn = vfswrap_brl_lock_windows,
.brl_unlock_windows_fn = vfswrap_brl_unlock_windows,
/* NT ACL operations. */
.fget_nt_acl_fn = vfswrap_fget_nt_acl,
- .get_nt_acl_at_fn = vfswrap_get_nt_acl_at,
.fset_nt_acl_fn = vfswrap_fset_nt_acl,
.audit_file_fn = vfswrap_audit_file,
/* POSIX ACL operations. */
- .sys_acl_get_file_fn = vfswrap_sys_acl_get_file,
.sys_acl_get_fd_fn = vfswrap_sys_acl_get_fd,
- .sys_acl_blob_get_file_fn = posix_sys_acl_blob_get_file,
.sys_acl_blob_get_fd_fn = posix_sys_acl_blob_get_fd,
.sys_acl_set_fd_fn = vfswrap_sys_acl_set_fd,
.sys_acl_delete_def_fd_fn = vfswrap_sys_acl_delete_def_fd,
/* EA operations. */
- .getxattr_fn = vfswrap_getxattr,
.getxattrat_send_fn = vfswrap_getxattrat_send,
.getxattrat_recv_fn = vfswrap_getxattrat_recv,
.fgetxattr_fn = vfswrap_fgetxattr,
git.samba.org / bbaumbach / samba-autobuild / .git / blobdiff