*/
#include "includes.h"
+#include "system/filesys.h"
+#include "fake_file.h"
+#include "smbd/smbd.h"
+#include "smbd/globals.h"
static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
connection_struct *conn,
- const char *orig_path,
struct smb_filename *smb_fname);
/****************************************************************************
}
}
-/**
- * XXX: This is temporary and there should be no callers of this outside of
- * this file once smb_filename is plumbed through all path based operations.
- * The one legitimate caller currently is smb_fname_str_dbg(), which this
- * could be made static for.
- */
-NTSTATUS get_full_smb_filename(TALLOC_CTX *ctx, const struct smb_filename *smb_fname,
- char **full_name)
+static NTSTATUS check_for_dot_component(const struct smb_filename *smb_fname)
{
- if (smb_fname->stream_name) {
- *full_name = talloc_asprintf(ctx, "%s%s", smb_fname->base_name,
- smb_fname->stream_name);
- } else {
- *full_name = talloc_strdup(ctx, smb_fname->base_name);
- }
-
- if (!*full_name) {
- return NT_STATUS_NO_MEMORY;
+ /* Ensure we catch all names with in "/."
+ this is disallowed under Windows and
+ in POSIX they've already been removed. */
+ const char *p = strstr(smb_fname->base_name, "/."); /*mb safe*/
+ if (p) {
+ if (p[2] == '/') {
+ /* Error code within a pathname. */
+ return NT_STATUS_OBJECT_PATH_NOT_FOUND;
+ } else if (p[2] == '\0') {
+ /* Error code at the end of a pathname. */
+ return NT_STATUS_OBJECT_NAME_INVALID;
+ }
}
-
return NT_STATUS_OK;
}
-/**
- * There are actually legitimate callers of this such as functions that
- * enumerate streams using the SMB_VFS_STREAMINFO interface and then want to
- * operate on each stream.
- */
-NTSTATUS create_synthetic_smb_fname(TALLOC_CTX *ctx, const char *base_name,
- const char *stream_name,
- const SMB_STRUCT_STAT *psbuf,
- struct smb_filename **smb_fname_out)
-{
- struct smb_filename smb_fname_loc;
-
- ZERO_STRUCT(smb_fname_loc);
-
- /* Setup the base_name/stream_name. */
- smb_fname_loc.base_name = CONST_DISCARD(char *, base_name);
- smb_fname_loc.stream_name = CONST_DISCARD(char *, stream_name);
-
- /* Copy the psbuf if one was given. */
- if (psbuf)
- smb_fname_loc.st = *psbuf;
-
- /* Let copy_smb_filename() do the heavy lifting. */
- return copy_smb_filename(ctx, &smb_fname_loc, smb_fname_out);
-}
+/****************************************************************************
+ Optimization for common case where the missing part
+ is in the last component and the client already
+ sent the correct case.
+ Returns NT_STATUS_OK to mean continue the tree walk
+ (possibly with modified start pointer).
+ Any other NT_STATUS_XXX error means terminate the path
+ lookup here.
+****************************************************************************/
-/**
- * XXX: This is temporary and there should be no callers of this once
- * smb_filename is plumbed through all path based operations.
- */
-NTSTATUS create_synthetic_smb_fname_split(TALLOC_CTX *ctx,
- const char *fname,
- const SMB_STRUCT_STAT *psbuf,
- struct smb_filename **smb_fname_out)
+static NTSTATUS check_parent_exists(TALLOC_CTX *ctx,
+ connection_struct *conn,
+ bool posix_pathnames,
+ const struct smb_filename *smb_fname,
+ char **pp_dirpath,
+ char **pp_start)
{
+ struct smb_filename parent_fname;
+ const char *last_component = NULL;
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. */
- if (stream_name) {
- base_name = talloc_strndup(ctx, fname,
- PTR_DIFF(stream_name, fname));
- } else {
- base_name = talloc_strdup(ctx, fname);
- }
+ int ret;
- if (!base_name) {
+ ZERO_STRUCT(parent_fname);
+ if (!parent_dirname(ctx, smb_fname->base_name,
+ &parent_fname.base_name,
+ &last_component)) {
return NT_STATUS_NO_MEMORY;
}
- status = create_synthetic_smb_fname(ctx, base_name, stream_name, psbuf,
- smb_fname_out);
- TALLOC_FREE(base_name);
- 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;
+ /*
+ * If there was no parent component in
+ * smb_fname->base_name of the parent name
+ * contained a wildcard then don't do this
+ * optimization.
+ */
+ if ((smb_fname->base_name == last_component) ||
+ ms_has_wild(parent_fname.base_name)) {
+ return NT_STATUS_OK;
}
- ret = SMB_VFS_STAT(conn, smb_fname);
- if (ret != -1) {
- *psbuf = smb_fname->st;
+ if (posix_pathnames) {
+ ret = SMB_VFS_LSTAT(conn, &parent_fname);
+ } else {
+ ret = SMB_VFS_STAT(conn, &parent_fname);
}
- 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;
- }
+ /* If the parent stat failed, just continue
+ with the normal tree walk. */
- ret = SMB_VFS_LSTAT(conn, smb_fname);
- if (ret != -1) {
- *psbuf = smb_fname->st;
+ if (ret == -1) {
+ return NT_STATUS_OK;
}
- TALLOC_FREE(smb_fname);
- return ret;
-}
-
-/**
- * Return a string using the debug_ctx()
- */
-const char *smb_fname_str_dbg(const struct smb_filename *smb_fname)
-{
- char *fname = NULL;
- NTSTATUS status;
-
- if (smb_fname == NULL) {
- return "";
- }
- status = get_full_smb_filename(debug_ctx(), smb_fname, &fname);
+ status = check_for_dot_component(&parent_fname);
if (!NT_STATUS_IS_OK(status)) {
- return "";
+ return status;
}
- return fname;
-}
-NTSTATUS copy_smb_filename(TALLOC_CTX *ctx,
- const struct smb_filename *smb_fname_in,
- struct smb_filename **smb_fname_out)
-{
+ /* Parent exists - set "start" to be the
+ * last component to shorten the tree walk. */
- *smb_fname_out = talloc_zero(ctx, struct smb_filename);
- if (*smb_fname_out == NULL) {
- return NT_STATUS_NO_MEMORY;
- }
-
- if (smb_fname_in->base_name) {
- (*smb_fname_out)->base_name =
- talloc_strdup(*smb_fname_out, smb_fname_in->base_name);
- if (!(*smb_fname_out)->base_name)
- goto no_mem_err;
- }
+ /*
+ * Safe to use discard_const_p
+ * here as last_component points
+ * into our smb_fname->base_name.
+ */
+ *pp_start = discard_const_p(char, last_component);
- if (smb_fname_in->stream_name) {
- (*smb_fname_out)->stream_name =
- talloc_strdup(*smb_fname_out, smb_fname_in->stream_name);
- if (!(*smb_fname_out)->stream_name)
- goto no_mem_err;
+ /* Update dirpath. */
+ TALLOC_FREE(*pp_dirpath);
+ *pp_dirpath = talloc_strdup(ctx, parent_fname.base_name);
+ if (!*pp_dirpath) {
+ return NT_STATUS_NO_MEMORY;
}
- if (smb_fname_in->original_lcomp) {
- (*smb_fname_out)->original_lcomp =
- talloc_strdup(*smb_fname_out, smb_fname_in->original_lcomp);
- if (!(*smb_fname_out)->original_lcomp)
- goto no_mem_err;
- }
+ DEBUG(5,("check_parent_exists: name "
+ "= %s, dirpath = %s, "
+ "start = %s\n",
+ smb_fname->base_name,
+ *pp_dirpath,
+ *pp_start));
- (*smb_fname_out)->st = smb_fname_in->st;
return NT_STATUS_OK;
-
- no_mem_err:
- TALLOC_FREE(*smb_fname_out);
- return NT_STATUS_NO_MEMORY;
}
/****************************************************************************
If the UCF_SAVE_LCOMP flag is passed in, then the unmodified last component
of the pathname is set in smb_filename->original_lcomp.
-If UCF_ALLOW_WCARD_LCOMP is passed in, then a MS wildcard was detected and
-should be allowed in the last component of the path only.
+If UCF_ALWAYS_ALLOW_WCARD_LCOMP is passed in, then a MS wildcard was detected
+and should be allowed in the last component of the path only.
If the orig_path was a stream, smb_filename->base_name will point to the base
filename, and smb_filename->stream_name will point to the stream name. If
struct smb_filename **smb_fname_out,
uint32_t ucf_flags)
{
- SMB_STRUCT_STAT st;
struct smb_filename *smb_fname = NULL;
char *start, *end;
char *dirpath = NULL;
- char *name = NULL;
char *stream = NULL;
bool component_was_mangled = False;
bool name_has_wildcard = False;
bool posix_pathnames = false;
- bool allow_wcard_last_component = ucf_flags & UCF_ALLOW_WCARD_LCOMP;
+ bool allow_wcard_last_component =
+ (ucf_flags & UCF_ALWAYS_ALLOW_WCARD_LCOMP);
bool save_last_component = ucf_flags & UCF_SAVE_LCOMP;
- NTSTATUS result;
+ NTSTATUS status;
int ret = -1;
*smb_fname_out = NULL;
- smb_fname = talloc_zero(talloc_tos(), struct smb_filename);
+ smb_fname = talloc_zero(ctx, struct smb_filename);
if (smb_fname == NULL) {
return NT_STATUS_NO_MEMORY;
}
filename - so don't convert them */
if (!(smb_fname->base_name = talloc_strdup(smb_fname,
orig_path))) {
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
- *smb_fname_out = smb_fname;
- return NT_STATUS_OK;
+ goto done;
}
DEBUG(5, ("unix_convert called on file \"%s\"\n", orig_path));
*/
if (!*orig_path) {
- if (!(name = talloc_strdup(ctx,"."))) {
- return NT_STATUS_NO_MEMORY;
+ if (!(smb_fname->base_name = talloc_strdup(smb_fname, "."))) {
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
- if (vfs_stat_smb_fname(conn,name,&st) == 0) {
- smb_fname->st = st;
- } else {
- return map_nt_error_from_unix(errno);
+ if (SMB_VFS_STAT(conn, smb_fname) != 0) {
+ status = map_nt_error_from_unix(errno);
+ goto err;
}
- DEBUG(5,("conversion finished \"\" -> %s\n",name));
+ DEBUG(5, ("conversion finished \"\" -> %s\n",
+ smb_fname->base_name));
goto done;
}
orig_path[1] == '\0')) {
/* Start of pathname can't be "." only. */
if (orig_path[1] == '\0' || orig_path[2] == '\0') {
- result = NT_STATUS_OBJECT_NAME_INVALID;
+ status = NT_STATUS_OBJECT_NAME_INVALID;
} else {
- result =determine_path_error(
- &orig_path[2], allow_wcard_last_component);
+ status =determine_path_error(&orig_path[2],
+ allow_wcard_last_component);
}
- return result;
+ goto err;
}
- if (!(name = talloc_strdup(ctx, orig_path))) {
+ /* Start with the full orig_path as given by the caller. */
+ if (!(smb_fname->base_name = talloc_strdup(smb_fname, orig_path))) {
DEBUG(0, ("talloc_strdup failed\n"));
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
/*
if (conn->case_sensitive && !conn->case_preserve &&
!conn->short_case_preserve) {
- strnorm(name, lp_defaultcase(SNUM(conn)));
+ if (!strnorm(smb_fname->base_name, lp_default_case(SNUM(conn)))) {
+ DEBUG(0, ("strnorm %s failed\n", smb_fname->base_name));
+ status = NT_STATUS_INVALID_PARAMETER;
+ goto err;
+ }
}
/*
*/
if(save_last_component) {
- end = strrchr_m(name, '/');
+ end = strrchr_m(smb_fname->base_name, '/');
if (end) {
- smb_fname->original_lcomp = talloc_strdup(ctx,
+ smb_fname->original_lcomp = talloc_strdup(smb_fname,
end + 1);
} else {
- smb_fname->original_lcomp = talloc_strdup(ctx, name);
+ smb_fname->original_lcomp =
+ talloc_strdup(smb_fname, smb_fname->base_name);
+ }
+ if (smb_fname->original_lcomp == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
}
- posix_pathnames = lp_posix_pathnames();
+ posix_pathnames = (lp_posix_pathnames() ||
+ (ucf_flags & UCF_POSIX_PATHNAMES));
- /* Strip off the stream. Should we use any of the other stream parsing
- * at this point? Also, should we set the is_stream bit? */
+ /*
+ * Strip off the stream, and add it back when we're done with the
+ * base_name.
+ */
if (!posix_pathnames) {
- stream = strchr_m(name, ':');
+ stream = strchr_m(smb_fname->base_name, ':');
if (stream != NULL) {
- char *tmp = talloc_strdup(ctx, stream);
+ char *tmp = talloc_strdup(smb_fname, stream);
if (tmp == NULL) {
- TALLOC_FREE(name);
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
+ /*
+ * Since this is actually pointing into
+ * smb_fname->base_name this truncates base_name.
+ */
*stream = '\0';
stream = tmp;
+
+ if (smb_fname->base_name[0] == '\0') {
+ /*
+ * orig_name was just a stream name.
+ * This is a stream on the root of
+ * the share. Replace base_name with
+ * a "."
+ */
+ smb_fname->base_name =
+ talloc_strdup(smb_fname, ".");
+ if (smb_fname->base_name == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
+ }
+ if (SMB_VFS_STAT(conn, smb_fname) != 0) {
+ status = map_nt_error_from_unix(errno);
+ goto err;
+ }
+ DEBUG(5, ("conversion finished %s -> %s\n",
+ orig_path,
+ smb_fname->base_name));
+ goto done;
+ }
}
}
- start = name;
+ start = smb_fname->base_name;
- /* If we're providing case insentive semantics or
+ /*
+ * If we're providing case insensitive semantics or
* the underlying filesystem is case insensitive,
* then a case-normalized hit in the stat-cache is
* authoratitive. JRA.
+ *
+ * Note: We're only checking base_name. The stream_name will be
+ * added and verified in build_stream_path().
*/
- if((!conn->case_sensitive || !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) &&
- stat_cache_lookup(conn, &name, &dirpath, &start, &st)) {
- smb_fname->st = st;
+ if((!conn->case_sensitive || !(conn->fs_capabilities &
+ FILE_CASE_SENSITIVE_SEARCH)) &&
+ stat_cache_lookup(conn, posix_pathnames, &smb_fname->base_name, &dirpath, &start,
+ &smb_fname->st)) {
goto done;
}
/*
* Make sure "dirpath" is an allocated string, we use this for
- * building the directories with asprintf and free it.
+ * building the directories with talloc_asprintf and free it.
*/
if ((dirpath == NULL) && (!(dirpath = talloc_strdup(ctx,"")))) {
DEBUG(0, ("talloc_strdup failed\n"));
- TALLOC_FREE(name);
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
/*
- * stat the name - if it exists then we are all done!
+ * If we have a wildcard we must walk the path to
+ * find where the error is, even if case sensitive
+ * is true.
*/
- if (posix_pathnames) {
- ret = vfs_lstat_smb_fname(conn,name,&st);
- } else {
- ret = vfs_stat_smb_fname(conn,name,&st);
+ name_has_wildcard = ms_has_wild(smb_fname->base_name);
+ if (name_has_wildcard && !allow_wcard_last_component) {
+ /* Wildcard not valid anywhere. */
+ status = NT_STATUS_OBJECT_NAME_INVALID;
+ goto fail;
}
- if (ret == 0) {
- /* Ensure we catch all names with in "/."
- this is disallowed under Windows. */
- const char *p = strstr(name, "/."); /* mb safe. */
- if (p) {
- if (p[2] == '/') {
- /* Error code within a pathname. */
- result = NT_STATUS_OBJECT_PATH_NOT_FOUND;
+ DEBUG(5,("unix_convert begin: name = %s, dirpath = %s, start = %s\n",
+ smb_fname->base_name, dirpath, start));
+
+ if (!name_has_wildcard) {
+ /*
+ * stat the name - if it exists then we can add the stream back (if
+ * there was one) and be done!
+ */
+
+ if (posix_pathnames) {
+ ret = SMB_VFS_LSTAT(conn, smb_fname);
+ } else {
+ ret = SMB_VFS_STAT(conn, smb_fname);
+ }
+
+ if (ret == 0) {
+ status = check_for_dot_component(smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
goto fail;
- } else if (p[2] == '\0') {
- /* Error code at the end of a pathname. */
- result = NT_STATUS_OBJECT_NAME_INVALID;
+ }
+ /* Add the path (not including the stream) to the cache. */
+ stat_cache_add(orig_path, smb_fname->base_name,
+ conn->case_sensitive);
+ DEBUG(5,("conversion of base_name finished %s -> %s\n",
+ orig_path, smb_fname->base_name));
+ goto done;
+ }
+
+ /* Stat failed - ensure we don't use it. */
+ SET_STAT_INVALID(smb_fname->st);
+
+ if (errno == ENOENT) {
+ /* Optimization when creating a new file - only
+ the last component doesn't exist.
+ NOTE : check_parent_exists() doesn't preserve errno.
+ */
+ int saved_errno = errno;
+ status = check_parent_exists(ctx,
+ conn,
+ posix_pathnames,
+ smb_fname,
+ &dirpath,
+ &start);
+ errno = saved_errno;
+ if (!NT_STATUS_IS_OK(status)) {
goto fail;
}
}
- stat_cache_add(orig_path, name, conn->case_sensitive);
- DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
- smb_fname->st = st;
- goto done;
- }
- DEBUG(5,("unix_convert begin: name = %s, dirpath = %s, start = %s\n",
- name, dirpath, start));
+ /*
+ * A special case - if we don't have any wildcards or mangling chars and are case
+ * sensitive or the underlying filesystem is case insensitive then searching
+ * won't help.
+ */
- /*
- * A special case - if we don't have any mangling chars and are case
- * sensitive or the underlying filesystem is case insentive then searching
- * won't help.
- */
+ if ((conn->case_sensitive || !(conn->fs_capabilities &
+ FILE_CASE_SENSITIVE_SEARCH)) &&
+ !mangle_is_mangled(smb_fname->base_name, conn->params)) {
- if ((conn->case_sensitive || !(conn->fs_capabilities & FILE_CASE_SENSITIVE_SEARCH)) &&
- !mangle_is_mangled(name, conn->params)) {
- goto done;
+ status = check_for_dot_component(smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto fail;
+ }
+
+ /*
+ * The stat failed. Could be ok as it could be
+ * a new file.
+ */
+
+ if (errno == ENOTDIR || errno == ELOOP) {
+ status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
+ goto fail;
+ } else if (errno == ENOENT) {
+ /*
+ * Was it a missing last component ?
+ * or a missing intermediate component ?
+ */
+ struct smb_filename parent_fname;
+ const char *last_component = NULL;
+
+ ZERO_STRUCT(parent_fname);
+ if (!parent_dirname(ctx, smb_fname->base_name,
+ &parent_fname.base_name,
+ &last_component)) {
+ status = NT_STATUS_NO_MEMORY;
+ goto fail;
+ }
+ if (posix_pathnames) {
+ ret = SMB_VFS_LSTAT(conn, &parent_fname);
+ } else {
+ ret = SMB_VFS_STAT(conn, &parent_fname);
+ }
+ if (ret == -1) {
+ if (errno == ENOTDIR ||
+ errno == ENOENT ||
+ errno == ELOOP) {
+ status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
+ goto fail;
+ }
+ }
+
+ /*
+ * Missing last component is ok - new file.
+ * Also deal with permission denied elsewhere.
+ * Just drop out to done.
+ */
+ goto done;
+ }
+ }
+ } else {
+ /*
+ * We have a wildcard in the pathname.
+ *
+ * Optimization for common case where the wildcard
+ * is in the last component and the client already
+ * sent the correct case.
+ * NOTE : check_parent_exists() doesn't preserve errno.
+ */
+ int saved_errno = errno;
+ status = check_parent_exists(ctx,
+ conn,
+ posix_pathnames,
+ smb_fname,
+ &dirpath,
+ &start);
+ errno = saved_errno;
+ if (!NT_STATUS_IS_OK(status)) {
+ goto fail;
+ }
}
/*
if (save_last_component) {
TALLOC_FREE(smb_fname->original_lcomp);
- smb_fname->original_lcomp = talloc_strdup(ctx,
+ smb_fname->original_lcomp = talloc_strdup(smb_fname,
end ? end + 1 : start);
if (!smb_fname->original_lcomp) {
DEBUG(0, ("talloc failed\n"));
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
}
if (ISDOT(start)) {
if (!end) {
/* Error code at the end of a pathname. */
- result = NT_STATUS_OBJECT_NAME_INVALID;
+ status = NT_STATUS_OBJECT_NAME_INVALID;
} else {
- result = determine_path_error(end+1,
+ status = determine_path_error(end+1,
allow_wcard_last_component);
}
goto fail;
name_has_wildcard = ms_has_wild(start);
- /* Wildcard not valid anywhere. */
- if (name_has_wildcard && !allow_wcard_last_component) {
- result = NT_STATUS_OBJECT_NAME_INVALID;
- goto fail;
- }
-
/* Wildcards never valid within a pathname. */
if (name_has_wildcard && end) {
- result = NT_STATUS_OBJECT_NAME_INVALID;
+ status = NT_STATUS_OBJECT_NAME_INVALID;
goto fail;
}
+ /* Skip the stat call if it's a wildcard end. */
+ if (name_has_wildcard) {
+ DEBUG(5,("Wildcard %s\n",start));
+ goto done;
+ }
+
/*
* Check if the name exists up to this point.
*/
if (posix_pathnames) {
- ret = vfs_lstat_smb_fname(conn,name, &st);
+ ret = SMB_VFS_LSTAT(conn, smb_fname);
} else {
- ret = vfs_stat_smb_fname(conn,name, &st);
+ ret = SMB_VFS_STAT(conn, smb_fname);
}
if (ret == 0) {
* It exists. it must either be a directory or this must
* be the last part of the path for it to be OK.
*/
- if (end && !S_ISDIR(st.st_ex_mode)) {
+ if (end && !S_ISDIR(smb_fname->st.st_ex_mode)) {
/*
* An intermediate part of the name isn't
* a directory.
* applications depend on the difference between
* these two errors.
*/
- result = NT_STATUS_OBJECT_PATH_NOT_FOUND;
+ status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
goto fail;
}
- if (!end) {
- /*
- * We just scanned for, and found the end of
- * the path. We must return the valid stat
- * struct. JRA.
- */
-
- smb_fname->st = st;
- }
-
} else {
char *found_name = NULL;
/* Stat failed - ensure we don't use it. */
- SET_STAT_INVALID(st);
+ SET_STAT_INVALID(smb_fname->st);
/*
* Reset errno so we can detect
if (errno == ENOENT ||
errno == ENOTDIR ||
errno == ELOOP) {
- result =
+ status =
NT_STATUS_OBJECT_PATH_NOT_FOUND;
}
else {
- result =
+ status =
map_nt_error_from_unix(errno);
}
goto fail;
/*
* ENOENT/EACCESS are the only valid errors
- * here. EACCESS needs handling here for
- * "dropboxes", i.e. directories where users
- * can only put stuff with permission -wx.
+ * here.
*/
- if ((errno != 0) && (errno != ENOENT)
- && (errno != EACCES)) {
+
+ if (errno == EACCES) {
+ if ((ucf_flags & UCF_PREP_CREATEFILE) == 0) {
+ status = NT_STATUS_ACCESS_DENIED;
+ goto fail;
+ } else {
+ /*
+ * This is the dropbox
+ * behaviour. A dropbox is a
+ * directory with only -wx
+ * permissions, so
+ * get_real_filename fails
+ * with EACCESS, it needs to
+ * list the directory. We
+ * nevertheless want to allow
+ * users creating a file.
+ */
+ errno = 0;
+ }
+ }
+
+ if ((errno != 0) && (errno != ENOENT)) {
/*
* ENOTDIR and ELOOP both map to
* NT_STATUS_OBJECT_PATH_NOT_FOUND
*/
if (errno == ENOTDIR ||
errno == ELOOP) {
- result =
+ status =
NT_STATUS_OBJECT_PATH_NOT_FOUND;
} else {
- result =
+ status =
map_nt_error_from_unix(errno);
}
goto fail;
(mangle_is_8_3(start, False,
conn->params) &&
!conn->short_case_preserve)) {
- strnorm(start,
- lp_defaultcase(SNUM(conn)));
+ if (!strnorm(start,
+ lp_default_case(SNUM(conn)))) {
+ DEBUG(0, ("strnorm %s failed\n",
+ start));
+ status = NT_STATUS_INVALID_PARAMETER;
+ goto err;
+ }
}
/*
&unmangled,
conn->params)) {
char *tmp;
- size_t start_ofs = start - name;
+ size_t start_ofs =
+ start - smb_fname->base_name;
if (*dirpath != '\0') {
- tmp = talloc_asprintf(ctx,
- "%s/%s", dirpath,
- unmangled);
+ tmp = talloc_asprintf(
+ smb_fname, "%s/%s",
+ dirpath, unmangled);
TALLOC_FREE(unmangled);
}
else {
}
if (tmp == NULL) {
DEBUG(0, ("talloc failed\n"));
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
- TALLOC_FREE(name);
- name = tmp;
- start = name + start_ofs;
+ TALLOC_FREE(smb_fname->base_name);
+ smb_fname->base_name = tmp;
+ start =
+ smb_fname->base_name + start_ofs;
end = start + strlen(start);
}
*/
if (end) {
char *tmp;
- size_t start_ofs = start - name;
+ size_t start_ofs =
+ start - smb_fname->base_name;
if (*dirpath != '\0') {
- tmp = talloc_asprintf(ctx,
+ tmp = talloc_asprintf(smb_fname,
"%s/%s/%s", dirpath,
found_name, end+1);
}
else {
- tmp = talloc_asprintf(ctx,
+ tmp = talloc_asprintf(smb_fname,
"%s/%s", found_name,
end+1);
}
if (tmp == NULL) {
DEBUG(0, ("talloc_asprintf failed\n"));
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
- TALLOC_FREE(name);
- name = tmp;
- start = name + start_ofs;
+ TALLOC_FREE(smb_fname->base_name);
+ smb_fname->base_name = tmp;
+ start = smb_fname->base_name + start_ofs;
end = start + strlen(found_name);
*end = '\0';
} else {
char *tmp;
- size_t start_ofs = start - name;
+ size_t start_ofs =
+ start - smb_fname->base_name;
if (*dirpath != '\0') {
- tmp = talloc_asprintf(ctx,
+ tmp = talloc_asprintf(smb_fname,
"%s/%s", dirpath,
found_name);
} else {
- tmp = talloc_strdup(ctx,
+ tmp = talloc_strdup(smb_fname,
found_name);
}
if (tmp == NULL) {
DEBUG(0, ("talloc failed\n"));
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
- TALLOC_FREE(name);
- name = tmp;
- start = name + start_ofs;
+ TALLOC_FREE(smb_fname->base_name);
+ smb_fname->base_name = tmp;
+ start = smb_fname->base_name + start_ofs;
/*
* We just scanned for, and found the end of
*/
if (posix_pathnames) {
- ret = vfs_lstat_smb_fname(conn,name,
- &st);
+ ret = SMB_VFS_LSTAT(conn, smb_fname);
} else {
- ret = vfs_stat_smb_fname(conn,name,
- &st);
+ ret = SMB_VFS_STAT(conn, smb_fname);
}
- if (ret == 0) {
- smb_fname->st = st;
- } else {
- SET_STAT_INVALID(st);
+ if (ret != 0) {
+ SET_STAT_INVALID(smb_fname->st);
}
}
* We should never provide different behaviors
* depending on DEVELOPER!!!
*/
- if (VALID_STAT(st)) {
+ if (VALID_STAT(smb_fname->st)) {
bool delete_pending;
- get_file_infos(vfs_file_id_from_sbuf(conn, &st),
+ uint32_t name_hash;
+
+ status = file_name_hash(conn,
+ smb_fname_str_dbg(smb_fname),
+ &name_hash);
+ if (!NT_STATUS_IS_OK(status)) {
+ goto fail;
+ }
+
+ get_file_infos(vfs_file_id_from_sbuf(conn,
+ &smb_fname->st),
+ name_hash,
&delete_pending, NULL);
if (delete_pending) {
- result = NT_STATUS_DELETE_PENDING;
+ status = NT_STATUS_DELETE_PENDING;
goto fail;
}
}
"%s/%s", dirpath, start);
if (!tmp) {
DEBUG(0, ("talloc_asprintf failed\n"));
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
TALLOC_FREE(dirpath);
dirpath = tmp;
TALLOC_FREE(dirpath);
if (!(dirpath = talloc_strdup(ctx,start))) {
DEBUG(0, ("talloc_strdup failed\n"));
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
}
/*
- * Don't cache a name with mangled or wildcard components
- * as this can change the size.
+ * Cache the dirpath thus far. Don't cache a name with mangled
+ * or wildcard components as this can change the size.
*/
-
if(!component_was_mangled && !name_has_wildcard) {
stat_cache_add(orig_path, dirpath,
conn->case_sensitive);
}
/*
- * Don't cache a name with mangled or wildcard components
- * as this can change the size.
+ * Cache the full path. Don't cache a name with mangled or wildcard
+ * components as this can change the size.
*/
if(!component_was_mangled && !name_has_wildcard) {
- stat_cache_add(orig_path, name, conn->case_sensitive);
+ stat_cache_add(orig_path, smb_fname->base_name,
+ conn->case_sensitive);
}
/*
* The name has been resolved.
*/
- DEBUG(5,("conversion finished %s -> %s\n",orig_path, name));
+ DEBUG(5,("conversion finished %s -> %s\n", orig_path,
+ smb_fname->base_name));
done:
- smb_fname->base_name = name;
-
+ /* Add back the stream if one was stripped off originally. */
if (stream != NULL) {
smb_fname->stream_name = stream;
/* Check path now that the base_name has been converted. */
- result = build_stream_path(ctx, conn, orig_path, smb_fname);
- if (!NT_STATUS_IS_OK(result)) {
+ status = build_stream_path(ctx, conn, smb_fname);
+ if (!NT_STATUS_IS_OK(status)) {
goto fail;
}
}
return NT_STATUS_OK;
fail:
DEBUG(10, ("dirpath = [%s] start = [%s]\n", dirpath, start));
- if (*dirpath != '\0') {
- smb_fname->base_name = talloc_asprintf(ctx, "%s/%s", dirpath,
- start);
+ if (dirpath && *dirpath != '\0') {
+ smb_fname->base_name = talloc_asprintf(smb_fname, "%s/%s",
+ dirpath, start);
} else {
- smb_fname->base_name = talloc_strdup(ctx, start);
+ smb_fname->base_name = talloc_strdup(smb_fname, start);
}
if (!smb_fname->base_name) {
DEBUG(0, ("talloc_asprintf failed\n"));
- return NT_STATUS_NO_MEMORY;
+ status = NT_STATUS_NO_MEMORY;
+ goto err;
}
*smb_fname_out = smb_fname;
- TALLOC_FREE(name);
TALLOC_FREE(dirpath);
- return result;
+ return status;
+ err:
+ TALLOC_FREE(smb_fname);
+ return status;
}
/****************************************************************************
- Check a filename - possibly calling check_reduced_name.
- This is called by every routine before it allows an operation on a filename.
- It does any final confirmation necessary to ensure that the filename is
- a valid one for the user to access.
+ Ensure a path is not vetoed.
****************************************************************************/
-NTSTATUS check_name(connection_struct *conn, const char *name)
+static NTSTATUS check_veto_path(connection_struct *conn, const char *name)
{
if (IS_VETO_PATH(conn, name)) {
/* Is it not dot or dot dot. */
- if (!((name[0] == '.') && (!name[1] ||
- (name[1] == '.' && !name[2])))) {
- DEBUG(5,("check_name: file path name %s vetoed\n",
+ if (!(ISDOT(name) || ISDOTDOT(name))) {
+ DEBUG(5,("check_veto_path: file path name %s vetoed\n",
name));
return map_nt_error_from_unix(ENOENT);
}
}
+ return NT_STATUS_OK;
+}
+
+/****************************************************************************
+ Check a filename - possibly calling check_reduced_name.
+ This is called by every routine before it allows an operation on a filename.
+ It does any final confirmation necessary to ensure that the filename is
+ a valid one for the user to access.
+****************************************************************************/
+
+NTSTATUS check_name(connection_struct *conn, const char *name)
+{
+ NTSTATUS status = check_veto_path(conn, name);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
- if (!lp_widelinks(SNUM(conn)) || !lp_symlinks(SNUM(conn))) {
- NTSTATUS status = check_reduced_name(conn,name);
+ if (!lp_widelinks(SNUM(conn)) || !lp_follow_symlinks(SNUM(conn))) {
+ status = check_reduced_name(conn,name);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(5,("check_name: name %s failed with %s\n",name,
nt_errstr(status)));
return NT_STATUS_OK;
}
+/****************************************************************************
+ Must be called as root. Creates the struct privilege_paths
+ attached to the struct smb_request if this call is successful.
+****************************************************************************/
+
+static NTSTATUS check_name_with_privilege(connection_struct *conn,
+ struct smb_request *smbreq,
+ const char *name)
+{
+ NTSTATUS status = check_veto_path(conn, name);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ return status;
+ }
+ return check_reduced_name_with_privilege(conn,
+ name,
+ smbreq);
+}
+
/****************************************************************************
Check if two filenames are equal.
This needs to be careful about whether we are case sensitive.
TALLOC_CTX *mem_ctx, char **found_name)
{
struct smb_Dir *cur_dir;
- const char *dname;
+ const char *dname = NULL;
+ char *talloced = NULL;
char *unmangled_name = NULL;
long curpos;
/* now scan for matching names */
curpos = 0;
- while ((dname = ReadDirName(cur_dir, &curpos, NULL))) {
+ while ((dname = ReadDirName(cur_dir, &curpos, NULL, &talloced))) {
/* Is it dot or dot dot. */
if (ISDOT(dname) || ISDOTDOT(dname)) {
+ TALLOC_FREE(talloced);
continue;
}
TALLOC_FREE(cur_dir);
if (!*found_name) {
errno = ENOMEM;
+ TALLOC_FREE(talloced);
return -1;
}
+ TALLOC_FREE(talloced);
return 0;
}
+ TALLOC_FREE(talloced);
}
TALLOC_FREE(unmangled_name);
static NTSTATUS build_stream_path(TALLOC_CTX *mem_ctx,
connection_struct *conn,
- const char *orig_path,
struct smb_filename *smb_fname)
{
NTSTATUS status;
- unsigned int i, num_streams;
+ unsigned int i, num_streams = 0;
struct stream_struct *streams = NULL;
if (SMB_VFS_STAT(conn, smb_fname) == 0) {
+ DEBUG(10, ("'%s' exists\n", smb_fname_str_dbg(smb_fname)));
return NT_STATUS_OK;
}
if (errno != ENOENT) {
+ DEBUG(10, ("vfs_stat failed: %s\n", strerror(errno)));
status = map_nt_error_from_unix(errno);
- DEBUG(10, ("vfs_stat failed: %s\n", nt_errstr(status)));
goto fail;
}
/* Fall back to a case-insensitive scan of all streams on the file. */
- status = SMB_VFS_STREAMINFO(conn, NULL, smb_fname->base_name, mem_ctx,
- &num_streams, &streams);
+ status = vfs_streaminfo(conn, NULL, smb_fname->base_name, mem_ctx,
+ &num_streams, &streams);
if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
SET_STAT_INVALID(smb_fname->st);
TALLOC_FREE(smb_fname->stream_name);
- smb_fname->stream_name = talloc_strdup(mem_ctx, streams[i].name);
+ smb_fname->stream_name = talloc_strdup(smb_fname, streams[i].name);
+ if (smb_fname->stream_name == NULL) {
+ status = NT_STATUS_NO_MEMORY;
+ goto fail;
+ }
SET_STAT_INVALID(smb_fname->st);
if (SMB_VFS_STAT(conn, smb_fname) == 0) {
- char *result = NULL;
-
- 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);
+ DEBUG(10, ("'%s' exists\n", smb_fname_str_dbg(smb_fname)));
}
status = NT_STATUS_OK;
fail:
return status;
}
-/****************************************************************************
- Go through all the steps to validate a filename.
-****************************************************************************/
-
-NTSTATUS filename_convert(TALLOC_CTX *ctx,
+/**
+ * Go through all the steps to validate a filename.
+ *
+ * @param ctx talloc_ctx to allocate memory with.
+ * @param conn connection struct for vfs calls.
+ * @param dfs_path Whether this path requires dfs resolution.
+ * @param smbreq SMB request if we're using privileges.
+ * @param name_in The unconverted name.
+ * @param ucf_flags flags to pass through to unix_convert().
+ * UCF_ALWAYS_ALLOW_WCARD_LCOMP will be OR'd in if
+ * p_cont_wcard != NULL and is true and
+ * UCF_COND_ALLOW_WCARD_LCOMP.
+ * @param p_cont_wcard If not NULL, will be set to true if the dfs path
+ * resolution detects a wildcard.
+ * @param pp_smb_fname The final converted name will be allocated if the
+ * return is NT_STATUS_OK.
+ *
+ * @return NT_STATUS_OK if all operations completed succesfully, appropriate
+ * error otherwise.
+ */
+static NTSTATUS filename_convert_internal(TALLOC_CTX *ctx,
connection_struct *conn,
bool dfs_path,
+ struct smb_request *smbreq,
const char *name_in,
- struct smb_filename **pp_smb_fname,
- char **pp_name)
+ uint32_t ucf_flags,
+ bool *ppath_contains_wcard,
+ struct smb_filename **pp_smb_fname)
{
NTSTATUS status;
+ bool allow_wcards = (ucf_flags & (UCF_COND_ALLOW_WCARD_LCOMP|UCF_ALWAYS_ALLOW_WCARD_LCOMP));
+ char *fname = NULL;
*pp_smb_fname = NULL;
- *pp_name = NULL;
- status = resolve_dfspath(ctx, conn,
+ status = resolve_dfspath_wcard(ctx, conn,
dfs_path,
name_in,
- pp_name);
+ allow_wcards,
+ !conn->sconn->using_smb2,
+ &fname,
+ ppath_contains_wcard);
if (!NT_STATUS_IS_OK(status)) {
- DEBUG(10,("filename_convert: resolve_dfspath failed "
+ DEBUG(10,("filename_convert_internal: resolve_dfspath failed "
"for name %s with %s\n",
name_in,
nt_errstr(status) ));
return status;
}
- status = unix_convert(ctx, conn, *pp_name, pp_smb_fname, 0);
+
+ if (is_fake_file_path(name_in)) {
+ SMB_STRUCT_STAT st;
+ ZERO_STRUCT(st);
+ st.st_ex_nlink = 1;
+ *pp_smb_fname = synthetic_smb_fname_split(ctx,
+ name_in,
+ &st);
+ if (*pp_smb_fname == NULL) {
+ return NT_STATUS_NO_MEMORY;
+ }
+ return NT_STATUS_OK;
+ }
+
+ /*
+ * If the caller conditionally allows wildcard lookups, only add the
+ * always allow if the path actually does contain a wildcard.
+ */
+ if (ucf_flags & UCF_COND_ALLOW_WCARD_LCOMP &&
+ ppath_contains_wcard != NULL && *ppath_contains_wcard) {
+ ucf_flags |= UCF_ALWAYS_ALLOW_WCARD_LCOMP;
+ }
+
+ status = unix_convert(ctx, conn, fname, pp_smb_fname, ucf_flags);
if (!NT_STATUS_IS_OK(status)) {
- DEBUG(10,("filename_convert: unix_convert failed "
+ DEBUG(10,("filename_convert_internal: unix_convert failed "
"for name %s with %s\n",
- *pp_name,
+ fname,
nt_errstr(status) ));
return status;
}
- status = get_full_smb_filename(ctx, *pp_smb_fname, pp_name);
- if (!NT_STATUS_IS_OK(status)) {
- return status;
+ if ((ucf_flags & UCF_UNIX_NAME_LOOKUP) &&
+ VALID_STAT((*pp_smb_fname)->st) &&
+ S_ISLNK((*pp_smb_fname)->st.st_ex_mode)) {
+ return check_veto_path(conn, (*pp_smb_fname)->base_name);
}
- status = check_name(conn, *pp_name);
+ if (!smbreq) {
+ status = check_name(conn, (*pp_smb_fname)->base_name);
+ } else {
+ status = check_name_with_privilege(conn, smbreq, (*pp_smb_fname)->base_name);
+ }
if (!NT_STATUS_IS_OK(status)) {
- DEBUG(3,("filename_convert: check_name failed "
+ DEBUG(3,("filename_convert_internal: check_name failed "
"for name %s with %s\n",
- *pp_name,
+ smb_fname_str_dbg(*pp_smb_fname),
nt_errstr(status) ));
+ TALLOC_FREE(*pp_smb_fname);
return status;
}
+
return status;
}
+
+/*
+ * Go through all the steps to validate a filename.
+ * Non-root version.
+ */
+
+NTSTATUS filename_convert(TALLOC_CTX *ctx,
+ connection_struct *conn,
+ bool dfs_path,
+ const char *name_in,
+ uint32_t ucf_flags,
+ bool *ppath_contains_wcard,
+ struct smb_filename **pp_smb_fname)
+{
+ return filename_convert_internal(ctx,
+ conn,
+ dfs_path,
+ NULL,
+ name_in,
+ ucf_flags,
+ ppath_contains_wcard,
+ pp_smb_fname);
+}
+
+/*
+ * Go through all the steps to validate a filename.
+ * root (privileged) version.
+ */
+
+NTSTATUS filename_convert_with_privilege(TALLOC_CTX *ctx,
+ connection_struct *conn,
+ struct smb_request *smbreq,
+ const char *name_in,
+ uint32_t ucf_flags,
+ bool *ppath_contains_wcard,
+ struct smb_filename **pp_smb_fname)
+{
+ return filename_convert_internal(ctx,
+ conn,
+ smbreq->flags2 & FLAGS2_DFS_PATHNAMES,
+ smbreq,
+ name_in,
+ ucf_flags,
+ ppath_contains_wcard,
+ pp_smb_fname);
+}