return vfswrap_fsync(NULL, fsp);
}
-static int skel_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
+static int skel_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
{
- return vfswrap_stat(NULL, fname, sbuf);
+ return vfswrap_stat(NULL, smb_fname);
}
static int skel_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
return vfswrap_fstat(NULL, fsp, sbuf);
}
-static int skel_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
+static int skel_lstat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
{
- return vfswrap_lstat(NULL, path, sbuf);
+ return vfswrap_lstat(NULL, smb_fname);
}
static int skel_unlink(vfs_handle_struct *handle, const char *path)
return SMB_VFS_NEXT_FSYNC(handle, fsp);
}
-static int skel_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
+static int skel_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
{
- return SMB_VFS_NEXT_STAT(handle, fname, sbuf);
+ return SMB_VFS_NEXT_STAT(handle, smb_fname);
}
static int skel_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
}
-static int skel_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
+static int skel_lstat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
{
- return SMB_VFS_NEXT_LSTAT(handle, path, sbuf);
+ return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
}
static int skel_unlink(vfs_handle_struct *handle, const char *path)
/* The following definitions come from modules/vfs_default.c */
-int vfswrap_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf);
ssize_t vfswrap_llistxattr(struct vfs_handle_struct *handle, const char *path, char *list, size_t size);
ssize_t vfswrap_flistxattr(struct vfs_handle_struct *handle, struct files_struct *fsp, char *list, size_t size);
NTSTATUS vfs_default_init(void);
/* The following definitions come from smbd/file_access.c */
bool can_access_file_acl(struct connection_struct *conn,
- const char * fname,
- uint32_t access_mask);
+ const struct smb_filename *smb_fname,
+ uint32_t access_mask);
bool can_delete_file_in_directory(connection_struct *conn,
- const struct smb_filename *smb_fname);
-bool can_access_file_data(connection_struct *conn, const char *fname, const SMB_STRUCT_STAT *psbuf, uint32 access_mask);
+ struct smb_filename *smb_fname);
+bool can_access_file_data(connection_struct *conn,
+ const struct smb_filename *smb_fname,
+ uint32 access_mask);
bool can_write_to_file(connection_struct *conn, const char *fname, const SMB_STRUCT_STAT *psbuf);
bool directory_has_default_acl(connection_struct *conn, const char *fname);
char **full_name);
NTSTATUS create_synthetic_smb_fname(TALLOC_CTX *ctx, const char *base_name,
const char *stream_name,
- SMB_STRUCT_STAT *psbuf,
+ const SMB_STRUCT_STAT *psbuf,
struct smb_filename **smb_fname_out);
NTSTATUS create_synthetic_smb_fname_split(TALLOC_CTX *ctx,
const char *fname,
- SMB_STRUCT_STAT *psbuf,
+ const SMB_STRUCT_STAT *psbuf,
struct smb_filename **smb_fname_out);
+int vfs_stat_smb_fname(struct connection_struct *conn, const char *fname,
+ SMB_STRUCT_STAT *psbuf);
+int vfs_lstat_smb_fname(struct connection_struct *conn, const char *fname,
+ SMB_STRUCT_STAT *psbuf);
const char *smb_fname_str_dbg(const struct smb_filename *smb_fname);
NTSTATUS copy_smb_filename(TALLOC_CTX *ctx,
const struct smb_filename *smb_fname_in,
void *vfs_memctx_fsp_extension(vfs_handle_struct *handle, files_struct *fsp);
void *vfs_fetch_fsp_extension(vfs_handle_struct *handle, files_struct *fsp);
bool smbd_vfs_init(connection_struct *conn);
-bool vfs_directory_exist(connection_struct *conn, const char *dname, SMB_STRUCT_STAT *st);
-bool vfs_object_exist(connection_struct *conn,const char *fname,SMB_STRUCT_STAT *sbuf);
NTSTATUS vfs_file_exist(connection_struct *conn, struct smb_filename *smb_fname);
ssize_t vfs_read_data(files_struct *fsp, char *buf, size_t byte_count);
ssize_t vfs_pread_data(files_struct *fsp, char *buf,
/* Leave at 25 - not yet released. Add locking calls. -- zkirsch. */
/* Leave at 25 - not yet released. Add strict locking calls. -- drichards. */
/* Changed to version 26 - Plumb struct smb_filename to SMB_VFS_CREATE_FILE,
- SMB_VFS_OPEN. */
+ SMB_VFS_OPEN, SMB_VFS_STAT, SMB_VFS_LSTAT. */
#define SMB_VFS_INTERFACE_VERSION 26
ssize_t (*recvfile)(struct vfs_handle_struct *handle, int fromfd, files_struct *tofsp, SMB_OFF_T offset, size_t count);
int (*rename)(struct vfs_handle_struct *handle, const char *oldname, const char *newname);
int (*fsync)(struct vfs_handle_struct *handle, struct files_struct *fsp);
- int (*stat)(struct vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf);
+ int (*stat)(struct vfs_handle_struct *handle, struct smb_filename *smb_fname);
int (*fstat)(struct vfs_handle_struct *handle, struct files_struct *fsp, SMB_STRUCT_STAT *sbuf);
- int (*lstat)(struct vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf);
+ int (*lstat)(struct vfs_handle_struct *handle, struct smb_filename *smb_filename);
uint64_t (*get_alloc_size)(struct vfs_handle_struct *handle, struct files_struct *fsp, const SMB_STRUCT_STAT *sbuf);
int (*unlink)(struct vfs_handle_struct *handle, const char *path);
int (*chmod)(struct vfs_handle_struct *handle, const char *path, mode_t mode);
#define SMB_VFS_RECVFILE(fromfd, tofsp, offset, count) ((tofsp)->conn->vfs.ops.recvfile((tofsp)->conn->vfs.handles.recvfile, (fromfd), (tofsp), (offset), (count)))
#define SMB_VFS_RENAME(conn, old, new) ((conn)->vfs.ops.rename((conn)->vfs.handles.rename, (old), (new)))
#define SMB_VFS_FSYNC(fsp) ((fsp)->conn->vfs.ops.fsync((fsp)->conn->vfs.handles.fsync, (fsp)))
-#define SMB_VFS_STAT(conn, fname, sbuf) ((conn)->vfs.ops.stat((conn)->vfs.handles.stat, (fname), (sbuf)))
+#define SMB_VFS_STAT(conn, smb_fname) ((conn)->vfs.ops.stat((conn)->vfs.handles.stat, (smb_fname)))
#define SMB_VFS_FSTAT(fsp, sbuf) ((fsp)->conn->vfs.ops.fstat((fsp)->conn->vfs.handles.fstat, (fsp), (sbuf)))
-#define SMB_VFS_LSTAT(conn, path, sbuf) ((conn)->vfs.ops.lstat((conn)->vfs.handles.lstat, (path), (sbuf)))
+#define SMB_VFS_LSTAT(conn, smb_fname) ((conn)->vfs.ops.lstat((conn)->vfs.handles.lstat, (smb_fname)))
#define SMB_VFS_GET_ALLOC_SIZE(conn, fsp, sbuf) ((conn)->vfs.ops.get_alloc_size((conn)->vfs.handles.get_alloc_size, (fsp), (sbuf)))
#define SMB_VFS_UNLINK(conn, path) ((conn)->vfs.ops.unlink((conn)->vfs.handles.unlink, (path)))
#define SMB_VFS_CHMOD(conn, path, mode) ((conn)->vfs.ops.chmod((conn)->vfs.handles.chmod, (path), (mode)))
#define SMB_VFS_OPAQUE_RECVFILE(fromfd, tofsp, offset, count) ((tofsp)->conn->vfs_opaque.ops.recvfile((tofsp)->conn->vfs_opaque.handles.recvfile, (fromfd), (tofsp), (offset), (count)))
#define SMB_VFS_OPAQUE_RENAME(conn, old, new) ((conn)->vfs_opaque.ops.rename((conn)->vfs_opaque.handles.rename, (old), (new)))
#define SMB_VFS_OPAQUE_FSYNC(fsp) ((fsp)->conn->vfs_opaque.ops.fsync((fsp)->conn->vfs_opaque.handles.fsync, (fsp)))
-#define SMB_VFS_OPAQUE_STAT(conn, fname, sbuf) ((conn)->vfs_opaque.ops.stat((conn)->vfs_opaque.handles.stat, (fname), (sbuf)))
+#define SMB_VFS_OPAQUE_STAT(conn, smb_fname) ((conn)->vfs_opaque.ops.stat((conn)->vfs_opaque.handles.stat, (smb_fname)))
#define SMB_VFS_OPAQUE_FSTAT(fsp, sbuf) ((fsp)->conn->vfs_opaque.ops.fstat((fsp)->conn->vfs_opaque.handles.fstat, (fsp), (sbuf)))
-#define SMB_VFS_OPAQUE_LSTAT(conn, path, sbuf) ((conn)->vfs_opaque.ops.lstat((conn)->vfs_opaque.handles.lstat, (path), (sbuf)))
+#define SMB_VFS_OPAQUE_LSTAT(conn, smb_fname) ((conn)->vfs_opaque.ops.lstat((conn)->vfs_opaque.handles.lstat, (smb_fname)))
#define SMB_VFS_OPAQUE_GET_ALLOC_SIZE(conn, fsp, sbuf) ((conn)->vfs_opaque.ops.get_alloc_size((conn)->vfs_opaque.handles.get_alloc_size, (fsp), (sbuf)))
#define SMB_VFS_OPAQUE_UNLINK(conn, path) ((conn)->vfs_opaque.ops.unlink((conn)->vfs_opaque.handles.unlink, (path)))
#define SMB_VFS_OPAQUE_CHMOD(conn, path, mode) ((conn)->vfs_opaque.ops.chmod((conn)->vfs_opaque.handles.chmod, (path), (mode)))
#define SMB_VFS_NEXT_RECVFILE(handle, fromfd, tofsp, offset, count) ((handle)->vfs_next.ops.recvfile((handle)->vfs_next.handles.recvfile, (fromfd), (tofsp), (offset), (count)))
#define SMB_VFS_NEXT_RENAME(handle, old, new) ((handle)->vfs_next.ops.rename((handle)->vfs_next.handles.rename, (old), (new)))
#define SMB_VFS_NEXT_FSYNC(handle, fsp) ((handle)->vfs_next.ops.fsync((handle)->vfs_next.handles.fsync, (fsp)))
-#define SMB_VFS_NEXT_STAT(handle, fname, sbuf) ((handle)->vfs_next.ops.stat((handle)->vfs_next.handles.stat, (fname), (sbuf)))
+#define SMB_VFS_NEXT_STAT(handle, smb_fname) ((handle)->vfs_next.ops.stat((handle)->vfs_next.handles.stat, (smb_fname)))
#define SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf) ((handle)->vfs_next.ops.fstat((handle)->vfs_next.handles.fstat, (fsp), (sbuf)))
-#define SMB_VFS_NEXT_LSTAT(handle, path, sbuf) ((handle)->vfs_next.ops.lstat((handle)->vfs_next.handles.lstat, (path), (sbuf)))
+#define SMB_VFS_NEXT_LSTAT(handle, smb_fname) ((handle)->vfs_next.ops.lstat((handle)->vfs_next.handles.lstat, (smb_fname)))
#define SMB_VFS_NEXT_GET_ALLOC_SIZE(conn, fsp, sbuf) ((conn)->vfs_next.ops.get_alloc_size((conn)->vfs_next.handles.get_alloc_size, (fsp), (sbuf)))
#define SMB_VFS_NEXT_UNLINK(handle, path) ((handle)->vfs_next.ops.unlink((handle)->vfs_next.handles.unlink, (path)))
#define SMB_VFS_NEXT_CHMOD(handle, path, mode) ((handle)->vfs_next.ops.chmod((handle)->vfs_next.handles.chmod, (path), (mode)))
memset(psbuf, 0, sizeof(SMB_STRUCT_STAT));
/* Get the stat struct for the owner info. */
- if (SMB_VFS_STAT(conn, filename, psbuf) != 0)
+ if (vfs_stat_smb_fname(conn, filename, psbuf) != 0)
{
DEBUG(8, ("SMB_VFS_STAT failed with error %s\n",
strerror(errno)));
ret = SMB_VFS_FSTAT(fsp, &sbuf);
} else {
if (fsp && fsp->posix_open) {
- ret = SMB_VFS_LSTAT(handle->conn, name, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn, name, &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn, name, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, name, &sbuf);
}
}
ret = SMB_VFS_FSTAT(fsp, &sbuf);
} else {
if (fsp->posix_open) {
- ret = SMB_VFS_LSTAT(handle->conn, fsp->fsp_name, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn, fsp->fsp_name,
+ &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn, fsp->fsp_name, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, fsp->fsp_name,
+ &sbuf);
}
}
return NT_STATUS_INTERNAL_DB_CORRUPTION);
if (lp_posix_pathnames()) {
- ret = SMB_VFS_LSTAT(handle->conn, fname, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn, fname, &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, fname, &sbuf);
}
if (ret == -1) {
ret = SMB_VFS_FSTAT(fsp, &sbuf);
} else {
if (fsp && fsp->posix_open) {
- ret = SMB_VFS_LSTAT(handle->conn,fname, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn,fname,
+ &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn,fname, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn,fname,
+ &sbuf);
}
}
if (ret == -1) {
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
if (lp_posix_pathnames()) {
- ret = SMB_VFS_LSTAT(handle->conn, path, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn, path, &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn, path, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, path, &sbuf);
}
if (ret == -1) {
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
if (lp_posix_pathnames()) {
- ret = SMB_VFS_LSTAT(handle->conn, path, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn, path, &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn, path, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, path, &sbuf);
}
if (ret == -1) {
}
if (fsp->is_directory || fsp->fh->fd == -1) {
if (fsp->posix_open) {
- ret = SMB_VFS_LSTAT(fsp->conn,fsp->fsp_name, &sbuf);
+ ret = vfs_lstat_smb_fname(fsp->conn,
+ fsp->fsp_name,
+ &sbuf);
} else {
- ret = SMB_VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf);
+ ret = vfs_stat_smb_fname(fsp->conn,
+ fsp->fsp_name,
+ &sbuf);
}
} else {
ret = SMB_VFS_FSTAT(fsp, &sbuf);
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
if (lp_posix_pathnames()) {
- ret = SMB_VFS_LSTAT(handle->conn, path, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn, path, &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn, path, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, path, &sbuf);
}
if (ret == -1) {
if (fsp->is_directory || fsp->fh->fd == -1) {
if (fsp->posix_open) {
- ret = SMB_VFS_LSTAT(fsp->conn,fsp->fsp_name, &sbuf);
+ ret = vfs_lstat_smb_fname(fsp->conn,fsp->fsp_name,
+ &sbuf);
} else {
- ret = SMB_VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf);
+ ret = vfs_stat_smb_fname(fsp->conn,fsp->fsp_name,
+ &sbuf);
}
} else {
ret = SMB_VFS_FSTAT(fsp, &sbuf);
ret = SMB_VFS_FSTAT(fsp, &sbuf);
} else {
if (fsp && fsp->posix_open) {
- ret = SMB_VFS_LSTAT(handle->conn,fname, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn, fname,
+ &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn,fname, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, fname,
+ &sbuf);
}
}
if (ret == -1) {
}
if (fsp->is_directory || fsp->fh->fd == -1) {
if (fsp->posix_open) {
- ret = SMB_VFS_LSTAT(fsp->conn,fsp->fsp_name, &sbuf);
+ ret = vfs_lstat_smb_fname(fsp->conn,
+ fsp->fsp_name,
+ &sbuf);
} else {
- ret = SMB_VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf);
+ ret = vfs_stat_smb_fname(fsp->conn,
+ fsp->fsp_name,
+ &sbuf);
}
} else {
ret = SMB_VFS_FSTAT(fsp, &sbuf);
SMB_STRUCT_STAT sbuf;
/* Get the stat struct for the owner info. */
- if(SMB_VFS_STAT(conn, name, &sbuf) != 0) {
+ if(vfs_stat_smb_fname(conn, name, &sbuf) != 0) {
return 0;
}
return SMB_VFS_NEXT_RENAME(handle, capold, capnew);
}
-static int cap_stat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
+static int cap_stat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
{
- char *cappath = capencode(talloc_tos(), path);
+ char *cappath;
+ char *tmp_base_name = NULL;
+ int ret;
+
+ cappath = capencode(talloc_tos(), smb_fname->base_name);
if (!cappath) {
errno = ENOMEM;
return -1;
}
- return SMB_VFS_NEXT_STAT(handle, cappath, sbuf);
+
+ tmp_base_name = smb_fname->base_name;
+ smb_fname->base_name = cappath;
+
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
+
+ smb_fname->base_name = tmp_base_name;
+ TALLOC_FREE(cappath);
+
+ return ret;
}
-static int cap_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
+static int cap_lstat(vfs_handle_struct *handle, struct smb_filename *smb_fname)
{
- char *cappath = capencode(talloc_tos(), path);
+ char *cappath;
+ char *tmp_base_name = NULL;
+ int ret;
+
+ cappath = capencode(talloc_tos(), smb_fname->base_name);
if (!cappath) {
errno = ENOMEM;
return -1;
}
- return SMB_VFS_NEXT_LSTAT(handle, cappath, sbuf);
+
+ tmp_base_name = smb_fname->base_name;
+ smb_fname->base_name = cappath;
+
+ ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
+
+ smb_fname->base_name = tmp_base_name;
+ TALLOC_FREE(cappath);
+
+ return ret;
}
static int cap_unlink(vfs_handle_struct *handle, const char *path)
}
static int catia_stat(vfs_handle_struct *handle,
- const char *fname, SMB_STRUCT_STAT *sbuf)
+ struct smb_filename *smb_fname)
{
- char *name = to_unix(talloc_tos(), fname);
+ char *name;
+ char *tmp_base_name;
+ int ret;
+ name = to_unix(talloc_tos(), smb_fname->base_name);
if (!name) {
errno = ENOMEM;
return -1;
}
- return SMB_VFS_NEXT_STAT(handle, name, sbuf);
+
+ tmp_base_name = smb_fname->base_name;
+ smb_fname->base_name = name;
+
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
+
+ smb_fname->base_name = tmp_base_name;
+ TALLOC_FREE(name);
+
+ return ret;
}
static int catia_lstat(vfs_handle_struct *handle,
- const char *path, SMB_STRUCT_STAT *sbuf)
+ struct smb_filename *smb_fname)
{
- char *name = to_unix(talloc_tos(), path);
+ char *name;
+ char *tmp_base_name;
+ int ret;
+ name = to_unix(talloc_tos(), smb_fname->base_name);
if (!name) {
errno = ENOMEM;
return -1;
}
- return SMB_VFS_NEXT_LSTAT(handle, name, sbuf);
+
+ tmp_base_name = smb_fname->base_name;
+ smb_fname->base_name = name;
+
+ ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
+
+ smb_fname->base_name = tmp_base_name;
+ TALLOC_FREE(name);
+
+ return ret;
}
static int catia_unlink(vfs_handle_struct *handle, const char *path)
#endif
}
-static int vfswrap_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
+static int vfswrap_stat(vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
{
int result;
+ NTSTATUS status;
+ char *fname = NULL;
START_PROFILE(syscall_stat);
- result = sys_stat(fname, sbuf);
+
+ 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;
+ }
+
+ result = sys_stat(fname, &smb_fname->st);
+
+ TALLOC_FREE(fname);
+
END_PROFILE(syscall_stat);
return result;
}
return result;
}
-int vfswrap_lstat(vfs_handle_struct *handle, const char *path, SMB_STRUCT_STAT *sbuf)
+static int vfswrap_lstat(vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
{
int result;
+ NTSTATUS status;
+ char *fname = NULL;
START_PROFILE(syscall_lstat);
- result = sys_lstat(path, sbuf);
+
+ 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;
+ }
+
+ result = sys_lstat(fname, &smb_fname->st);
+
+ TALLOC_FREE(fname);
+
END_PROFILE(syscall_lstat);
return result;
}
ret = SMB_VFS_FSTAT(fsp, &sbuf);
}
else {
- ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, fname, &sbuf);
}
if (ret == -1) {
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_VFS
-static int fake_perms_stat(vfs_handle_struct *handle, const char *fname, SMB_STRUCT_STAT *sbuf)
+static int fake_perms_stat(vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
{
int ret = -1;
- ret = SMB_VFS_NEXT_STAT(handle, fname, sbuf);
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
if (ret == 0) {
- if (S_ISDIR(sbuf->st_ex_mode)) {
- sbuf->st_ex_mode = S_IFDIR | S_IRWXU;
+ if (S_ISDIR(smb_fname->st.st_ex_mode)) {
+ smb_fname->st.st_ex_mode = S_IFDIR | S_IRWXU;
} else {
- sbuf->st_ex_mode = S_IRWXU;
+ smb_fname->st.st_ex_mode = S_IRWXU;
}
- sbuf->st_ex_uid = handle->conn->server_info->utok.uid;
- sbuf->st_ex_gid = handle->conn->server_info->utok.gid;
+ smb_fname->st.st_ex_uid = handle->conn->server_info->utok.uid;
+ smb_fname->st.st_ex_gid = handle->conn->server_info->utok.gid;
}
return ret;
const char *oldname, const char *newname);
static int smb_full_audit_fsync(vfs_handle_struct *handle, files_struct *fsp);
static int smb_full_audit_stat(vfs_handle_struct *handle,
- const char *fname, SMB_STRUCT_STAT *sbuf);
+ struct smb_filename *smb_fname);
static int smb_full_audit_fstat(vfs_handle_struct *handle, files_struct *fsp,
SMB_STRUCT_STAT *sbuf);
static int smb_full_audit_lstat(vfs_handle_struct *handle,
- const char *path, SMB_STRUCT_STAT *sbuf);
+ struct smb_filename *smb_fname);
static int smb_full_audit_get_alloc_size(vfs_handle_struct *handle,
files_struct *fsp, const SMB_STRUCT_STAT *sbuf);
static int smb_full_audit_unlink(vfs_handle_struct *handle,
}
static int smb_full_audit_stat(vfs_handle_struct *handle,
- const char *fname, SMB_STRUCT_STAT *sbuf)
+ struct smb_filename *smb_fname)
{
int result;
- result = SMB_VFS_NEXT_STAT(handle, fname, sbuf);
+ result = SMB_VFS_NEXT_STAT(handle, smb_fname);
- do_log(SMB_VFS_OP_STAT, (result >= 0), handle, "%s", fname);
+ do_log(SMB_VFS_OP_STAT, (result >= 0), handle, "%s",
+ smb_fname_str_dbg(smb_fname));
return result;
}
}
static int smb_full_audit_lstat(vfs_handle_struct *handle,
- const char *path, SMB_STRUCT_STAT *sbuf)
+ struct smb_filename *smb_fname)
{
int result;
- result = SMB_VFS_NEXT_LSTAT(handle, path, sbuf);
+ result = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
- do_log(SMB_VFS_OP_LSTAT, (result >= 0), handle, "%s", path);
+ do_log(SMB_VFS_OP_LSTAT, (result >= 0), handle, "%s",
+ smb_fname_str_dbg(smb_fname));
return result;
}
return size;
}
-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) {
+ 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) {
+ 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;
}
* that has _not_ been specified in "type" from the file first
* and concatenate it with the acl provided.
*/
- if (SMB_VFS_STAT(handle->conn, name, &s) != 0) {
+ if (vfs_stat_smb_fname(handle->conn, name, &s) != 0) {
DEBUG(10, ("Error in stat call: %s\n", strerror(errno)));
goto done;
}
{
SMB_STRUCT_STAT st;
- if (SMB_VFS_NEXT_STAT(handle, dname, &st) == 0) {
+ if (vfs_stat_smb_fname(handle->conn, dname, &st) == 0) {
if (S_ISDIR(st.st_ex_mode)) {
return True;
}
{
SMB_STRUCT_STAT st;
- if (SMB_VFS_NEXT_STAT(handle, fname, &st) == 0) {
+ if (vfs_stat_smb_fname(handle->conn, fname, &st) == 0) {
if (S_ISREG(st.st_ex_mode)) {
return True;
}
{
SMB_STRUCT_STAT st;
- if (SMB_VFS_NEXT_STAT(handle, fname, &st) != 0) {
+ if (vfs_stat_smb_fname(handle->conn, fname, &st) != 0) {
DEBUG(0,("recycle: stat for %s returned %s\n", fname, strerror(errno)));
return (SMB_OFF_T)0;
}
ZERO_STRUCT(ft);
- if (SMB_VFS_NEXT_STAT(handle, fname, &st) != 0) {
+ if (vfs_stat_smb_fname(handle->conn, fname, &st) != 0) {
DEBUG(0,("recycle: stat for %s returned %s\n",
fname, strerror(errno)));
return;
}
static int shadow_copy2_stat(vfs_handle_struct *handle,
- const char *fname, SMB_STRUCT_STAT *sbuf)
+ struct smb_filename *smb_fname)
{
- _SHADOW2_NEXT(STAT, (handle, name, sbuf), int, -1, convert_sbuf(handle, fname, sbuf));
+ _SHADOW2_NEXT_SMB_FNAME(STAT, (handle, smb_fname), int, -1,
+ convert_sbuf(handle, smb_fname->base_name,
+ &smb_fname->st));
}
static int shadow_copy2_lstat(vfs_handle_struct *handle,
- const char *fname, SMB_STRUCT_STAT *sbuf)
+ struct smb_filename *smb_fname)
{
- _SHADOW2_NEXT(LSTAT, (handle, name, sbuf), int, -1, convert_sbuf(handle, fname, sbuf));
+ _SHADOW2_NEXT_SMB_FNAME(LSTAT, (handle, smb_fname), int, -1,
+ convert_sbuf(handle, smb_fname->base_name,
+ &smb_fname->st));
}
static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp, SMB_STRUCT_STAT *sbuf)
* that has not been specified in "type" from the file first
* and concatenate it with the acl provided.
*/
- if (SMB_VFS_STAT(handle->conn, name, &s) != 0) {
+ if (vfs_stat_smb_fname(handle->conn, name, &s) != 0) {
DEBUG(10, ("Error in stat call: %s\n", strerror(errno)));
goto done;
}
return true;
}
-static char *stream_dir(vfs_handle_struct *handle, const char *base_path,
+/**
+ * Given an smb_filename, determine the stream directory using the file's
+ * base_name.
+ */
+static char *stream_dir(vfs_handle_struct *handle,
+ const struct smb_filename *smb_fname,
const SMB_STRUCT_STAT *base_sbuf, bool create_it)
{
uint32_t hash;
+ struct smb_filename *smb_fname_hash = NULL;
char *result = NULL;
- SMB_STRUCT_STAT sbuf;
+ SMB_STRUCT_STAT base_sbuf_tmp;
uint8_t first, second;
char *tmp;
char *id_hex;
uint8 id_buf[16];
bool check_valid;
const char *rootdir;
+ NTSTATUS status;
check_valid = lp_parm_bool(SNUM(handle->conn),
"streams_depot", "check_valid", true);
SNUM(handle->conn), "streams_depot", "directory",
tmp);
+ /* Stat the base file if it hasn't already been done. */
if (base_sbuf == NULL) {
- if (SMB_VFS_NEXT_STAT(handle, base_path, &sbuf) == -1) {
- /*
- * base file is not there
- */
+ 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);
+ goto fail;
+ }
+ if (SMB_VFS_NEXT_STAT(handle, smb_fname_base) == -1) {
+ TALLOC_FREE(smb_fname_base);
goto fail;
}
- base_sbuf = &sbuf;
+ base_sbuf_tmp = smb_fname_base->st;
+ TALLOC_FREE(smb_fname_base);
+ } else {
+ base_sbuf_tmp = *base_sbuf;
}
- id = SMB_VFS_FILE_ID_CREATE(handle->conn, base_sbuf);
+ id = SMB_VFS_FILE_ID_CREATE(handle->conn, &base_sbuf_tmp);
push_file_id_16((char *)id_buf, &id);
return NULL;
}
- if (SMB_VFS_NEXT_STAT(handle, result, &sbuf) == 0) {
+ 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);
+ goto fail;
+ }
+
+ if (SMB_VFS_NEXT_STAT(handle, smb_fname_hash) == 0) {
char *newname;
- if (!S_ISDIR(sbuf.st_ex_mode)) {
+ if (!S_ISDIR(smb_fname_hash->st.st_ex_mode)) {
errno = EINVAL;
goto fail;
}
- if (file_is_valid(handle, base_path, check_valid)) {
+ if (file_is_valid(handle, smb_fname->base_name, check_valid)) {
return result;
}
goto fail;
}
- if (!mark_file_valid(handle, base_path, check_valid)) {
+ if (!mark_file_valid(handle, smb_fname->base_name, check_valid)) {
goto fail;
}
+ TALLOC_FREE(smb_fname_hash);
return result;
fail:
+ TALLOC_FREE(smb_fname_hash);
TALLOC_FREE(result);
return NULL;
}
*smb_fname_out = NULL;
- dirname = stream_dir(handle, smb_fname->base_name, NULL, create_dir);
+ dirname = stream_dir(handle, smb_fname, NULL, create_dir);
if (dirname == NULL) {
status = map_nt_error_from_unix(errno);
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);
+ status = create_synthetic_smb_fname(talloc_tos(), stream_fname, NULL,
+ NULL, smb_fname_out);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
return status;
}
+/*
+ * XXX: This function should be removed after the other vfs ops take
+ * smb_filename structs
+ */
static char *stream_name(vfs_handle_struct *handle, const char *fname,
bool create_dir)
{
- char *base = NULL;
+ struct smb_filename *smb_fname = NULL;
+ struct smb_filename *smb_fname_stream = NULL;
char *sname = NULL;
- char *id_hex = NULL;
- char *dirname, *stream_fname;
-
- if (!NT_STATUS_IS_OK(split_ntfs_stream_name(talloc_tos(), fname,
- &base, &sname))) {
- DEBUG(10, ("split_ntfs_stream_name failed\n"));
- errno = ENOMEM;
- goto fail;
- }
+ NTSTATUS status;
- /* if it's the ::$DATA stream just return the base file name */
- if (!sname) {
- return base;
+ status = create_synthetic_smb_fname_split(talloc_tos(), fname,
+ NULL, &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ goto out;
}
- dirname = stream_dir(handle, base, NULL, create_dir);
-
- if (dirname == NULL) {
- goto fail;
+ status = stream_smb_fname(handle, smb_fname, &smb_fname_stream,
+ create_dir);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ goto out;
}
- stream_fname = talloc_asprintf(talloc_tos(), "%s/:%s", dirname, sname);
-
- if (stream_fname == NULL) {
- errno = ENOMEM;
- goto fail;
+ status = get_full_smb_filename(talloc_tos(), smb_fname_stream,
+ &sname);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ goto out;
}
+ out:
+ TALLOC_FREE(smb_fname);
+ TALLOC_FREE(smb_fname_stream);
- DEBUG(10, ("stream filename = %s\n", stream_fname));
-
- TALLOC_FREE(base);
- TALLOC_FREE(sname);
- TALLOC_FREE(id_hex);
-
- return stream_fname;
-
- fail:
- DEBUG(5, ("stream_name failed: %s\n", strerror(errno)));
- TALLOC_FREE(base);
- TALLOC_FREE(sname);
- TALLOC_FREE(id_hex);
- return NULL;
+ return sname;
}
static NTSTATUS walk_streams(vfs_handle_struct *handle,
- const char *fname,
- const SMB_STRUCT_STAT *sbuf,
+ struct smb_filename *smb_fname_base,
char **pdirname,
bool (*fn)(const char *dirname,
const char *dirent,
SMB_STRUCT_DIR *dirhandle = NULL;
char *dirent;
- dirname = stream_dir(handle, fname, sbuf, false);
+ dirname = stream_dir(handle, smb_fname_base, &smb_fname_base->st,
+ false);
if (dirname == NULL) {
if (errno == ENOENT) {
return NT_STATUS_OK;
}
-static int streams_depot_stat(vfs_handle_struct *handle, const char *fname,
- SMB_STRUCT_STAT *sbuf)
+/**
+ * Helper to stat/lstat the base file of an smb_fname. This will actually
+ * fills in the stat struct in smb_filename.
+ */
+static int streams_depot_stat_base(vfs_handle_struct *handle,
+ struct smb_filename *smb_fname,
+ bool follow_links)
{
- char *stream_fname;
+ 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 streams_depot_stat(vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
+{
+ struct smb_filename *smb_fname_stream = NULL;
+ NTSTATUS status;
int ret = -1;
- DEBUG(10, ("streams_depot_stat called for [%s]\n", fname));
+ DEBUG(10, ("streams_depot_stat called for [%s]\n",
+ smb_fname_str_dbg(smb_fname)));
- if (!is_ntfs_stream_name(fname)) {
- return SMB_VFS_NEXT_STAT(handle, fname, sbuf);
+ if (!is_ntfs_stream_smb_fname(smb_fname)) {
+ return SMB_VFS_NEXT_STAT(handle, smb_fname);
}
- stream_fname = stream_name(handle, fname, false);
- if (stream_fname == NULL) {
+ /* If the default stream is requested, just stat the base file. */
+ if (is_ntfs_default_stream_smb_fname(smb_fname)) {
+ return streams_depot_stat_base(handle, smb_fname, true);
+ }
+
+ /* Stat the actual stream now. */
+ status = stream_smb_fname(handle, smb_fname, &smb_fname_stream,
+ false);
+ if (!NT_STATUS_IS_OK(status)) {
+ ret = -1;
+ errno = map_errno_from_nt_status(status);
goto done;
}
- ret = SMB_VFS_NEXT_STAT(handle, stream_fname, sbuf);
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname_stream);
+ /* Update the original smb_fname with the stat info. */
+ smb_fname->st = smb_fname_stream->st;
done:
- TALLOC_FREE(stream_fname);
+ TALLOC_FREE(smb_fname_stream);
return ret;
}
-static int streams_depot_lstat(vfs_handle_struct *handle, const char *fname,
- SMB_STRUCT_STAT *sbuf)
+
+
+static int streams_depot_lstat(vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
{
- char *stream_fname;
+ struct smb_filename *smb_fname_stream = NULL;
+ NTSTATUS status;
int ret = -1;
- if (!is_ntfs_stream_name(fname)) {
- return SMB_VFS_NEXT_LSTAT(handle, fname, sbuf);
+ DEBUG(10, ("streams_depot_lstat called for [%s]\n",
+ smb_fname_str_dbg(smb_fname)));
+
+ if (!is_ntfs_stream_smb_fname(smb_fname)) {
+ return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
}
- stream_fname = stream_name(handle, fname, false);
- if (stream_fname == NULL) {
+ /* If the default stream is requested, just stat the base file. */
+ if (is_ntfs_default_stream_smb_fname(smb_fname)) {
+ return streams_depot_stat_base(handle, smb_fname, false);
+ }
+
+ /* Stat the actual stream now. */
+ status = stream_smb_fname(handle, smb_fname, &smb_fname_stream,
+ false);
+ if (!NT_STATUS_IS_OK(status)) {
+ ret = -1;
+ errno = map_errno_from_nt_status(status);
goto done;
}
- ret = SMB_VFS_NEXT_LSTAT(handle, stream_fname, sbuf);
+ ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_stream);
done:
- TALLOC_FREE(stream_fname);
+ TALLOC_FREE(smb_fname_stream);
return ret;
}
files_struct *fsp, int flags, mode_t mode)
{
struct smb_filename *smb_fname_stream = NULL;
- SMB_STRUCT_STAT base_sbuf;
+ struct smb_filename *smb_fname_base = NULL;
NTSTATUS status;
int ret = -1;
tmp_stream_name = smb_fname->stream_name;
smb_fname->stream_name = NULL;
-
ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
-
smb_fname->stream_name = tmp_stream_name;
return ret;
}
/* Ensure the base file still exists. */
- ret = SMB_VFS_NEXT_STAT(handle, smb_fname->base_name, &base_sbuf);
+ status = create_synthetic_smb_fname(talloc_tos(),
+ smb_fname->base_name,
+ NULL, NULL,
+ &smb_fname_base);
+ if (!NT_STATUS_IS_OK(status)) {
+ ret = -1;
+ errno = map_errno_from_nt_status(status);
+ goto done;
+ }
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname_base);
if (ret == -1) {
goto done;
}
+ /* Determine the stream name, and then open it. */
status = stream_smb_fname(handle, smb_fname, &smb_fname_stream, true);
if (!NT_STATUS_IS_OK(status)) {
ret = -1;
done:
TALLOC_FREE(smb_fname_stream);
+ TALLOC_FREE(smb_fname_base);
return ret;
}
static int streams_depot_unlink(vfs_handle_struct *handle, const char *fname)
{
+ struct smb_filename *smb_fname_base = NULL;
+ NTSTATUS status;
int ret = -1;
- SMB_STRUCT_STAT sbuf;
DEBUG(10, ("streams_depot_unlink called for %s\n", fname));
* We potentially need to delete the per-inode streams directory
*/
+ status = create_synthetic_smb_fname(talloc_tos(), fname, NULL, NULL,
+ &smb_fname_base);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+
if (lp_posix_pathnames()) {
- ret = SMB_VFS_NEXT_LSTAT(handle, fname, &sbuf);
+ ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_base);
} else {
- ret = SMB_VFS_NEXT_STAT(handle, fname, &sbuf);
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname_base);
}
if (ret == -1) {
+ TALLOC_FREE(smb_fname_base);
return -1;
}
- if (sbuf.st_ex_nlink == 1) {
- char *dirname = stream_dir(handle, fname, &sbuf, false);
+ if (smb_fname_base->st.st_ex_nlink == 1) {
+ char *dirname = stream_dir(handle, smb_fname_base,
+ &smb_fname_base->st, false);
if (dirname != NULL) {
SMB_VFS_NEXT_RMDIR(handle, dirname);
TALLOC_FREE(dirname);
}
+ TALLOC_FREE(smb_fname_base);
+
return SMB_VFS_NEXT_UNLINK(handle, fname);
}
{
struct streaminfo_state *state =
(struct streaminfo_state *)private_data;
- char *full_sname;
- SMB_STRUCT_STAT sbuf;
+ struct smb_filename *smb_fname = NULL;
+ char *sname = NULL;
+ NTSTATUS status;
+ bool ret;
- if (asprintf(&full_sname, "%s/%s", dirname, dirent) == -1) {
+ sname = talloc_asprintf(talloc_tos(), "%s/%s", dirname, dirent);
+ if (sname == NULL) {
state->status = NT_STATUS_NO_MEMORY;
- return false;
+ ret = false;
+ goto out;
}
- if (SMB_VFS_NEXT_STAT(state->handle, full_sname, &sbuf) == -1) {
- DEBUG(10, ("Could not stat %s: %s\n", full_sname,
- strerror(errno)));
- SAFE_FREE(full_sname);
- return true;
+
+ status = create_synthetic_smb_fname(talloc_tos(), sname, NULL,
+ NULL, &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ state->status = status;
+ ret = false;
+ goto out;
}
- SAFE_FREE(full_sname);
+ if (SMB_VFS_NEXT_STAT(state->handle, smb_fname) == -1) {
+ DEBUG(10, ("Could not stat %s: %s\n", sname,
+ strerror(errno)));
+ ret = true;
+ goto out;
+ }
if (!add_one_stream(state->mem_ctx,
&state->num_streams, &state->streams,
- dirent, sbuf.st_ex_size,
+ dirent, smb_fname->st.st_ex_size,
SMB_VFS_GET_ALLOC_SIZE(state->handle->conn, NULL,
- &sbuf))) {
+ &smb_fname->st))) {
state->status = NT_STATUS_NO_MEMORY;
- return false;
+ ret = false;
+ goto out;
}
- return true;
+ ret = true;
+ out:
+ TALLOC_FREE(sname);
+ TALLOC_FREE(smb_fname);
+ return ret;
}
static NTSTATUS streams_depot_streaminfo(vfs_handle_struct *handle,
unsigned int *pnum_streams,
struct stream_struct **pstreams)
{
- SMB_STRUCT_STAT sbuf;
+ struct smb_filename *smb_fname_base = NULL;
int ret;
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;
+ }
+
if ((fsp != NULL) && (fsp->fh->fd != -1)) {
if (is_ntfs_stream_name(fsp->fsp_name)) {
return NT_STATUS_INVALID_PARAMETER;
}
- ret = SMB_VFS_NEXT_FSTAT(handle, fsp, &sbuf);
+ ret = SMB_VFS_NEXT_FSTAT(handle, fsp, &smb_fname_base->st);
}
else {
if (is_ntfs_stream_name(fname)) {
return NT_STATUS_INVALID_PARAMETER;
}
if (lp_posix_pathnames()) {
- ret = SMB_VFS_NEXT_LSTAT(handle, fname, &sbuf);
+ ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_base);
} else {
- ret = SMB_VFS_NEXT_STAT(handle, fname, &sbuf);
+ ret = SMB_VFS_NEXT_STAT(handle, smb_fname_base);
}
}
if (ret == -1) {
- return map_nt_error_from_unix(errno);
+ status = map_nt_error_from_unix(errno);
+ goto out;
}
state.streams = NULL;
state.num_streams = 0;
- if (!S_ISDIR(sbuf.st_ex_mode)) {
+ if (!S_ISDIR(smb_fname_base->st.st_ex_mode)) {
if (!add_one_stream(mem_ctx,
&state.num_streams, &state.streams,
- "::$DATA", sbuf.st_ex_size,
+ "::$DATA", smb_fname_base->st.st_ex_size,
SMB_VFS_GET_ALLOC_SIZE(handle->conn, fsp,
- &sbuf))) {
- return NT_STATUS_NO_MEMORY;
+ &smb_fname_base->st))) {
+ status = NT_STATUS_NO_MEMORY;
+ goto out;
}
}
state.handle = handle;
state.status = NT_STATUS_OK;
- status = walk_streams(handle, fname, &sbuf, NULL, collect_one_stream,
+ status = walk_streams(handle, smb_fname_base, NULL, collect_one_stream,
&state);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(state.streams);
- return status;
+ goto out;
}
if (!NT_STATUS_IS_OK(state.status)) {
TALLOC_FREE(state.streams);
- return state.status;
+ status = state.status;
+ goto out;
}
*pnum_streams = state.num_streams;
*pstreams = state.streams;
- return NT_STATUS_OK;
+ status = NT_STATUS_OK;
+
+ out:
+ TALLOC_FREE(smb_fname_base);
+ return status;
}
static uint32_t streams_depot_fs_capabilities(struct vfs_handle_struct *handle)
return true;
}
+/**
+ * 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 streams_xattr_fstat(vfs_handle_struct *handle, files_struct *fsp,
SMB_STRUCT_STAT *sbuf)
{
+ struct smb_filename *smb_fname_base = NULL;
+ NTSTATUS status;
int ret = -1;
struct stream_io *io = (struct stream_io *)
VFS_FETCH_FSP_EXTENSION(handle, fsp);
return -1;
}
+ /* Create an smb_filename with stream_name == NULL. */
+ status = create_synthetic_smb_fname(talloc_tos(),
+ io->base,
+ NULL, NULL,
+ &smb_fname_base);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+
if (lp_posix_pathnames()) {
- ret = SMB_VFS_LSTAT(handle->conn, io->base, sbuf);
+ ret = SMB_VFS_LSTAT(handle->conn, smb_fname_base);
} else {
- ret = SMB_VFS_STAT(handle->conn, io->base, sbuf);
+ ret = SMB_VFS_STAT(handle->conn, smb_fname_base);
}
+ *sbuf = smb_fname_base->st;
+ TALLOC_FREE(smb_fname_base);
if (ret == -1) {
return -1;
return 0;
}
-static int streams_xattr_stat(vfs_handle_struct *handle, const char *fname,
- SMB_STRUCT_STAT *sbuf)
+static int streams_xattr_stat(vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
{
NTSTATUS status;
- char *base = NULL, *sname = NULL;
int result = -1;
- char *xattr_name;
-
- if (!is_ntfs_stream_name(fname)) {
- return SMB_VFS_NEXT_STAT(handle, fname, sbuf);
- }
+ char *xattr_name = NULL;
- status = split_ntfs_stream_name(talloc_tos(), fname, &base, &sname);
- if (!NT_STATUS_IS_OK(status)) {
- errno = EINVAL;
- return -1;
+ if (!is_ntfs_stream_smb_fname(smb_fname)) {
+ return SMB_VFS_NEXT_STAT(handle, smb_fname);
}
- if (sname == NULL){
- return SMB_VFS_NEXT_STAT(handle, base, sbuf);
+ /* 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);
}
- if (SMB_VFS_STAT(handle->conn, base, sbuf) == -1) {
- goto fail;
+ /* Populate the stat struct with info from the base file. */
+ if (streams_xattr_stat_base(handle, smb_fname, true) == -1) {
+ return -1;
}
- xattr_name = talloc_asprintf(talloc_tos(), "%s%s",
- SAMBA_XATTR_DOSSTREAM_PREFIX, sname);
- if (xattr_name == NULL) {
- errno = ENOMEM;
- goto fail;
+ /* Derive the xattr name to lookup. */
+ status = streams_xattr_get_name(talloc_tos(), smb_fname->stream_name,
+ &xattr_name);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
}
- sbuf->st_ex_size = get_xattr_size(handle->conn, NULL, base, xattr_name);
- if (sbuf->st_ex_size == -1) {
+ /* Augment the base file's stat information before returning. */
+ smb_fname->st.st_ex_size = get_xattr_size(handle->conn, NULL,
+ smb_fname->base_name,
+ xattr_name);
+ if (smb_fname->st.st_ex_size == -1) {
errno = ENOENT;
+ result = -1;
goto fail;
}
- sbuf->st_ex_ino = stream_inode(sbuf, xattr_name);
- sbuf->st_ex_mode &= ~S_IFMT;
- sbuf->st_ex_mode |= S_IFREG;
- sbuf->st_ex_blocks = sbuf->st_ex_size % STAT_ST_BLOCKSIZE + 1;
+ 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_IFREG;
+ smb_fname->st.st_ex_blocks =
+ smb_fname->st.st_ex_size % STAT_ST_BLOCKSIZE + 1;
result = 0;
fail:
- TALLOC_FREE(base);
- TALLOC_FREE(sname);
+ TALLOC_FREE(xattr_name);
return result;
}
-static int streams_xattr_lstat(vfs_handle_struct *handle, const char *fname,
- SMB_STRUCT_STAT *sbuf)
+static int streams_xattr_lstat(vfs_handle_struct *handle,
+ struct smb_filename *smb_fname)
{
NTSTATUS status;
- char *base, *sname;
int result = -1;
- char *xattr_name;
-
- if (!is_ntfs_stream_name(fname)) {
- return SMB_VFS_NEXT_LSTAT(handle, fname, sbuf);
- }
+ char *xattr_name = NULL;
- status = split_ntfs_stream_name(talloc_tos(), fname, &base, &sname);
- if (!NT_STATUS_IS_OK(status)) {
- errno = EINVAL;
- goto fail;
+ if (!is_ntfs_stream_smb_fname(smb_fname)) {
+ return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
}
- if (sname == NULL){
- return SMB_VFS_NEXT_LSTAT(handle, base, sbuf);
+ /* 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, false);
}
- if (SMB_VFS_LSTAT(handle->conn, base, sbuf) == -1) {
- goto fail;
+ /* Populate the stat struct with info from the base file. */
+ if (streams_xattr_stat_base(handle, smb_fname, false) == -1) {
+ return -1;
}
- xattr_name = talloc_asprintf(talloc_tos(), "%s%s",
- SAMBA_XATTR_DOSSTREAM_PREFIX, sname);
- if (xattr_name == NULL) {
- errno = ENOMEM;
- goto fail;
+ /* Derive the xattr name to lookup. */
+ status = streams_xattr_get_name(talloc_tos(), smb_fname->stream_name,
+ &xattr_name);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
}
- sbuf->st_ex_size = get_xattr_size(handle->conn, NULL, base, xattr_name);
- if (sbuf->st_ex_size == -1) {
+ /* Augment the base file's stat information before returning. */
+ smb_fname->st.st_ex_size = get_xattr_size(handle->conn, NULL,
+ smb_fname->base_name,
+ xattr_name);
+ if (smb_fname->st.st_ex_size == -1) {
errno = ENOENT;
+ result = -1;
goto fail;
}
- sbuf->st_ex_ino = stream_inode(sbuf, xattr_name);
- sbuf->st_ex_mode &= ~S_IFMT;
- sbuf->st_ex_mode |= S_IFREG;
- sbuf->st_ex_blocks = sbuf->st_ex_size % STAT_ST_BLOCKSIZE + 1;
+ 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_IFREG;
+ smb_fname->st.st_ex_blocks =
+ smb_fname->st.st_ex_size % STAT_ST_BLOCKSIZE + 1;
result = 0;
+
fail:
- TALLOC_FREE(base);
- TALLOC_FREE(sname);
+ TALLOC_FREE(xattr_name);
return result;
}
return NT_STATUS_INVALID_PARAMETER;
}
if (lp_posix_pathnames()) {
- ret = SMB_VFS_LSTAT(handle->conn, fname, &sbuf);
+ ret = vfs_lstat_smb_fname(handle->conn, fname, &sbuf);
} else {
- ret = SMB_VFS_STAT(handle->conn, fname, &sbuf);
+ ret = vfs_stat_smb_fname(handle->conn, fname, &sbuf);
}
}
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
- if (SMB_VFS_STAT(handle->conn, path, &sbuf) == -1) {
+ if (vfs_stat_smb_fname(handle->conn, path, &sbuf) == -1) {
return -1;
}
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
- if (SMB_VFS_STAT(handle->conn, path, &sbuf) == -1) {
+ if (vfs_stat_smb_fname(handle->conn, path, &sbuf) == -1) {
return -1;
}
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
- if (SMB_VFS_STAT(handle->conn, path, &sbuf) == -1) {
+ if (vfs_stat_smb_fname(handle->conn, path, &sbuf) == -1) {
return -1;
}
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
- if (SMB_VFS_STAT(handle->conn, path, &sbuf) == -1) {
+ if (vfs_stat_smb_fname(handle->conn, path, &sbuf) == -1) {
return -1;
}
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
- if (SMB_VFS_STAT(handle->conn, path, &sbuf) == -1) {
+ if (vfs_stat_smb_fname(handle->conn, path, &sbuf) == -1) {
return -1;
}
SMB_VFS_HANDLE_GET_DATA(handle, db, struct db_context, return -1);
- if (SMB_VFS_STAT(handle->conn, path, &sbuf) == -1) {
+ if (vfs_stat_smb_fname(handle->conn, path, &sbuf) == -1) {
return -1;
}
hasn't been renamed. */
if (fsp->posix_open) {
- ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf);
+ ret = vfs_lstat_smb_fname(conn,fsp->fsp_name,&sbuf);
} else {
- ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
+ ret = vfs_stat_smb_fname(conn,fsp->fsp_name,&sbuf);
}
if (ret != 0) {
ret = SMB_VFS_FSTAT(fsp, &sbuf);
} else {
if (fsp->posix_open) {
- ret = SMB_VFS_LSTAT(fsp->conn,fsp->fsp_name,&sbuf);
+ ret = vfs_lstat_smb_fname(fsp->conn, fsp->fsp_name,
+ &sbuf);
} else {
- ret = SMB_VFS_STAT(fsp->conn,fsp->fsp_name,&sbuf);
+ ret = vfs_stat_smb_fname(fsp->conn, fsp->fsp_name,
+ &sbuf);
}
}
long *poffset,
SMB_STRUCT_STAT *pst)
{
+ struct smb_filename *smb_fname_base = NULL;
char *name = NULL;
char *pathreal = NULL;
char *found_name = NULL;
int ret;
const char *name_temp = NULL;
+ NTSTATUS status;
SET_STAT_INVALID(*pst);
if (!pathreal)
return NULL;
- if (SMB_VFS_STAT(dptr->conn, pathreal, pst) == 0) {
+ /* Create an smb_filename with stream_name == NULL. */
+ status = create_synthetic_smb_fname(ctx, pathreal, NULL, NULL,
+ &smb_fname_base);
+ if (!NT_STATUS_IS_OK(status)) {
+ return NULL;
+ }
+
+ if (SMB_VFS_STAT(dptr->conn, smb_fname_base) == 0) {
+ *pst = smb_fname_base->st;
+ TALLOC_FREE(smb_fname_base);
name = talloc_strdup(ctx, dptr->wcard);
goto clean;
} else {
+ TALLOC_FREE(smb_fname_base);
/* If we get any other error than ENOENT or ENOTDIR
then the file exists we just can't stat it. */
if (errno != ENOENT && errno != ENOTDIR) {
return False;
}
- if (!VALID_STAT(sbuf) && (SMB_VFS_STAT(conn, pathreal, &sbuf)) != 0) {
- DEBUG(5,("Couldn't stat 1 [%s]. Error = %s\n",
- pathreal, strerror(errno) ));
- TALLOC_FREE(pathreal);
- TALLOC_FREE(filename);
- continue;
+ if (!VALID_STAT(sbuf)) {
+ struct smb_filename *smb_fname = NULL;
+ NTSTATUS status;
+
+ /* Create smb_fname with NULL stream_name. */
+ status =
+ create_synthetic_smb_fname(ctx, pathreal,
+ NULL, NULL,
+ &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(pathreal);
+ TALLOC_FREE(filename);
+ return NULL;
+ }
+
+ if ((SMB_VFS_STAT(conn, smb_fname)) != 0) {
+ DEBUG(5,("Couldn't stat 1 [%s]. Error "
+ "= %s\n", pathreal,
+ strerror(errno)));
+ TALLOC_FREE(smb_fname);
+ TALLOC_FREE(pathreal);
+ TALLOC_FREE(filename);
+ continue;
+ }
+ sbuf = smb_fname->st;
+ TALLOC_FREE(smb_fname);
}
*mode = dos_mode(conn,pathreal,&sbuf);
use it for anything security sensitive.
********************************************************************/
-static bool user_can_read_file(connection_struct *conn, char *name)
+static bool user_can_read_file(connection_struct *conn,
+ struct smb_filename *smb_fname)
{
/*
* If user is a member of the Admin group
return True;
}
- return can_access_file_acl(conn, name, FILE_READ_DATA);
+ return can_access_file_acl(conn, smb_fname, FILE_READ_DATA);
}
/*******************************************************************
bool hide_unreadable = lp_hideunreadable(SNUM(conn));
bool hide_unwriteable = lp_hideunwriteable_files(SNUM(conn));
bool hide_special = lp_hide_special_files(SNUM(conn));
+ char *entry = NULL;
+ struct smb_filename *smb_fname_base = NULL;
+ NTSTATUS status;
+ bool ret = false;
if ((strcmp(".",name) == 0) || (strcmp("..",name) == 0)) {
return True; /* . and .. are always visible. */
}
if (hide_unreadable || hide_unwriteable || hide_special) {
- char *entry = NULL;
-
entry = talloc_asprintf(talloc_tos(), "%s/%s", dir_path, name);
- if (!entry)
- return false;
+ if (!entry) {
+ ret = false;
+ goto out;
}
/* If it's a dfs symlink, ignore _hide xxxx_ options */
if (lp_host_msdfs() &&
lp_msdfs_root(SNUM(conn)) &&
is_msdfs_link(conn, entry, NULL)) {
- TALLOC_FREE(entry);
- return true;
+ ret = true;
+ goto out;
+ }
+
+ /* Create an smb_filename with stream_name == NULL. */
+ status = create_synthetic_smb_fname(talloc_tos(), entry, NULL,
+ NULL, &smb_fname_base);
+ if (!NT_STATUS_IS_OK(status)) {
+ ret = false;
+ goto out;
}
/* If the file name does not exist, there's no point checking
* the configuration options. We succeed, on the basis that the
* checks *might* have passed if the file was present.
*/
- if (!VALID_STAT(*pst) && (SMB_VFS_STAT(conn, entry, pst) != 0))
+ if (!VALID_STAT(*pst) &&
+ (SMB_VFS_STAT(conn, smb_fname_base) != 0))
{
- TALLOC_FREE(entry);
- return true;
+ ret = true;
+ goto out;
}
+ *pst = smb_fname_base->st;
+
/* Honour _hide unreadable_ option */
- if (hide_unreadable && !user_can_read_file(conn, entry)) {
+ if (hide_unreadable &&
+ !user_can_read_file(conn, smb_fname_base)) {
DEBUG(10,("is_visible_file: file %s is unreadable.\n",
entry ));
- TALLOC_FREE(entry);
- return false;
+ ret = false;
+ goto out;
}
/* Honour _hide unwriteable_ option */
if (hide_unwriteable && !user_can_write_file(conn, entry, pst)) {
DEBUG(10,("is_visible_file: file %s is unwritable.\n",
entry ));
- TALLOC_FREE(entry);
- return false;
+ ret = false;
+ goto out;
}
/* Honour _hide_special_ option */
if (hide_special && file_is_special(conn, entry, pst)) {
DEBUG(10,("is_visible_file: file %s is special.\n",
entry ));
- TALLOC_FREE(entry);
- return false;
+ ret = false;
+ goto out;
}
- TALLOC_FREE(entry);
}
- return true;
+
+ ret = true;
+ out:
+ TALLOC_FREE(smb_fname_base);
+ TALLOC_FREE(entry);
+ return ret;
}
static int smb_Dir_destructor(struct smb_Dir *dirp)
DEBUG(2, ("unix_mode(%s) inheriting from %s\n", fname,
inherit_from_dir));
- if (SMB_VFS_STAT(conn, inherit_from_dir, &sbuf) != 0) {
+ if (vfs_stat_smb_fname(conn, inherit_from_dir, &sbuf) != 0) {
DEBUG(4,("unix_mode(%s) failed, [dir %s]: %s\n", fname,
inherit_from_dir, strerror(errno)));
return(0); /* *** shouldn't happen! *** */
}
if (!VALID_STAT(*st)) {
- if (SMB_VFS_STAT(conn,fname,st))
+ if (vfs_stat_smb_fname(conn,fname,st))
return(-1);
}
* Security descriptor / NT Token level access check function.
*/
bool can_access_file_acl(struct connection_struct *conn,
- const char * fname,
- uint32_t access_mask)
+ const struct smb_filename *smb_fname,
+ uint32_t access_mask)
{
NTSTATUS status;
uint32_t access_granted;
struct security_descriptor *secdesc = NULL;
+ char *fname = NULL;
+ bool ret;
if (conn->server_info->utok.uid == 0 || conn->admin_user) {
/* I'm sorry sir, I didn't know you were root... */
return true;
}
+ status = get_full_smb_filename(talloc_tos(), smb_fname, &fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ ret = false;
+ goto out;
+ }
+
status = SMB_VFS_GET_NT_ACL(conn, fname,
(OWNER_SECURITY_INFORMATION |
GROUP_SECURITY_INFORMATION |
&secdesc);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5, ("Could not get acl: %s\n", nt_errstr(status)));
- return false;
+ ret = false;
+ goto out;
}
status = se_access_check(secdesc, conn->server_info->ptok,
access_mask, &access_granted);
+ ret = NT_STATUS_IS_OK(status);
+ out:
+ TALLOC_FREE(fname);
TALLOC_FREE(secdesc);
- return NT_STATUS_IS_OK(status);
+ return ret;
}
/****************************************************************************
****************************************************************************/
bool can_delete_file_in_directory(connection_struct *conn,
- const struct smb_filename *smb_fname)
+ struct smb_filename *smb_fname)
{
- SMB_STRUCT_STAT sbuf;
TALLOC_CTX *ctx = talloc_tos();
char *dname = NULL;
+ struct smb_filename *smb_fname_parent = NULL;
+ NTSTATUS status;
+ bool ret;
if (!CAN_WRITE(conn)) {
return False;
if (!parent_dirname(ctx, smb_fname->base_name, &dname, NULL)) {
return False;
}
- if(SMB_VFS_STAT(conn, dname, &sbuf) != 0) {
- return False;
+
+ status = create_synthetic_smb_fname(ctx, dname, NULL, NULL,
+ &smb_fname_parent);
+ if (!NT_STATUS_IS_OK(status)) {
+ ret = false;
+ goto out;
+ }
+
+ if(SMB_VFS_STAT(conn, smb_fname_parent) != 0) {
+ ret = false;
+ goto out;
}
/* fast paths first */
- if (!S_ISDIR(sbuf.st_ex_mode)) {
- return False;
+ if (!S_ISDIR(smb_fname_parent->st.st_ex_mode)) {
+ ret = false;
+ goto out;
}
if (conn->server_info->utok.uid == 0 || conn->admin_user) {
/* I'm sorry sir, I didn't know you were root... */
- return True;
+ ret = true;
+ goto out;
}
#ifdef S_ISVTX
/* sticky bit means delete only by owner of file or by root or
* by owner of directory. */
- if (sbuf.st_ex_mode & S_ISVTX) {
- SMB_STRUCT_STAT sbuf_file;
- char *fname = NULL;
- NTSTATUS status;
-
- status = get_full_smb_filename(talloc_tos(), smb_fname,
- &fname);
- if (!NT_STATUS_IS_OK(status)) {
- return false;
- }
- if(SMB_VFS_STAT(conn, fname, &sbuf_file) != 0) {
- TALLOC_FREE(fname);
+ if (smb_fname_parent->st.st_ex_mode & S_ISVTX) {
+ if(SMB_VFS_STAT(conn, smb_fname) != 0) {
if (errno == ENOENT) {
/* If the file doesn't already exist then
* yes we'll be able to delete it. */
- return True;
+ ret = true;
+ goto out;
}
DEBUG(10,("can_delete_file_in_directory: can't "
"stat file %s (%s)",
smb_fname_str_dbg(smb_fname),
strerror(errno) ));
- return False;
+ ret = false;
+ goto out;
}
- TALLOC_FREE(fname);
/*
* Patch from SATOH Fumiyasu <fumiyas@miraclelinux.com>
* or the owner of the directory as we have no possible
* chance of deleting. Otherwise, go on and check the ACL.
*/
- if ((conn->server_info->utok.uid != sbuf.st_ex_uid) &&
- (conn->server_info->utok.uid != sbuf_file.st_ex_uid)) {
+ if ((conn->server_info->utok.uid !=
+ smb_fname_parent->st.st_ex_uid) &&
+ (conn->server_info->utok.uid != smb_fname->st.st_ex_uid)) {
DEBUG(10,("can_delete_file_in_directory: not "
"owner of file %s or directory %s",
- smb_fname_str_dbg(smb_fname), dname));
- return False;
+ smb_fname_str_dbg(smb_fname),
+ smb_fname_str_dbg(smb_fname_parent)));
+ ret = false;
+ goto out;
}
}
#endif
* check the file DELETE permission separately.
*/
- return can_access_file_acl(conn, dname, FILE_DELETE_CHILD);
+ ret = can_access_file_acl(conn, smb_fname_parent, FILE_DELETE_CHILD);
+ out:
+ TALLOC_FREE(dname);
+ TALLOC_FREE(smb_fname_parent);
+ return ret;
}
/****************************************************************************
Note this doesn't take into account share write permissions.
****************************************************************************/
-bool can_access_file_data(connection_struct *conn, const char *fname, const SMB_STRUCT_STAT *psbuf, uint32 access_mask)
+bool can_access_file_data(connection_struct *conn,
+ const struct smb_filename *smb_fname,
+ uint32 access_mask)
{
if (!(access_mask & (FILE_READ_DATA|FILE_WRITE_DATA))) {
return False;
/* some fast paths first */
DEBUG(10,("can_access_file_data: requesting 0x%x on file %s\n",
- (unsigned int)access_mask, fname ));
+ (unsigned int)access_mask, smb_fname_str_dbg(smb_fname)));
if (conn->server_info->utok.uid == 0 || conn->admin_user) {
/* I'm sorry sir, I didn't know you were root... */
return True;
}
- SMB_ASSERT(psbuf && VALID_STAT(*psbuf));
+ SMB_ASSERT(VALID_STAT(smb_fname->st));
/* Check primary owner access. */
- if (conn->server_info->utok.uid == psbuf->st_ex_uid) {
+ if (conn->server_info->utok.uid == smb_fname->st.st_ex_uid) {
switch (access_mask) {
case FILE_READ_DATA:
- return (psbuf->st_ex_mode & S_IRUSR) ? True : False;
+ return (smb_fname->st.st_ex_mode & S_IRUSR) ?
+ True : False;
case FILE_WRITE_DATA:
- return (psbuf->st_ex_mode & S_IWUSR) ? True : False;
+ return (smb_fname->st.st_ex_mode & S_IWUSR) ?
+ True : False;
default: /* FILE_READ_DATA|FILE_WRITE_DATA */
- if ((psbuf->st_ex_mode & (S_IWUSR|S_IRUSR)) == (S_IWUSR|S_IRUSR)) {
+ if ((smb_fname->st.st_ex_mode &
+ (S_IWUSR|S_IRUSR)) ==
+ (S_IWUSR|S_IRUSR)) {
return True;
} else {
return False;
/* now for ACL checks */
- return can_access_file_acl(conn, fname, access_mask);
+ return can_access_file_acl(conn, smb_fname, access_mask);
}
/****************************************************************************
bool can_write_to_file(connection_struct *conn, const char *fname, const SMB_STRUCT_STAT *psbuf)
{
- return can_access_file_data(conn, fname, psbuf, FILE_WRITE_DATA);
+ struct smb_filename *smb_fname;
+ NTSTATUS status;
+ bool ret;
+
+ status = create_synthetic_smb_fname_split(talloc_tos(), fname, psbuf,
+ &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ return false;
+ }
+
+ ret = can_access_file_data(conn, smb_fname, FILE_WRITE_DATA);
+
+ TALLOC_FREE(smb_fname);
+
+ return ret;
}
/****************************************************************************
int fsp_stat(files_struct *fsp, SMB_STRUCT_STAT *pst)
{
if (fsp->fh->fd == -1) {
- return SMB_VFS_STAT(fsp->conn, fsp->fsp_name, pst);
+ return vfs_stat_smb_fname(fsp->conn, fsp->fsp_name, pst);
} else {
return SMB_VFS_FSTAT(fsp, pst);
}
*/
NTSTATUS create_synthetic_smb_fname(TALLOC_CTX *ctx, const char *base_name,
const char *stream_name,
- SMB_STRUCT_STAT *psbuf,
+ const SMB_STRUCT_STAT *psbuf,
struct smb_filename **smb_fname_out)
{
struct smb_filename smb_fname_loc;
*/
NTSTATUS create_synthetic_smb_fname_split(TALLOC_CTX *ctx,
const char *fname,
- SMB_STRUCT_STAT *psbuf,
+ const SMB_STRUCT_STAT *psbuf,
struct smb_filename **smb_fname_out)
{
NTSTATUS status;
const char *stream_name = NULL;
char *base_name = NULL;
+ if (!lp_posix_pathnames()) {
+ stream_name = strchr_m(fname, ':');
+ }
+
/* Setup the base_name/stream_name. */
- stream_name = strchr_m(fname, ':');
if (stream_name) {
base_name = talloc_strndup(ctx, fname,
PTR_DIFF(stream_name, fname));
return status;
}
+/**
+ * XXX: This is temporary and there should be no callers of this once
+ * smb_filename is plumbed through all path based operations.
+ */
+int vfs_stat_smb_fname(struct connection_struct *conn, const char *fname,
+ SMB_STRUCT_STAT *psbuf)
+{
+ struct smb_filename *smb_fname = NULL;
+ NTSTATUS status;
+ int ret;
+
+ status = create_synthetic_smb_fname_split(talloc_tos(), fname, NULL,
+ &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+
+ ret = SMB_VFS_STAT(conn, smb_fname);
+ if (ret != -1) {
+ *psbuf = smb_fname->st;
+ }
+
+ TALLOC_FREE(smb_fname);
+ return ret;
+}
+
+/**
+ * XXX: This is temporary and there should be no callers of this once
+ * smb_filename is plumbed through all path based operations.
+ */
+int vfs_lstat_smb_fname(struct connection_struct *conn, const char *fname,
+ SMB_STRUCT_STAT *psbuf)
+{
+ struct smb_filename *smb_fname = NULL;
+ NTSTATUS status;
+ int ret;
+
+ status = create_synthetic_smb_fname_split(talloc_tos(), fname, NULL,
+ &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ return -1;
+ }
+
+ ret = SMB_VFS_LSTAT(conn, smb_fname);
+ if (ret != -1) {
+ *psbuf = smb_fname->st;
+ }
+
+ TALLOC_FREE(smb_fname);
+ return ret;
+}
+
/**
* Return a string using the debug_ctx()
*/
if (!(name = talloc_strdup(ctx,"."))) {
return NT_STATUS_NO_MEMORY;
}
- if (SMB_VFS_STAT(conn,name,&st) == 0) {
+ if (vfs_stat_smb_fname(conn,name,&st) == 0) {
smb_fname->st = st;
} else {
return map_nt_error_from_unix(errno);
*/
if (posix_pathnames) {
- ret = SMB_VFS_LSTAT(conn,name,&st);
+ ret = vfs_lstat_smb_fname(conn,name,&st);
} else {
- ret = SMB_VFS_STAT(conn,name,&st);
+ ret = vfs_stat_smb_fname(conn,name,&st);
}
if (ret == 0) {
*/
if (posix_pathnames) {
- ret = SMB_VFS_LSTAT(conn,name, &st);
+ ret = vfs_lstat_smb_fname(conn,name, &st);
} else {
- ret = SMB_VFS_STAT(conn,name, &st);
+ ret = vfs_stat_smb_fname(conn,name, &st);
}
if (ret == 0) {
*/
if (posix_pathnames) {
- ret = SMB_VFS_LSTAT(conn,name, &st);
+ ret = vfs_lstat_smb_fname(conn,name,
+ &st);
} else {
- ret = SMB_VFS_STAT(conn,name, &st);
+ ret = vfs_stat_smb_fname(conn,name,
+ &st);
}
if (ret == 0) {
const char *orig_path,
struct smb_filename *smb_fname)
{
- char *result = NULL;
NTSTATUS status;
unsigned int i, num_streams;
struct stream_struct *streams = NULL;
- status = get_full_smb_filename(mem_ctx, smb_fname, &result);
- if (!NT_STATUS_IS_OK(status)) {
- return NT_STATUS_NO_MEMORY;
- }
-
- if (SMB_VFS_STAT(conn, result, &smb_fname->st) == 0) {
+ if (SMB_VFS_STAT(conn, smb_fname) == 0) {
return NT_STATUS_OK;
}
TALLOC_FREE(smb_fname->stream_name);
smb_fname->stream_name = talloc_strdup(mem_ctx, streams[i].name);
- TALLOC_FREE(result);
- status = get_full_smb_filename(mem_ctx, smb_fname, &result);
- if (!NT_STATUS_IS_OK(status)) {
- status = NT_STATUS_NO_MEMORY;
- goto fail;
- }
-
SET_STAT_INVALID(smb_fname->st);
- if (SMB_VFS_STAT(conn, result, &smb_fname->st) == 0) {
- stat_cache_add(orig_path, result, conn->case_sensitive);
- }
+ if (SMB_VFS_STAT(conn, smb_fname) == 0) {
+ char *result = NULL;
- TALLOC_FREE(streams);
- return NT_STATUS_OK;
+ status = get_full_smb_filename(mem_ctx, smb_fname, &result);
+ if (!NT_STATUS_IS_OK(status)) {
+ status = NT_STATUS_NO_MEMORY;
+ goto fail;
+ }
+ stat_cache_add(orig_path, result, conn->case_sensitive);
+ TALLOC_FREE(result);
+ }
+ status = NT_STATUS_OK;
fail:
- TALLOC_FREE(result);
TALLOC_FREE(streams);
return status;
}
sbufp = &st;
}
- if (SMB_VFS_LSTAT(conn, path, sbufp) != 0) {
+ if (vfs_lstat_smb_fname(conn, path, sbufp) != 0) {
DEBUG(5,("is_msdfs_link_read_target: %s does not exist.\n",
path));
goto err;
char *fullpath;
char *parent;
const char *name;
- SMB_STRUCT_STAT sbuf;
if (path[0] == '.' && path[1] == '/') {
path += 2;
}
- if (asprintf(&fullpath, "%s/%s", conn->connectpath, path) == -1) {
- DEBUG(0, ("asprintf failed\n"));
- return;
+ if (parent_dirname(talloc_tos(), path, &parent, &name)) {
+ struct smb_filename *smb_fname_parent = NULL;
+ NTSTATUS status;
+
+ status = create_synthetic_smb_fname(talloc_tos(), parent, NULL,
+ NULL, &smb_fname_parent);
+ if (!NT_STATUS_IS_OK(status)) {
+ return;
+ }
+ if (SMB_VFS_STAT(conn, smb_fname_parent) != -1) {
+ notify_onelevel(conn->notify_ctx, action, filter,
+ SMB_VFS_FILE_ID_CREATE(conn, &smb_fname_parent->st),
+ name);
+ }
+ TALLOC_FREE(smb_fname_parent);
}
- if (parent_dirname(talloc_tos(), path, &parent, &name)
- && (SMB_VFS_STAT(conn, parent, &sbuf) != -1)) {
- notify_onelevel(conn->notify_ctx, action, filter,
- SMB_VFS_FILE_ID_CREATE(conn, &sbuf),
- name);
+ fullpath = talloc_asprintf(talloc_tos(), "%s/%s", conn->connectpath,
+ path);
+ if (fullpath == NULL) {
+ DEBUG(0, ("asprintf failed\n"));
+ return;
}
-
notify_trigger(conn->notify_ctx, action, filter, fullpath);
- SAFE_FREE(fullpath);
+ TALLOC_FREE(fullpath);
}
static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
const char *inherit_from_dir,
files_struct *fsp)
{
- SMB_STRUCT_STAT parent_st;
+ struct smb_filename *smb_fname_parent = NULL;
+ NTSTATUS status;
int ret;
- ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
+ status = create_synthetic_smb_fname(talloc_tos(), inherit_from_dir,
+ NULL, NULL, &smb_fname_parent);
+ if (!NT_STATUS_IS_OK(status)) {
+ return;
+ }
+
+ ret = SMB_VFS_STAT(conn, smb_fname_parent);
if (ret == -1) {
DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
"directory %s. Error was %s\n",
- inherit_from_dir, strerror(errno) ));
+ smb_fname_str_dbg(smb_fname_parent),
+ strerror(errno)));
return;
}
become_root();
- ret = SMB_VFS_FCHOWN(fsp, parent_st.st_ex_uid, (gid_t)-1);
+ ret = SMB_VFS_FCHOWN(fsp, smb_fname_parent->st.st_ex_uid, (gid_t)-1);
unbecome_root();
if (ret == -1) {
DEBUG(0,("change_file_owner_to_parent: failed to fchown "
"file %s to parent directory uid %u. Error "
"was %s\n", fsp->fsp_name,
- (unsigned int)parent_st.st_ex_uid,
+ (unsigned int)smb_fname_parent->st.st_ex_uid,
strerror(errno) ));
}
DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
"parent directory uid %u.\n", fsp->fsp_name,
- (unsigned int)parent_st.st_ex_uid ));
+ (unsigned int)smb_fname_parent->st.st_ex_uid));
+
+ TALLOC_FREE(smb_fname_parent);
}
NTSTATUS change_dir_owner_to_parent(connection_struct *conn,
const char *fname,
SMB_STRUCT_STAT *psbuf)
{
+ struct smb_filename *smb_fname_parent = NULL;
+ struct smb_filename *smb_fname_cwd = NULL;
char *saved_dir = NULL;
- SMB_STRUCT_STAT sbuf;
- SMB_STRUCT_STAT parent_st;
TALLOC_CTX *ctx = talloc_tos();
NTSTATUS status = NT_STATUS_OK;
int ret;
- ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
+ status = create_synthetic_smb_fname(ctx, inherit_from_dir, NULL, NULL,
+ &smb_fname_parent);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ ret = SMB_VFS_STAT(conn, smb_fname_parent);
if (ret == -1) {
status = map_nt_error_from_unix(errno);
DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
"directory %s. Error was %s\n",
- inherit_from_dir, strerror(errno) ));
- return status;
+ smb_fname_str_dbg(smb_fname_parent),
+ strerror(errno)));
+ goto out;
}
/* We've already done an lstat into psbuf, and we know it's a
DEBUG(0,("change_dir_owner_to_parent: failed to get "
"current working directory. Error was %s\n",
strerror(errno)));
- return status;
+ goto out;
}
/* Chdir into the new path. */
DEBUG(0,("change_dir_owner_to_parent: failed to change "
"current working directory to %s. Error "
"was %s\n", fname, strerror(errno) ));
- goto out;
+ goto chdir;
+ }
+
+ status = create_synthetic_smb_fname(ctx, ".", NULL, NULL,
+ &smb_fname_cwd);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
}
- if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
+ ret = SMB_VFS_STAT(conn, smb_fname_cwd);
+ if (ret == -1) {
status = map_nt_error_from_unix(errno);
DEBUG(0,("change_dir_owner_to_parent: failed to stat "
"directory '.' (%s) Error was %s\n",
fname, strerror(errno)));
- goto out;
+ goto chdir;
}
/* Ensure we're pointing at the same place. */
- if (sbuf.st_ex_dev != psbuf->st_ex_dev ||
- sbuf.st_ex_ino != psbuf->st_ex_ino ||
- sbuf.st_ex_mode != psbuf->st_ex_mode ) {
+ if (smb_fname_cwd->st.st_ex_dev != psbuf->st_ex_dev ||
+ smb_fname_cwd->st.st_ex_ino != psbuf->st_ex_ino ||
+ smb_fname_cwd->st.st_ex_mode != psbuf->st_ex_mode ) {
DEBUG(0,("change_dir_owner_to_parent: "
"device/inode/mode on directory %s changed. "
"Refusing to chown !\n", fname ));
status = NT_STATUS_ACCESS_DENIED;
- goto out;
+ goto chdir;
}
become_root();
- ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_ex_uid, (gid_t)-1);
+ ret = SMB_VFS_CHOWN(conn, ".", smb_fname_parent->st.st_ex_uid,
+ (gid_t)-1);
unbecome_root();
if (ret == -1) {
status = map_nt_error_from_unix(errno);
DEBUG(10,("change_dir_owner_to_parent: failed to chown "
"directory %s to parent directory uid %u. "
"Error was %s\n", fname,
- (unsigned int)parent_st.st_ex_uid, strerror(errno) ));
- goto out;
+ (unsigned int)smb_fname_parent->st.st_ex_uid,
+ strerror(errno) ));
+ goto chdir;
}
DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
"directory %s to parent directory uid %u.\n",
- fname, (unsigned int)parent_st.st_ex_uid ));
-
- out:
+ fname, (unsigned int)smb_fname_parent->st.st_ex_uid ));
+ chdir:
vfs_ChDir(conn,saved_dir);
+ out:
+ TALLOC_FREE(smb_fname_parent);
+ TALLOC_FREE(smb_fname_cwd);
return status;
}
int ret;
if (fsp->fh->fd == -1) {
- ret = SMB_VFS_STAT(conn, path, &smb_fname->st);
+ ret = SMB_VFS_STAT(conn, smb_fname);
} else {
ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
/* If we have an fd, this stat should succeed. */
can_access_mask = FILE_READ_DATA;
}
- if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
- !can_access_file_data(conn, fname, &smb_fname->st, can_access_mask)) {
+ if (((can_access_mask & FILE_WRITE_DATA) &&
+ !CAN_WRITE(conn)) ||
+ !can_access_file_data(conn, smb_fname,
+ can_access_mask)) {
can_access = False;
}
/* Ensure we're checking for a symlink here.... */
/* We don't want to get caught by a symlink racer. */
- if (SMB_VFS_LSTAT(conn, name, psbuf) == -1) {
+ if (vfs_lstat_smb_fname(conn, name, psbuf) == -1) {
DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
name, strerror(errno)));
return map_nt_error_from_unix(errno);
* We want to follow symlinks here.
*/
- if (SMB_VFS_STAT(conn, fname, &smb_dname->st) != 0) {
+ if (SMB_VFS_STAT(conn, smb_dname) != 0) {
return map_nt_error_from_unix(errno);
}
for (i=0; i<num_streams; i++) {
struct smb_filename *smb_fname = NULL;
- char *streamname = NULL;
- SMB_STRUCT_STAT sbuf;
if (strequal(stream_info[i].name, "::$DATA")) {
streams[i] = NULL;
continue;
}
- streamname = talloc_asprintf(talloc_tos(), "%s%s", fname,
- stream_info[i].name);
- if (streamname == NULL) {
- DEBUG(0, ("talloc_aprintf failed\n"));
- status = NT_STATUS_NO_MEMORY;
- }
-
- if (SMB_VFS_STAT(conn, streamname, &sbuf) == -1) {
- SET_STAT_INVALID(sbuf);
- }
-
- TALLOC_FREE(streamname);
-
status = create_synthetic_smb_fname(talloc_tos(), fname,
stream_info[i].name,
- &sbuf, &smb_fname);
+ NULL, &smb_fname);
if (!NT_STATUS_IS_OK(status)) {
goto fail;
}
+ if (SMB_VFS_STAT(conn, smb_fname) == -1) {
+ DEBUG(10, ("Unable to stat stream: %s\n",
+ smb_fname_str_dbg(smb_fname)));
+ }
+
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
NULL, /* req */
&& (share_access & FILE_SHARE_DELETE)
&& (access_mask & DELETE_ACCESS)
&& (!(can_delete_file_in_directory(conn, smb_fname) ||
- can_access_file_acl(conn, fname, DELETE_ACCESS)))) {
+ can_access_file_acl(conn, smb_fname, DELETE_ACCESS)))) {
status = NT_STATUS_ACCESS_DENIED;
DEBUG(10,("create_file_unixpath: open file %s "
"for delete ACCESS_DENIED\n",
&& (!(create_options & NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE))) {
uint32 base_create_disposition;
struct smb_filename *smb_fname_base = NULL;
- SMB_STRUCT_STAT sbuf;
if (create_options & FILE_DIRECTORY_FILE) {
status = NT_STATUS_NOT_A_DIRECTORY;
break;
}
- if (SMB_VFS_STAT(conn, smb_fname->base_name, &sbuf) == -1) {
- SET_STAT_INVALID(sbuf);
- }
-
/* Create an smb_filename with stream_name == NULL. */
status = create_synthetic_smb_fname(talloc_tos(),
smb_fname->base_name,
- NULL, &sbuf,
+ NULL, NULL,
&smb_fname_base);
if (!NT_STATUS_IS_OK(status)) {
goto fail;
}
+ if (SMB_VFS_STAT(conn, smb_fname_base) == -1) {
+ DEBUG(10, ("Unable to stat stream: %s\n",
+ smb_fname_str_dbg(smb_fname_base)));
+ }
+
/* Open the base file. */
status = create_file_unixpath(conn, NULL, smb_fname_base, 0,
FILE_SHARE_READ
DEBUG(10,("posix_get_nt_acl: called for file %s\n", name ));
/* Get the stat struct for the owner info. */
- if(SMB_VFS_STAT(conn, name, &sbuf) != 0) {
+ if(vfs_stat_smb_fname(conn, name, &sbuf) != 0) {
return map_nt_error_from_unix(errno);
}
return -1;
}
- if (SMB_VFS_STAT(conn,fname,&st)) {
+ if (vfs_stat_smb_fname(conn,fname,&st)) {
return -1;
}
*/
if(fsp->is_directory || fsp->fh->fd == -1) {
- if(SMB_VFS_STAT(fsp->conn,fsp->fsp_name, &sbuf) != 0)
+ if(vfs_stat_smb_fname(fsp->conn,fsp->fsp_name, &sbuf) != 0)
return map_nt_error_from_unix(errno);
} else {
if(SMB_VFS_FSTAT(fsp, &sbuf) != 0)
*/
if(fsp->is_directory) {
- if(SMB_VFS_STAT(fsp->conn, fsp->fsp_name, &sbuf) != 0) {
+ if(vfs_stat_smb_fname(fsp->conn, fsp->fsp_name,
+ &sbuf) != 0) {
return map_nt_error_from_unix(errno);
}
} else {
int sret;
if(fsp->fh->fd == -1)
- sret = SMB_VFS_STAT(fsp->conn, fsp->fsp_name, &sbuf);
+ sret = vfs_stat_smb_fname(fsp->conn,
+ fsp->fsp_name,
+ &sbuf);
else
sret = SMB_VFS_FSTAT(fsp, &sbuf);
}
if (!VALID_STAT(smb_fname->st) &&
- (SMB_VFS_STAT(conn, name, &smb_fname->st) != 0)) {
- DEBUG(3,("reply_checkpath: stat of %s failed (%s)\n",name,strerror(errno)));
+ (SMB_VFS_STAT(conn, smb_fname) != 0)) {
+ DEBUG(3,("reply_checkpath: stat of %s failed (%s)\n",
+ smb_fname_str_dbg(smb_fname), strerror(errno)));
status = map_nt_error_from_unix(errno);
goto path_err;
}
}
reply_outbuf(req, 0, 0);
- out:
- TALLOC_FREE(smb_fname);
- END_PROFILE(SMBcheckpath);
- return;
path_err:
-
- TALLOC_FREE(smb_fname);
-
- END_PROFILE(SMBcheckpath);
-
/* We special case this - as when a Windows machine
is parsing a path is steps through the components
one at a time - if a component fails it expects
*/
reply_botherror(req, NT_STATUS_OBJECT_NAME_NOT_FOUND,
ERRDOS, ERRbadpath);
- return;
+ goto out;
}
reply_nterror(req, status);
+
+ out:
+ TALLOC_FREE(smb_fname);
+ END_PROFILE(SMBcheckpath);
+ return;
}
/****************************************************************************
goto out;
}
if (!VALID_STAT(smb_fname->st) &&
- (SMB_VFS_STAT(conn, fname, &smb_fname->st) != 0)) {
- DEBUG(3,("reply_getatr: stat of %s failed (%s)\n",fname,strerror(errno)));
+ (SMB_VFS_STAT(conn, smb_fname) != 0)) {
+ DEBUG(3,("reply_getatr: stat of %s failed (%s)\n",
+ smb_fname_str_dbg(smb_fname),
+ strerror(errno)));
reply_unixerror(req, ERRDOS,ERRbadfile);
goto out;
}
SVAL(req->outbuf, smb_flg2) | FLAGS2_IS_LONG_NAME);
}
- DEBUG(3,("reply_getatr: name=%s mode=%d size=%u\n", fname, mode, (unsigned int)size ) );
+ DEBUG(3,("reply_getatr: name=%s mode=%d size=%u\n",
+ smb_fname_str_dbg(smb_fname), mode, (unsigned int)size));
out:
TALLOC_FREE(smb_fname);
+ TALLOC_FREE(fname);
END_PROFILE(SMBgetatr);
return;
}
goto out;
}
- SET_STAT_INVALID(smb_fname->st);
- SMB_VFS_STAT(conn, smb_fname->base_name, &smb_fname->st);
+ SMB_VFS_STAT(conn, smb_fname);
/* We should fail if file does not exist. */
status = SMB_VFS_CREATE_FILE(
return NT_STATUS_MEDIA_WRITE_PROTECTED;
}
+ if (SMB_VFS_LSTAT(conn, smb_fname) != 0) {
+ return map_nt_error_from_unix(errno);
+ }
+
status = get_full_smb_filename(smb_fname, smb_fname, &fname);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
-
- if (SMB_VFS_LSTAT(conn, fname, &smb_fname->st) != 0) {
- return map_nt_error_from_unix(errno);
- }
-
fattr = dos_mode(conn, fname, &smb_fname->st);
+ TALLOC_FREE(fname);
if (dirtype & FILE_ATTRIBUTE_NORMAL) {
dirtype = aDIR|aARCH|aRONLY;
while((dname = ReadDirName(dir_hnd, &offset, &st))) {
char *fullname = NULL;
+ struct smb_filename *smb_fname = NULL;
+ NTSTATUS status;
if (ISDOT(dname) || ISDOTDOT(dname)) {
continue;
dname);
if (!fullname) {
errno = ENOMEM;
- ret = False;
- break;
+ goto err_break;
}
- if(SMB_VFS_LSTAT(conn,fullname, &st) != 0) {
- ret = False;
- break;
+ status = create_synthetic_smb_fname(talloc_tos(), fullname,
+ NULL, NULL, &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto err_break;
+ }
+
+ if(SMB_VFS_LSTAT(conn, smb_fname) != 0) {
+ goto err_break;
}
- if(st.st_ex_mode & S_IFDIR) {
+ if(smb_fname->st.st_ex_mode & S_IFDIR) {
if(!recursive_rmdir(ctx, conn, fullname)) {
- ret = False;
- break;
+ goto err_break;
}
if(SMB_VFS_RMDIR(conn,fullname) != 0) {
- ret = False;
- break;
+ goto err_break;
}
} else if(SMB_VFS_UNLINK(conn,fullname) != 0) {
- ret = False;
- break;
+ goto err_break;
}
+ TALLOC_FREE(smb_fname);
+ TALLOC_FREE(fullname);
+ continue;
+ err_break:
+ TALLOC_FREE(smb_fname);
TALLOC_FREE(fullname);
+ ret = false;
+ break;
}
TALLOC_FREE(dir_hnd);
return ret;
SMB_STRUCT_STAT st;
/* Might be a symlink. */
- if(SMB_VFS_LSTAT(conn, directory, &st) != 0) {
+ if(vfs_lstat_smb_fname(conn, directory, &st) != 0) {
return map_nt_error_from_unix(errno);
}
if (S_ISLNK(st.st_ex_mode)) {
/* Is what it points to a directory ? */
- if(SMB_VFS_STAT(conn, directory, &st) != 0) {
+ if(vfs_stat_smb_fname(conn, directory, &st) != 0) {
return map_nt_error_from_unix(errno);
}
if (!(S_ISDIR(st.st_ex_mode))) {
break;
}
- if(SMB_VFS_LSTAT(conn,fullname, &st) != 0) {
+ if(vfs_lstat_smb_fname(conn,fullname, &st) != 0) {
break;
}
if(st.st_ex_mode & S_IFDIR) {
return NT_STATUS_INVALID_PARAMETER;
}
- /*
- * Have vfs_object_exist also fill sbuf1
- */
- dst_exists = vfs_object_exist(conn, newname, &sbuf1);
+ dst_exists = vfs_stat_smb_fname(conn, newname, &sbuf1) == 0;
if(!replace_if_exists && dst_exists) {
DEBUG(3,("rename_internals_fsp: dest exists doing rename %s -> %s\n",
} else {
int ret = -1;
if (fsp->posix_open) {
- ret = SMB_VFS_LSTAT(conn,fsp->fsp_name,&sbuf);
+ ret = vfs_lstat_smb_fname(conn,fsp->fsp_name,&sbuf);
} else {
- ret = SMB_VFS_STAT(conn,fsp->fsp_name,&sbuf);
+
+ ret = vfs_stat_smb_fname(conn,fsp->fsp_name,&sbuf);
}
if (ret == -1) {
return map_nt_error_from_unix(errno);
if (!src_has_wild) {
files_struct *fsp;
- char *fname_src = NULL;
char *fname_dst = NULL;
/*
smb_fname_dst->base_name = fname_dst_mod;
}
- status = get_full_smb_filename(ctx, smb_fname_src, &fname_src);
- if (!NT_STATUS_IS_OK(status)) {
- goto out;
- }
-
ZERO_STRUCT(smb_fname_src->st);
if (posix_pathnames) {
- SMB_VFS_LSTAT(conn, fname_src, &smb_fname_src->st);
+ SMB_VFS_LSTAT(conn, smb_fname_src);
} else {
- SMB_VFS_STAT(conn, fname_src, &smb_fname_src->st);
+ SMB_VFS_STAT(conn, smb_fname_src);
}
if (S_ISDIR(smb_fname_src->st.st_ex_mode)) {
create_options |= FILE_DIRECTORY_FILE;
}
- TALLOC_FREE(fname_src);
-
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
req, /* req */
status = get_full_smb_filename(ctx, smb_fname_dst, &fname_dst);
if (!NT_STATUS_IS_OK(status)) {
- TALLOC_FREE(fname_src);
goto out;
}
while ((dname = ReadDirName(dir_hnd, &offset, &smb_fname_src->st))) {
files_struct *fsp = NULL;
- char *fname_src = NULL;
char *fname_dst = NULL;
char *destname = NULL;
bool sysdir_entry = False;
TALLOC_FREE(smb_fname_dst->base_name);
smb_fname_dst->base_name = destname;
- status = get_full_smb_filename(ctx, smb_fname_src, &fname_src);
- if (!NT_STATUS_IS_OK(status)) {
- goto out;
- }
-
ZERO_STRUCT(smb_fname_src->st);
if (posix_pathnames) {
- SMB_VFS_LSTAT(conn, fname_src, &smb_fname_src->st);
+ SMB_VFS_LSTAT(conn, smb_fname_src);
} else {
- SMB_VFS_STAT(conn, fname_src, &smb_fname_src->st);
+ SMB_VFS_STAT(conn, smb_fname_src);
}
- TALLOC_FREE(fname_src);
-
create_options = 0;
if (S_ISDIR(smb_fname_src->st.st_ex_mode)) {
{
struct smb_filename *smb_fname_dst_tmp = NULL;
char *fname_src = NULL;
- char *fname_dst = NULL;
SMB_OFF_T ret=-1;
files_struct *fsp1,*fsp2;
uint32 dosattrs;
TALLOC_FREE(fname_src);
- status = get_full_smb_filename(talloc_tos(), smb_fname_dst_tmp, &fname_dst);
- if (!NT_STATUS_IS_OK(status)) {
- goto out;
- }
-
- if (SMB_VFS_STAT(conn, fname_dst, &smb_fname_dst_tmp->st) == -1) {
+ if (SMB_VFS_STAT(conn, smb_fname_dst_tmp) == -1) {
ZERO_STRUCTP(&smb_fname_dst_tmp->st);
}
- TALLOC_FREE(fname_dst);
-
/* Open the dst file for writing. */
status = SMB_VFS_CREATE_FILE(
conn, /* conn */
int ret = -1;
if (fsp->posix_open) {
- ret = SMB_VFS_LSTAT(conn, fsp->fsp_name, &sbuf);
+ ret = vfs_lstat_smb_fname(conn, fsp->fsp_name, &sbuf);
} else {
- ret = SMB_VFS_STAT(conn, fsp->fsp_name, &sbuf);
+ ret = vfs_stat_smb_fname(conn, fsp->fsp_name, &sbuf);
}
if (ret == -1) {
status = map_nt_error_from_unix(errno);
NTSTATUS *pstatus)
{
connection_struct *conn;
- SMB_STRUCT_STAT st;
+ struct smb_filename *smb_fname_cpath = NULL;
fstring dev;
int ret;
char addr[INET6_ADDRSTRLEN];
NTSTATUS status;
fstrcpy(dev, pdev);
- SET_STAT_INVALID(st);
if (NT_STATUS_IS_ERR(*pstatus = share_sanity_checks(snum, dev))) {
return NULL;
/* Any error exit after here needs to call the disconnect hook. */
on_err_call_dis_hook = true;
+ status = create_synthetic_smb_fname(talloc_tos(), conn->connectpath,
+ NULL, NULL, &smb_fname_cpath);
+ if (!NT_STATUS_IS_OK(status)) {
+ *pstatus = status;
+ goto err_root_exit;
+ }
+
/* win2000 does not check the permissions on the directory
during the tree connect, instead relying on permission
check during individual operations. To match this behaviour
I have disabled this chdir check (tridge) */
/* the alternative is just to check the directory exists */
- if ((ret = SMB_VFS_STAT(conn, conn->connectpath, &st)) != 0 ||
- !S_ISDIR(st.st_ex_mode)) {
- if (ret == 0 && !S_ISDIR(st.st_ex_mode)) {
+ if ((ret = SMB_VFS_STAT(conn, smb_fname_cpath)) != 0 ||
+ !S_ISDIR(smb_fname_cpath->st.st_ex_mode)) {
+ if (ret == 0 && !S_ISDIR(smb_fname_cpath->st.st_ex_mode)) {
DEBUG(0,("'%s' is not a directory, when connecting to "
"[%s]\n", conn->connectpath,
lp_servicename(snum)));
return(conn);
err_root_exit:
-
+ TALLOC_FREE(smb_fname_cpath);
change_to_root_user();
if (on_err_call_dis_hook) {
/* Call VFS disconnect hook */
"-> [%s]\n", chk_name, translated_path ));
DO_PROFILE_INC(statcache_hits);
- if (SMB_VFS_STAT(conn, translated_path, pst) != 0) {
+ if (vfs_stat_smb_fname(conn, translated_path, pst) != 0) {
/* Discard this entry - it doesn't exist in the filesystem. */
memcache_delete(smbd_memcache(), STAT_CACHE,
data_blob_const(chk_name, strlen(chk_name)));
}
if (INFO_LEVEL_IS_UNIX(info_level)) {
- if (SMB_VFS_LSTAT(conn,pathreal,&sbuf) != 0) {
+ if (vfs_lstat_smb_fname(conn, pathreal,
+ &sbuf) != 0) {
DEBUG(5,("get_lanman2_dir_entry:Couldn't lstat [%s] (%s)\n",
pathreal,strerror(errno)));
TALLOC_FREE(pathreal);
TALLOC_FREE(fname);
continue;
}
- } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,pathreal,&sbuf) != 0) {
+ } else if (!VALID_STAT(sbuf) &&
+ vfs_stat_smb_fname(conn, pathreal,
+ &sbuf) != 0) {
/* Needed to show the msdfs symlinks as
* directories */
DEBUG(3,("call_trans2qfsinfo: level = %d\n", info_level));
- if(SMB_VFS_STAT(conn,".",&st)!=0) {
+ if(vfs_stat_smb_fname(conn,".",&st)!=0) {
DEBUG(2,("call_trans2qfsinfo: stat of . failed (%s)\n", strerror(errno)));
reply_doserror(req, ERRSRV, ERRinvdevice);
return;
char *lock_data = NULL;
bool ms_dfs_link = false;
TALLOC_CTX *ctx = talloc_tos();
+ NTSTATUS status = NT_STATUS_OK;
if (!params) {
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
- ZERO_STRUCT(sbuf);
ZERO_STRUCT(write_time_ts);
if (tran_call == TRANSACT2_QFILEINFO) {
return;
}
+ status = create_synthetic_smb_fname_split(talloc_tos(), fname,
+ NULL, &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ reply_nterror(req, status);
+ return;
+ }
+
if(fsp->fake_file_handle) {
/*
* This is actually for the QUOTA_FAKE_FILE --metze
if (INFO_LEVEL_IS_UNIX(info_level)) {
/* Always do lstat for UNIX calls. */
- if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
- DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
+ if (SMB_VFS_LSTAT(conn, smb_fname)) {
+ DEBUG(3,("call_trans2qfilepathinfo: "
+ "SMB_VFS_LSTAT of %s failed "
+ "(%s)\n",
+ smb_fname_str_dbg(smb_fname),
+ strerror(errno)));
reply_unixerror(req,ERRDOS,ERRbadpath);
return;
}
- } else if (SMB_VFS_STAT(conn,fname,&sbuf)) {
- DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
+ } else if (SMB_VFS_STAT(conn, smb_fname)) {
+ DEBUG(3,("call_trans2qfilepathinfo: "
+ "SMB_VFS_STAT of %s failed (%s)\n",
+ smb_fname_str_dbg(smb_fname),
+ strerror(errno)));
reply_unixerror(req, ERRDOS, ERRbadpath);
return;
}
- fileid = vfs_file_id_from_sbuf(conn, &sbuf);
+ fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
get_file_infos(fileid, &delete_pending, &write_time_ts);
} else {
/*
return;
}
- if (SMB_VFS_FSTAT(fsp, &sbuf) != 0) {
- DEBUG(3,("fstat of fnum %d failed (%s)\n", fsp->fnum, strerror(errno)));
+ if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
+ DEBUG(3, ("fstat of fnum %d failed (%s)\n",
+ fsp->fnum, strerror(errno)));
reply_unixerror(req, ERRDOS, ERRbadfid);
return;
}
pos = fsp->fh->position_information;
- fileid = vfs_file_id_from_sbuf(conn, &sbuf);
+ fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
get_file_infos(fileid, &delete_pending, &write_time_ts);
}
} else {
- NTSTATUS status = NT_STATUS_OK;
-
/* qpathinfo */
if (total_params < 7) {
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
- sbuf = smb_fname->st;
-
+ /* If this is a stream, check if there is a delete_pending. */
if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
- && is_ntfs_stream_name(fname)) {
- char *base;
- SMB_STRUCT_STAT bsbuf;
-
- status = split_ntfs_stream_name(talloc_tos(), fname,
- &base, NULL);
+ && is_ntfs_stream_smb_fname(smb_fname)) {
+ struct smb_filename *smb_fname_base = NULL;
+
+ /* Create an smb_filename with stream_name == NULL. */
+ status =
+ create_synthetic_smb_fname(talloc_tos(),
+ smb_fname->base_name,
+ NULL, NULL,
+ &smb_fname_base);
if (!NT_STATUS_IS_OK(status)) {
- DEBUG(10, ("create_file_unixpath: "
- "split_ntfs_stream_name failed: %s\n",
- nt_errstr(status)));
reply_nterror(req, status);
return;
}
- SMB_ASSERT(!is_ntfs_stream_name(base)); /* paranoia.. */
-
if (INFO_LEVEL_IS_UNIX(info_level)) {
/* Always do lstat for UNIX calls. */
- if (SMB_VFS_LSTAT(conn,base,&bsbuf)) {
- DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",base,strerror(errno)));
+ if (SMB_VFS_LSTAT(conn, smb_fname_base) != 0) {
+ DEBUG(3,("call_trans2qfilepathinfo: "
+ "SMB_VFS_LSTAT of %s failed "
+ "(%s)\n",
+ smb_fname_str_dbg(smb_fname_base),
+ strerror(errno)));
+ TALLOC_FREE(smb_fname_base);
reply_unixerror(req,ERRDOS,ERRbadpath);
return;
}
} else {
- if (SMB_VFS_STAT(conn,base,&bsbuf) != 0) {
- DEBUG(3,("call_trans2qfilepathinfo: fileinfo of %s failed (%s)\n",base,strerror(errno)));
+ if (SMB_VFS_STAT(conn, smb_fname_base) != 0) {
+ DEBUG(3,("call_trans2qfilepathinfo: "
+ "fileinfo of %s failed "
+ "(%s)\n",
+ smb_fname_str_dbg(smb_fname_base),
+ strerror(errno)));
+ TALLOC_FREE(smb_fname_base);
reply_unixerror(req,ERRDOS,ERRbadpath);
return;
}
}
- fileid = vfs_file_id_from_sbuf(conn, &bsbuf);
+ fileid = vfs_file_id_from_sbuf(conn,
+ &smb_fname_base->st);
+ TALLOC_FREE(smb_fname_base);
get_file_infos(fileid, &delete_pending, NULL);
if (delete_pending) {
reply_nterror(req, NT_STATUS_DELETE_PENDING);
if (INFO_LEVEL_IS_UNIX(info_level)) {
/* Always do lstat for UNIX calls. */
- if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
- DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
+ if (SMB_VFS_LSTAT(conn, smb_fname)) {
+ DEBUG(3,("call_trans2qfilepathinfo: "
+ "SMB_VFS_LSTAT of %s failed (%s)\n",
+ smb_fname_str_dbg(smb_fname),
+ strerror(errno)));
reply_unixerror(req, ERRDOS, ERRbadpath);
return;
}
- } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf) && (info_level != SMB_INFO_IS_NAME_VALID)) {
- ms_dfs_link = check_msdfs_link(conn,fname,&sbuf);
+ } else if (!VALID_STAT(smb_fname->st) &&
+ SMB_VFS_STAT(conn, smb_fname) &&
+ (info_level != SMB_INFO_IS_NAME_VALID)) {
+ ms_dfs_link = check_msdfs_link(conn, fname,
+ &smb_fname->st);
if (!ms_dfs_link) {
- DEBUG(3,("call_trans2qfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
+ DEBUG(3,("call_trans2qfilepathinfo: "
+ "SMB_VFS_STAT of %s failed (%s)\n",
+ smb_fname_str_dbg(smb_fname),
+ strerror(errno)));
reply_unixerror(req, ERRDOS, ERRbadpath);
return;
}
}
- fileid = vfs_file_id_from_sbuf(conn, &sbuf);
+ fileid = vfs_file_id_from_sbuf(conn, &smb_fname->st);
get_file_infos(fileid, &delete_pending, &write_time_ts);
if (delete_pending) {
reply_nterror(req, NT_STATUS_DELETE_PENDING);
}
}
+ /* Set sbuf for use below. */
+ sbuf = smb_fname->st;
+
if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
reply_nterror(req, NT_STATUS_INVALID_LEVEL);
return;
case SMB_FILE_STREAM_INFORMATION: {
unsigned int num_streams;
struct stream_struct *streams;
- NTSTATUS status;
DEBUG(10,("call_trans2qfilepathinfo: "
"SMB_FILE_STREAM_INFORMATION\n"));
case SMB_QUERY_POSIX_LOCK:
{
- NTSTATUS status = NT_STATUS_INVALID_LEVEL;
uint64_t count;
uint64_t offset;
uint32 lock_pid;
TALLOC_FREE(parent);
}
- if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
+ if (vfs_stat_smb_fname(conn, fname, psbuf) != 0) {
status = map_nt_error_from_unix(errno);
SMB_VFS_UNLINK(conn,fname);
return status;
return;
}
- ZERO_STRUCT(sbuf);
-
if (tran_call == TRANSACT2_SETFILEINFO) {
if (total_params < 4) {
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
return;
}
+ status = create_synthetic_smb_fname_split(talloc_tos(), fname,
+ NULL, &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ reply_nterror(req, status);
+ return;
+ }
+
if(fsp->is_directory || fsp->fh->fd == -1) {
/*
* This is actually a SETFILEINFO on a directory
*/
if (INFO_LEVEL_IS_UNIX(info_level)) {
/* Always do lstat for UNIX calls. */
- if (SMB_VFS_LSTAT(conn,fname,&sbuf)) {
- DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_LSTAT of %s failed (%s)\n",fname,strerror(errno)));
+ if (SMB_VFS_LSTAT(conn, smb_fname)) {
+ DEBUG(3,("call_trans2setfilepathinfo: "
+ "SMB_VFS_LSTAT of %s failed "
+ "(%s)\n",
+ smb_fname_str_dbg(smb_fname),
+ strerror(errno)));
reply_unixerror(req,ERRDOS,ERRbadpath);
return;
}
} else {
- if (SMB_VFS_STAT(conn,fname,&sbuf) != 0) {
- DEBUG(3,("call_trans2setfilepathinfo: fileinfo of %s failed (%s)\n",fname,strerror(errno)));
+ if (SMB_VFS_STAT(conn, smb_fname) != 0) {
+ DEBUG(3,("call_trans2setfilepathinfo: "
+ "fileinfo of %s failed (%s)\n",
+ smb_fname_str_dbg(smb_fname),
+ strerror(errno)));
reply_unixerror(req,ERRDOS,ERRbadpath);
return;
}
return;
}
- if (SMB_VFS_FSTAT(fsp, &sbuf) != 0) {
- DEBUG(3,("call_trans2setfilepathinfo: fstat of fnum %d failed (%s)\n",fsp->fnum, strerror(errno)));
+ if (SMB_VFS_FSTAT(fsp, &smb_fname->st) != 0) {
+ DEBUG(3,("call_trans2setfilepathinfo: fstat "
+ "of fnum %d failed (%s)\n", fsp->fnum,
+ strerror(errno)));
reply_unixerror(req, ERRDOS, ERRbadfid);
return;
}
return;
}
- sbuf = smb_fname->st;
-
if (INFO_LEVEL_IS_UNIX(info_level)) {
/*
* For CIFS UNIX extensions the target name may not exist.
*/
/* Always do lstat for UNIX calls. */
- SMB_VFS_LSTAT(conn,fname,&sbuf);
-
- } else if (!VALID_STAT(sbuf) && SMB_VFS_STAT(conn,fname,&sbuf)) {
- DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of %s failed (%s)\n",fname,strerror(errno)));
+ SMB_VFS_LSTAT(conn, smb_fname);
+
+ } else if (!VALID_STAT(smb_fname->st) &&
+ SMB_VFS_STAT(conn, smb_fname)) {
+ DEBUG(3,("call_trans2setfilepathinfo: SMB_VFS_STAT of "
+ "%s failed (%s)\n",
+ smb_fname_str_dbg(smb_fname),
+ strerror(errno)));
reply_unixerror(req, ERRDOS, ERRbadpath);
return;
}
}
+ /* Set sbuf for use below. */
+ sbuf = smb_fname->st;
+
if (INFO_LEVEL_IS_UNIX(info_level) && !lp_unix_extensions()) {
reply_nterror(req, NT_STATUS_INVALID_LEVEL);
return;
return True;
}
-/*******************************************************************
- Check if directory exists.
-********************************************************************/
-
-bool vfs_directory_exist(connection_struct *conn, const char *dname, SMB_STRUCT_STAT *st)
-{
- SMB_STRUCT_STAT st2;
- bool ret;
-
- if (!st)
- st = &st2;
-
- if (SMB_VFS_STAT(conn,dname,st) != 0)
- return(False);
-
- ret = S_ISDIR(st->st_ex_mode);
- if(!ret)
- errno = ENOTDIR;
-
- return ret;
-}
-
-/*******************************************************************
- Check if an object exists in the vfs.
-********************************************************************/
-
-bool vfs_object_exist(connection_struct *conn,const char *fname,SMB_STRUCT_STAT *sbuf)
-{
- SMB_STRUCT_STAT st;
-
- if (!sbuf)
- sbuf = &st;
-
- ZERO_STRUCTP(sbuf);
-
- if (SMB_VFS_STAT(conn,fname,sbuf) == -1)
- return(False);
- return True;
-}
-
/*******************************************************************
Check if a file exists in the vfs.
********************************************************************/
NTSTATUS vfs_file_exist(connection_struct *conn, struct smb_filename *smb_fname)
{
- char *fname = NULL;
- NTSTATUS status;
-
- status = get_full_smb_filename(talloc_tos(), smb_fname, &fname);
- if (!NT_STATUS_IS_OK(status)) {
- goto out;
- }
-
- status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
- if (SMB_VFS_STAT(conn, fname, &smb_fname->st) == -1) {
- goto out;
- }
-
/* Only return OK if stat was successful and S_ISREG */
- if (S_ISREG(smb_fname->st.st_ex_mode)) {
- status = NT_STATUS_OK;
+ if ((SMB_VFS_STAT(conn, smb_fname) != -1) &&
+ S_ISREG(smb_fname->st.st_ex_mode)) {
+ return NT_STATUS_OK;
}
- out:
- TALLOC_FREE(fname);
- return status;
+
+ return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
/****************************************************************************
char *vfs_GetWd(TALLOC_CTX *ctx, connection_struct *conn)
{
char s[PATH_MAX+1];
- SMB_STRUCT_STAT st, st2;
- char *result;
+ char *result = NULL;
DATA_BLOB cache_value;
struct file_id key;
+ struct smb_filename *smb_fname_dot = NULL;
+ struct smb_filename *smb_fname_full = NULL;
+ NTSTATUS status;
*s = 0;
goto nocache;
}
- SET_STAT_INVALID(st);
+ status = create_synthetic_smb_fname(ctx, ".", NULL, NULL,
+ &smb_fname_dot);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ goto out;
+ }
- if (SMB_VFS_STAT(conn, ".",&st) == -1) {
+ if (SMB_VFS_STAT(conn, smb_fname_dot) == -1) {
/*
* Known to fail for root: the directory may be NFS-mounted
* and exported with root_squash (so has no root access).
goto nocache;
}
- key = vfs_file_id_from_sbuf(conn, &st);
+ key = vfs_file_id_from_sbuf(conn, &smb_fname_dot->st);
if (!memcache_lookup(smbd_memcache(), GETWD_CACHE,
data_blob_const(&key, sizeof(key)),
SMB_ASSERT((cache_value.length > 0)
&& (cache_value.data[cache_value.length-1] == '\0'));
- if ((SMB_VFS_STAT(conn, (char *)cache_value.data, &st2) == 0)
- && (st.st_ex_dev == st2.st_ex_dev) && (st.st_ex_ino == st2.st_ex_ino)
- && (S_ISDIR(st.st_ex_mode))) {
+ status = create_synthetic_smb_fname(ctx, (char *)cache_value.data,
+ NULL, NULL, &smb_fname_full);
+ if (!NT_STATUS_IS_OK(status)) {
+ errno = map_errno_from_nt_status(status);
+ goto out;
+ }
+
+ if ((SMB_VFS_STAT(conn, smb_fname_full) == 0) &&
+ (smb_fname_dot->st.st_ex_dev == smb_fname_full->st.st_ex_dev) &&
+ (smb_fname_dot->st.st_ex_ino == smb_fname_full->st.st_ex_ino) &&
+ (S_ISDIR(smb_fname_dot->st.st_ex_mode))) {
/*
* Ok, we're done
*/
- result = talloc_strdup(ctx, (char *)cache_value.data);
+ result = talloc_strdup(ctx, smb_fname_full->base_name);
if (result == NULL) {
errno = ENOMEM;
}
- return result;
+ goto out;
}
nocache:
if (!SMB_VFS_GETWD(conn,s)) {
DEBUG(0, ("vfs_GetWd: SMB_VFS_GETWD call failed: %s\n",
strerror(errno)));
- return NULL;
+ goto out;
}
- if (lp_getwd_cache() && VALID_STAT(st)) {
- key = vfs_file_id_from_sbuf(conn, &st);
+ if (lp_getwd_cache() && VALID_STAT(smb_fname_dot->st)) {
+ key = vfs_file_id_from_sbuf(conn, &smb_fname_dot->st);
memcache_add(smbd_memcache(), GETWD_CACHE,
data_blob_const(&key, sizeof(key)),
if (result == NULL) {
errno = ENOMEM;
}
+
+ out:
+ TALLOC_FREE(smb_fname_dot);
+ TALLOC_FREE(smb_fname_full);
return result;
}
#ifdef S_ISLNK
if (!lp_symlinks(SNUM(conn))) {
SMB_STRUCT_STAT statbuf;
- if ( (SMB_VFS_LSTAT(conn,fname,&statbuf) != -1) &&
+ if ( (vfs_lstat_smb_fname(conn,fname,&statbuf) != -1) &&
(S_ISLNK(statbuf.st_ex_mode)) ) {
if (free_resolved_name) {
SAFE_FREE(resolved_name);
const char *group;
struct passwd *pwd = NULL;
struct group *grp = NULL;
+ struct smb_filename *smb_fname = NULL;
SMB_STRUCT_STAT st;
time_t tmp_time;
+ NTSTATUS status;
if (argc != 2) {
printf("Usage: stat <fname>\n");
return NT_STATUS_OK;
}
- ret = SMB_VFS_STAT(vfs->conn, argv[1], &st);
+ status = create_synthetic_smb_fname_split(mem_ctx, argv[1], NULL,
+ &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ ret = SMB_VFS_STAT(vfs->conn, smb_fname);
if (ret == -1) {
printf("stat: error=%d (%s)\n", errno, strerror(errno));
+ TALLOC_FREE(smb_fname);
return NT_STATUS_UNSUCCESSFUL;
}
+ st = smb_fname->st;
+ TALLOC_FREE(smb_fname);
pwd = sys_getpwuid(st.st_ex_uid);
if (pwd != NULL) user = pwd->pw_name;
const char *group;
struct passwd *pwd = NULL;
struct group *grp = NULL;
+ struct smb_filename *smb_fname = NULL;
SMB_STRUCT_STAT st;
time_t tmp_time;
+ NTSTATUS status;
if (argc != 2) {
printf("Usage: lstat <path>\n");
return NT_STATUS_OK;
}
- if (SMB_VFS_LSTAT(vfs->conn, argv[1], &st) == -1) {
+ status = create_synthetic_smb_fname_split(mem_ctx, argv[1], NULL,
+ &smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+
+ if (SMB_VFS_LSTAT(vfs->conn, smb_fname) == -1) {
printf("lstat: error=%d (%s)\n", errno, strerror(errno));
+ TALLOC_FREE(smb_fname);
return NT_STATUS_UNSUCCESSFUL;
}
+ st = smb_fname->st;
+ TALLOC_FREE(smb_fname);
pwd = sys_getpwuid(st.st_ex_uid);
if (pwd != NULL) user = pwd->pw_name;
git.samba.org / gd / samba / .git / commitdiff