* an option to put in a special ACL entry for a non-existing group.
*/
-static bool file_is_valid(vfs_handle_struct *handle, const char *path,
- bool check_valid)
+static bool file_is_valid(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
{
char buf;
- if (!check_valid) {
- return true;
- }
-
- DEBUG(10, ("file_is_valid (%s) called\n", path));
+ DEBUG(10, ("file_is_valid (%s) called\n", smb_fname->base_name));
- if (SMB_VFS_GETXATTR(handle->conn, path, SAMBA_XATTR_MARKER,
+ if (SMB_VFS_GETXATTR(handle->conn, smb_fname, SAMBA_XATTR_MARKER,
&buf, sizeof(buf)) != sizeof(buf)) {
DEBUG(10, ("GETXATTR failed: %s\n", strerror(errno)));
return false;
return true;
}
-static bool mark_file_valid(vfs_handle_struct *handle, const char *path,
- bool check_valid)
+static bool mark_file_valid(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
{
char buf = '1';
int ret;
- if (!check_valid) {
- return true;
- }
+ DEBUG(10, ("marking file %s as valid\n", smb_fname->base_name));
- DEBUG(10, ("marking file %s as valid\n", path));
-
- ret = SMB_VFS_SETXATTR(handle->conn, path, SAMBA_XATTR_MARKER,
+ ret = SMB_VFS_SETXATTR(handle->conn, smb_fname, SAMBA_XATTR_MARKER,
&buf, sizeof(buf), 0);
if (ret == -1) {
char *tmp;
char *id_hex;
struct file_id id;
- uint8 id_buf[16];
+ uint8_t id_buf[16];
bool check_valid;
- const char *rootdir;
- NTSTATUS status;
+ char *rootdir = NULL;
+ struct smb_filename *rootdir_fname = NULL;
+ struct smb_filename *tmp_fname = NULL;
check_valid = lp_parm_bool(SNUM(handle->conn),
"streams_depot", "check_valid", true);
- tmp = talloc_asprintf(talloc_tos(), "%s/.streams", handle->conn->connectpath);
+ tmp = talloc_asprintf(talloc_tos(), "%s/.streams",
+ handle->conn->connectpath);
if (tmp == NULL) {
errno = ENOMEM;
goto fail;
}
- rootdir = lp_parm_const_string(
+ rootdir = lp_parm_talloc_string(talloc_tos(),
SNUM(handle->conn), "streams_depot", "directory",
tmp);
+ if (rootdir == NULL) {
+ errno = ENOMEM;
+ goto fail;
+ }
+
+ rootdir_fname = synthetic_smb_fname(talloc_tos(),
+ rootdir,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (rootdir_fname == NULL) {
+ errno = ENOMEM;
+ goto fail;
+ }
/* Stat the base file if it hasn't already been done. */
if (base_sbuf == NULL) {
- struct smb_filename *smb_fname_base = NULL;
-
- status = create_synthetic_smb_fname(talloc_tos(),
- smb_fname->base_name,
- NULL, NULL,
- &smb_fname_base);
- if (!NT_STATUS_IS_OK(status)) {
- errno = map_errno_from_nt_status(status);
+ struct smb_filename *smb_fname_base;
+
+ smb_fname_base = synthetic_smb_fname(
+ talloc_tos(),
+ smb_fname->base_name,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (smb_fname_base == NULL) {
+ errno = ENOMEM;
goto fail;
}
if (SMB_VFS_NEXT_STAT(handle, smb_fname_base) == -1) {
return NULL;
}
- status = create_synthetic_smb_fname(talloc_tos(), result, NULL, NULL,
- &smb_fname_hash);
- if (!NT_STATUS_IS_OK(status)) {
- errno = map_errno_from_nt_status(status);
+ smb_fname_hash = synthetic_smb_fname(talloc_tos(),
+ result,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (smb_fname_hash == NULL) {
+ errno = ENOMEM;
goto fail;
}
if (SMB_VFS_NEXT_STAT(handle, smb_fname_hash) == 0) {
struct smb_filename *smb_fname_new = NULL;
char *newname;
+ bool delete_lost;
if (!S_ISDIR(smb_fname_hash->st.st_ex_mode)) {
errno = EINVAL;
goto fail;
}
- if (file_is_valid(handle, smb_fname->base_name, check_valid)) {
+ if (!check_valid ||
+ file_is_valid(handle, smb_fname)) {
return result;
}
/*
* Someone has recreated a file under an existing inode
- * without deleting the streams directory. For now, just move
- * it away.
+ * without deleting the streams directory.
+ * Move it away or remove if streams_depot:delete_lost is set.
*/
again:
- newname = talloc_asprintf(talloc_tos(), "lost-%lu", random());
- if (newname == NULL) {
- errno = ENOMEM;
- goto fail;
- }
+ delete_lost = lp_parm_bool(SNUM(handle->conn), "streams_depot",
+ "delete_lost", false);
+
+ if (delete_lost) {
+ DEBUG(3, ("Someone has recreated a file under an "
+ "existing inode. Removing: %s\n",
+ smb_fname_hash->base_name));
+ recursive_rmdir(talloc_tos(), handle->conn,
+ smb_fname_hash);
+ SMB_VFS_NEXT_RMDIR(handle, smb_fname_hash);
+ } else {
+ newname = talloc_asprintf(talloc_tos(), "lost-%lu",
+ random());
+ DEBUG(3, ("Someone has recreated a file under an "
+ "existing inode. Renaming: %s to: %s\n",
+ smb_fname_hash->base_name,
+ newname));
+ if (newname == NULL) {
+ errno = ENOMEM;
+ goto fail;
+ }
- status = create_synthetic_smb_fname(talloc_tos(), newname,
- NULL, NULL,
- &smb_fname_new);
- TALLOC_FREE(newname);
- if (!NT_STATUS_IS_OK(status)) {
- errno = map_errno_from_nt_status(status);
- goto fail;
- }
+ smb_fname_new = synthetic_smb_fname(
+ talloc_tos(),
+ newname,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ TALLOC_FREE(newname);
+ if (smb_fname_new == NULL) {
+ errno = ENOMEM;
+ goto fail;
+ }
- if (SMB_VFS_NEXT_RENAME(handle, smb_fname_hash,
- smb_fname_new) == -1) {
- TALLOC_FREE(smb_fname_new);
- if ((errno == EEXIST) || (errno == ENOTEMPTY)) {
- goto again;
+ if (SMB_VFS_NEXT_RENAME(handle, smb_fname_hash,
+ smb_fname_new) == -1) {
+ TALLOC_FREE(smb_fname_new);
+ if ((errno == EEXIST) || (errno == ENOTEMPTY)) {
+ goto again;
+ }
+ goto fail;
}
- goto fail;
- }
- TALLOC_FREE(smb_fname_new);
+ TALLOC_FREE(smb_fname_new);
+ }
}
if (!create_it) {
goto fail;
}
- if ((SMB_VFS_NEXT_MKDIR(handle, rootdir, 0755) != 0)
+ if ((SMB_VFS_NEXT_MKDIR(handle, rootdir_fname, 0755) != 0)
&& (errno != EEXIST)) {
goto fail;
}
goto fail;
}
- if ((SMB_VFS_NEXT_MKDIR(handle, tmp, 0755) != 0)
+ tmp_fname = synthetic_smb_fname(talloc_tos(),
+ tmp,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (tmp_fname == NULL) {
+ errno = ENOMEM;
+ goto fail;
+ }
+
+ if ((SMB_VFS_NEXT_MKDIR(handle, tmp_fname, 0755) != 0)
&& (errno != EEXIST)) {
goto fail;
}
TALLOC_FREE(tmp);
+ TALLOC_FREE(tmp_fname);
tmp = talloc_asprintf(result, "%s/%2.2X/%2.2X", rootdir, first,
second);
goto fail;
}
- if ((SMB_VFS_NEXT_MKDIR(handle, tmp, 0755) != 0)
+ tmp_fname = synthetic_smb_fname(talloc_tos(),
+ tmp,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (tmp_fname == NULL) {
+ errno = ENOMEM;
+ goto fail;
+ }
+
+ if ((SMB_VFS_NEXT_MKDIR(handle, tmp_fname, 0755) != 0)
&& (errno != EEXIST)) {
goto fail;
}
TALLOC_FREE(tmp);
+ TALLOC_FREE(tmp_fname);
- if ((SMB_VFS_NEXT_MKDIR(handle, result, 0755) != 0)
+ /* smb_fname_hash is the struct smb_filename version of 'result' */
+ if ((SMB_VFS_NEXT_MKDIR(handle, smb_fname_hash, 0755) != 0)
&& (errno != EEXIST)) {
goto fail;
}
- if (!mark_file_valid(handle, smb_fname->base_name, check_valid)) {
+ if (check_valid && !mark_file_valid(handle, smb_fname)) {
goto fail;
}
+ TALLOC_FREE(rootdir_fname);
+ TALLOC_FREE(rootdir);
+ TALLOC_FREE(tmp_fname);
TALLOC_FREE(smb_fname_hash);
return result;
fail:
+ TALLOC_FREE(rootdir_fname);
+ TALLOC_FREE(rootdir);
+ TALLOC_FREE(tmp_fname);
TALLOC_FREE(smb_fname_hash);
TALLOC_FREE(result);
return NULL;
}
} else {
/* Normalize the stream type to upercase. */
- strupper_m(strrchr_m(stream_fname, ':') + 1);
+ if (!strupper_m(strrchr_m(stream_fname, ':') + 1)) {
+ status = NT_STATUS_INVALID_PARAMETER;
+ goto fail;
+ }
}
DEBUG(10, ("stream filename = %s\n", stream_fname));
/* Create an smb_filename with stream_name == NULL. */
- status = create_synthetic_smb_fname(talloc_tos(), stream_fname, NULL,
- NULL, smb_fname_out);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
+ *smb_fname_out = synthetic_smb_fname(talloc_tos(),
+ stream_fname,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (*smb_fname_out == NULL) {
+ return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_OK;
void *private_data)
{
char *dirname;
- SMB_STRUCT_DIR *dirhandle = NULL;
+ struct smb_filename *dir_smb_fname = NULL;
+ DIR *dirhandle = NULL;
const char *dirent = NULL;
char *talloced = NULL;
DEBUG(10, ("walk_streams: dirname=%s\n", dirname));
- dirhandle = SMB_VFS_NEXT_OPENDIR(handle, dirname, NULL, 0);
+ dir_smb_fname = synthetic_smb_fname(talloc_tos(),
+ dirname,
+ NULL,
+ NULL,
+ smb_fname_base->flags);
+ if (dir_smb_fname == NULL) {
+ TALLOC_FREE(dirname);
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ dirhandle = SMB_VFS_NEXT_OPENDIR(handle, dir_smb_fname, NULL, 0);
+
+ TALLOC_FREE(dir_smb_fname);
if (dirhandle == NULL) {
TALLOC_FREE(dirname);
}
/* Ensure the base file still exists. */
- status = create_synthetic_smb_fname(talloc_tos(),
- smb_fname->base_name,
- NULL, NULL,
- &smb_fname_base);
- if (!NT_STATUS_IS_OK(status)) {
+ smb_fname_base = synthetic_smb_fname(talloc_tos(),
+ smb_fname->base_name,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (smb_fname_base == NULL) {
ret = -1;
- errno = map_errno_from_nt_status(status);
+ errno = ENOMEM;
goto done;
}
const struct smb_filename *smb_fname)
{
struct smb_filename *smb_fname_base = NULL;
- NTSTATUS status;
int ret = -1;
DEBUG(10, ("streams_depot_unlink called for %s\n",
if (is_ntfs_stream_smb_fname(smb_fname) &&
!is_ntfs_default_stream_smb_fname(smb_fname)) {
struct smb_filename *smb_fname_stream = NULL;
+ NTSTATUS status;
status = stream_smb_fname(handle, smb_fname, &smb_fname_stream,
false);
* We potentially need to delete the per-inode streams directory
*/
- status = create_synthetic_smb_fname(talloc_tos(), smb_fname->base_name,
- NULL, NULL, &smb_fname_base);
- if (!NT_STATUS_IS_OK(status)) {
- errno = map_errno_from_nt_status(status);
+ smb_fname_base = synthetic_smb_fname(talloc_tos(),
+ smb_fname->base_name,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (smb_fname_base == NULL) {
+ errno = ENOMEM;
return -1;
}
- if (lp_posix_pathnames()) {
+ if (smb_fname_base->flags & SMB_FILENAME_POSIX_PATH) {
ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_base);
} else {
ret = SMB_VFS_NEXT_STAT(handle, smb_fname_base);
return -1;
}
- if (smb_fname_base->st.st_ex_nlink == 1) {
+ /*
+ * We know the unlink should succeed as the ACL
+ * check is already done in the caller. Remove the
+ * file *after* the streams.
+ */
+ {
char *dirname = stream_dir(handle, smb_fname_base,
&smb_fname_base->st, false);
if (dirname != NULL) {
- SMB_VFS_NEXT_RMDIR(handle, dirname);
+ struct smb_filename *smb_fname_dir =
+ synthetic_smb_fname(talloc_tos(),
+ dirname,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (smb_fname_dir == NULL) {
+ TALLOC_FREE(smb_fname_base);
+ TALLOC_FREE(dirname);
+ errno = ENOMEM;
+ return -1;
+ }
+ SMB_VFS_NEXT_RMDIR(handle, smb_fname_dir);
+ TALLOC_FREE(smb_fname_dir);
}
TALLOC_FREE(dirname);
}
ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname);
+ TALLOC_FREE(smb_fname_base);
+ return ret;
+}
+
+static int streams_depot_rmdir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname)
+{
+ struct smb_filename *smb_fname_base = NULL;
+ int ret = -1;
+
+ DEBUG(10, ("streams_depot_rmdir called for %s\n",
+ smb_fname->base_name));
+
+ /*
+ * We potentially need to delete the per-inode streams directory
+ */
+
+ smb_fname_base = synthetic_smb_fname(talloc_tos(),
+ smb_fname->base_name,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (smb_fname_base == NULL) {
+ errno = ENOMEM;
+ return -1;
+ }
+ if (smb_fname_base->flags & SMB_FILENAME_POSIX_PATH) {
+ ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_base);
+ } else {
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname_base);
+ }
+
+ if (ret == -1) {
+ TALLOC_FREE(smb_fname_base);
+ return -1;
+ }
+
+ /*
+ * We know the rmdir should succeed as the ACL
+ * check is already done in the caller. Remove the
+ * directory *after* the streams.
+ */
+ {
+ char *dirname = stream_dir(handle, smb_fname_base,
+ &smb_fname_base->st, false);
+
+ if (dirname != NULL) {
+ struct smb_filename *smb_fname_dir =
+ synthetic_smb_fname(talloc_tos(),
+ dirname,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (smb_fname_dir == NULL) {
+ TALLOC_FREE(smb_fname_base);
+ TALLOC_FREE(dirname);
+ errno = ENOMEM;
+ return -1;
+ }
+ SMB_VFS_NEXT_RMDIR(handle, smb_fname_dir);
+ TALLOC_FREE(smb_fname_dir);
+ }
+ TALLOC_FREE(dirname);
+ }
+
+ ret = SMB_VFS_NEXT_RMDIR(handle, smb_fname_base);
TALLOC_FREE(smb_fname_base);
return ret;
}
static bool add_one_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
struct stream_struct **streams,
- const char *name, SMB_OFF_T size,
- SMB_OFF_T alloc_size)
+ const char *name, off_t size,
+ off_t alloc_size)
{
struct stream_struct *tmp;
(struct streaminfo_state *)private_data;
struct smb_filename *smb_fname = NULL;
char *sname = NULL;
- NTSTATUS status;
bool ret;
sname = talloc_asprintf(talloc_tos(), "%s/%s", dirname, dirent);
goto out;
}
- status = create_synthetic_smb_fname(talloc_tos(), sname, NULL,
- NULL, &smb_fname);
- if (!NT_STATUS_IS_OK(status)) {
- state->status = status;
+ smb_fname = synthetic_smb_fname(talloc_tos(), sname, NULL, NULL, 0);
+ if (smb_fname == NULL) {
+ state->status = NT_STATUS_NO_MEMORY;
ret = false;
goto out;
}
static NTSTATUS streams_depot_streaminfo(vfs_handle_struct *handle,
struct files_struct *fsp,
- const char *fname,
+ const struct smb_filename *smb_fname,
TALLOC_CTX *mem_ctx,
unsigned int *pnum_streams,
struct stream_struct **pstreams)
NTSTATUS status;
struct streaminfo_state state;
- status = create_synthetic_smb_fname(talloc_tos(), fname, NULL, NULL,
- &smb_fname_base);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
+ smb_fname_base = synthetic_smb_fname(talloc_tos(),
+ smb_fname->base_name,
+ NULL,
+ NULL,
+ smb_fname->flags);
+ if (smb_fname_base == NULL) {
+ return NT_STATUS_NO_MEMORY;
}
if ((fsp != NULL) && (fsp->fh->fd != -1)) {
ret = SMB_VFS_NEXT_FSTAT(handle, fsp, &smb_fname_base->st);
}
else {
- if (lp_posix_pathnames()) {
+ if (smb_fname_base->flags & SMB_FILENAME_POSIX_PATH) {
ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_base);
} else {
ret = SMB_VFS_NEXT_STAT(handle, smb_fname_base);
goto out;
}
- state.streams = NULL;
- state.num_streams = 0;
-
- if (!S_ISDIR(smb_fname_base->st.st_ex_mode)) {
- if (!add_one_stream(mem_ctx,
- &state.num_streams, &state.streams,
- "::$DATA", smb_fname_base->st.st_ex_size,
- SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp,
- &smb_fname_base->st))) {
- status = NT_STATUS_NO_MEMORY;
- goto out;
- }
- }
-
+ state.streams = *pstreams;
+ state.num_streams = *pnum_streams;
state.mem_ctx = mem_ctx;
state.handle = handle;
state.status = NT_STATUS_OK;
- status = walk_streams(handle, smb_fname_base, NULL, collect_one_stream,
+ if (S_ISLNK(smb_fname_base->st.st_ex_mode)) {
+ /*
+ * Currently we do't have SMB_VFS_LLISTXATTR
+ * inside the VFS which means there's no way
+ * to cope with a symlink when lp_posix_pathnames().
+ * returns true. For now ignore links.
+ * FIXME - by adding SMB_VFS_LLISTXATTR. JRA.
+ */
+ status = NT_STATUS_OK;
+ } else {
+ status = walk_streams(handle, smb_fname_base, NULL, collect_one_stream,
&state);
+ }
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(state.streams);
*pnum_streams = state.num_streams;
*pstreams = state.streams;
- status = NT_STATUS_OK;
+ status = SMB_VFS_NEXT_STREAMINFO(handle,
+ fsp,
+ smb_fname_base,
+ mem_ctx,
+ pnum_streams,
+ pstreams);
out:
TALLOC_FREE(smb_fname_base);
}
static struct vfs_fn_pointers vfs_streams_depot_fns = {
- .fs_capabilities = streams_depot_fs_capabilities,
+ .fs_capabilities_fn = streams_depot_fs_capabilities,
.open_fn = streams_depot_open,
- .stat = streams_depot_stat,
- .lstat = streams_depot_lstat,
- .unlink = streams_depot_unlink,
- .rename = streams_depot_rename,
- .streaminfo = streams_depot_streaminfo,
+ .stat_fn = streams_depot_stat,
+ .lstat_fn = streams_depot_lstat,
+ .unlink_fn = streams_depot_unlink,
+ .rmdir_fn = streams_depot_rmdir,
+ .rename_fn = streams_depot_rename,
+ .streaminfo_fn = streams_depot_streaminfo,
};
-NTSTATUS vfs_streams_depot_init(void);
-NTSTATUS vfs_streams_depot_init(void)
+static_decl_vfs;
+NTSTATUS vfs_streams_depot_init(TALLOC_CTX *ctx)
{
return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "streams_depot",
&vfs_streams_depot_fns);
git.samba.org / samba.git / blobdiff