static int xattr_tdb_get_file_id(struct vfs_handle_struct *handle,
const char *path, struct file_id *id)
{
int ret;
TALLOC_CTX *frame = talloc_stackframe();
struct smb_filename *smb_fname;
smb_fname = synthetic_smb_fname(frame, path, NULL, NULL, 0);
if (smb_fname == NULL) {
TALLOC_FREE(frame);
errno = ENOMEM;
return -1;
}
ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
if (ret == -1) {
TALLOC_FREE(frame);
return -1;
}
*id = SMB_VFS_NEXT_FILE_ID_CREATE(handle, &smb_fname->st);
TALLOC_FREE(frame);
return 0;
}
static int fake_acls_sys_acl_delete_def_file(vfs_handle_struct *handle, const char *path)
{
int ret;
const char *name = FAKE_ACL_DEFAULT_XATTR;
TALLOC_CTX *frame = talloc_stackframe();
struct smb_filename *smb_fname;
smb_fname = synthetic_smb_fname(frame, path, NULL, NULL);
if (smb_fname == NULL) {
TALLOC_FREE(frame);
errno = ENOMEM;
return -1;
}
ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
if (ret == -1) {
TALLOC_FREE(frame);
return -1;
}
if (!S_ISDIR(smb_fname->st.st_ex_mode)) {
errno = EINVAL;
TALLOC_FREE(frame);
return -1;
}
ret = SMB_VFS_NEXT_REMOVEXATTR(handle, path, name);
if (ret == -1 && errno == ENOATTR) {
ret = 0;
errno = 0;
}
TALLOC_FREE(frame);
return ret;
}
/*
* On unlink we need to delete the tdb record
*/
static int posix_eadb_unlink(vfs_handle_struct *handle,
const struct smb_filename *smb_fname)
{
struct smb_filename *smb_fname_tmp = NULL;
int ret = -1;
struct tdb_wrap *ea_tdb;
SMB_VFS_HANDLE_GET_DATA(handle, ea_tdb, struct tdb_wrap, return -1);
smb_fname_tmp = cp_smb_filename(talloc_tos(), smb_fname);
if (smb_fname_tmp == NULL) {
errno = ENOMEM;
return -1;
}
if (lp_posix_pathnames()) {
ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_tmp);
} else {
ret = SMB_VFS_NEXT_STAT(handle, smb_fname_tmp);
}
if (ret == -1) {
goto out;
}
if (smb_fname_tmp->st.st_ex_nlink == 1) {
NTSTATUS status;
/* Only remove record on last link to file. */
if (tdb_transaction_start(ea_tdb->tdb) != 0) {
ret = -1;
goto out;
}
status = unlink_posix_eadb_raw(ea_tdb, smb_fname->base_name, -1);
if (!NT_STATUS_IS_OK(status)) {
tdb_transaction_cancel(ea_tdb->tdb);
ret = -1;
goto out;
}
}
ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname_tmp);
if (ret == -1) {
tdb_transaction_cancel(ea_tdb->tdb);
goto out;
} else {
if (tdb_transaction_commit(ea_tdb->tdb) != 0) {
ret = -1;
goto out;
}
}
out:
TALLOC_FREE(smb_fname_tmp);
return ret;
}
static int streams_xattr_stat(vfs_handle_struct *handle,
struct smb_filename *smb_fname)
{
NTSTATUS status;
int result = -1;
char *xattr_name = NULL;
if (!is_ntfs_stream_smb_fname(smb_fname)) {
return SMB_VFS_NEXT_STAT(handle, smb_fname);
}
/* Note if lp_posix_paths() is true, we can never
* get here as is_ntfs_stream_smb_fname() is
* always false. So we never need worry about
* not following links here. */
/* If the default stream is requested, just stat the base file. */
if (is_ntfs_default_stream_smb_fname(smb_fname)) {
return streams_xattr_stat_base(handle, smb_fname, true);
}
/* Populate the stat struct with info from the base file. */
if (streams_xattr_stat_base(handle, smb_fname, true) == -1) {
return -1;
}
/* Derive the xattr name to lookup. */
status = streams_xattr_get_name(handle, talloc_tos(),
smb_fname->stream_name, &xattr_name);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
return -1;
}
/* Augment the base file's stat information before returning. */
smb_fname->st.st_ex_size = get_xattr_size(handle->conn,
smb_fname,
xattr_name);
if (smb_fname->st.st_ex_size == -1) {
SET_STAT_INVALID(smb_fname->st);
errno = ENOENT;
result = -1;
goto fail;
}
smb_fname->st.st_ex_ino = stream_inode(&smb_fname->st, xattr_name);
smb_fname->st.st_ex_mode &= ~S_IFMT;
smb_fname->st.st_ex_mode &= ~S_IFDIR;
smb_fname->st.st_ex_mode |= S_IFREG;
smb_fname->st.st_ex_blocks =
smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
result = 0;
fail:
TALLOC_FREE(xattr_name);
return result;
}
/**
* Return file size
* @param conn connection
* @param fname file name
* @return size in bytes
**/
static SMB_OFF_T recycle_get_file_size(vfs_handle_struct *handle, const char *fname)
{
SMB_STRUCT_STAT st;
if (SMB_VFS_NEXT_STAT(handle, fname, &st) != 0) {
DEBUG(0,("recycle: stat for %s returned %s\n", fname, strerror(errno)));
return (SMB_OFF_T)0;
}
return(st.st_size);
}
static BOOL recycle_file_exist(vfs_handle_struct *handle, const char *fname)
{
SMB_STRUCT_STAT st;
if (SMB_VFS_NEXT_STAT(handle, fname, &st) == 0) {
if (S_ISREG(st.st_mode)) {
return True;
}
}
return False;
}
static BOOL recycle_directory_exist(vfs_handle_struct *handle, const char *dname)
{
SMB_STRUCT_STAT st;
if (SMB_VFS_NEXT_STAT(handle, dname, &st) == 0) {
if (S_ISDIR(st.st_mode)) {
return True;
}
}
return False;
}
/**
* Touch access or modify date
**/
static void recycle_do_touch(vfs_handle_struct *handle, const char *fname, BOOL touch_mtime)
{
SMB_STRUCT_STAT st;
struct timespec ts[2];
if (SMB_VFS_NEXT_STAT(handle, fname, &st) != 0) {
DEBUG(0,("recycle: stat for %s returned %s\n", fname, strerror(errno)));
return;
}
ts[0] = timespec_current(); /* atime */
ts[1] = touch_mtime ? ts[0] : get_mtimespec(&st); /* mtime */
if (SMB_VFS_NEXT_NTIMES(handle, fname, ts) == -1 ) {
DEBUG(0, ("recycle: touching %s failed, reason = %s\n", fname, strerror(errno)));
}
}
/**
* Helper to stat/lstat the base file of an smb_fname.
*/
static int streams_xattr_stat_base(vfs_handle_struct *handle,
struct smb_filename *smb_fname,
bool follow_links)
{
char *tmp_stream_name;
int result;
tmp_stream_name = smb_fname->stream_name;
smb_fname->stream_name = NULL;
if (follow_links) {
result = SMB_VFS_NEXT_STAT(handle, smb_fname);
} else {
result = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
}
smb_fname->stream_name = tmp_stream_name;
return result;
}
static int fake_perms_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
{
int ret = -1;
ret = SMB_VFS_NEXT_STAT(handle, fname, 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;
}
/**
* Touch access date
**/
static void recycle_do_touch(vfs_handle_struct *handle, const char *fname)
{
SMB_STRUCT_STAT st;
struct utimbuf tb;
time_t currtime;
if (SMB_VFS_NEXT_STAT(handle, handle->conn, fname, &st) != 0) {
DEBUG(0,("recycle: stat for %s returned %s\n", fname, strerror(errno)));
return;
}
currtime = time(&currtime);
tb.actime = currtime;
tb.modtime = st.st_mtime;
if (SMB_VFS_NEXT_UTIME(handle, handle->conn, fname, &tb) == -1 ) {
DEBUG(0, ("recycle: touching %s failed, reason = %s\n", fname, strerror(errno)));
}
}
static int fake_acls_stat(vfs_handle_struct *handle,
struct smb_filename *smb_fname)
{
int ret = -1;
ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
if (ret == 0) {
TALLOC_CTX *frame = talloc_stackframe();
char *path;
struct smb_filename smb_fname_base = {
.base_name = smb_fname->base_name
};
NTSTATUS status;
/*
* As we're calling getxattr directly here
* we need to use only the base_name, not
* the full name containing any stream name.
*/
status = get_full_smb_filename(frame, &smb_fname_base, &path);
if (!NT_STATUS_IS_OK(status)) {
errno = map_errno_from_nt_status(status);
TALLOC_FREE(frame);
return -1;
}
ret = fake_acls_uid(handle, path, &smb_fname->st.st_ex_uid);
if (ret != 0) {
TALLOC_FREE(frame);
return ret;
}
ret = fake_acls_gid(handle, path, &smb_fname->st.st_ex_gid);
if (ret != 0) {
TALLOC_FREE(frame);
return ret;
}
TALLOC_FREE(frame);
}
return ret;
}
static int skel_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
{
return SMB_VFS_NEXT_STAT(handle, smb_fname);
}
static int skel_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
{
return SMB_VFS_NEXT_STAT(handle, fname, sbuf);
}
static int cap_stat(vfs_handle_struct *handle, connection_struct *conn, const char *fname, SMB_STRUCT_STAT *sbuf)
{
pstring capname;
capencode(capname, fname);
return SMB_VFS_NEXT_STAT(handle, conn, capname, sbuf);
}