/* For non-directory PATHs full entry information is obtained by reading
* the entries for the parent directory of PATH and then extracting PATH's
* entry. If PATH is a directory then only abrieviated information is
* available in the parent directory, more complete information is
* available by reading the entries for PATH itself.
*
* Note: There is one bit of information about directories that is only
* available in the parent directory, that is the "deleted" state. If PATH
* is a versioned directory then the "deleted" state information will not
* be returned in ENTRY. This means some bits of the code (e.g. revert)
* need to obtain it by directly extracting the directory entry from the
* parent directory's entries. I wonder if this function should handle
* that?
*/
svn_error_t *
svn_wc_entry(const svn_wc_entry_t **entry,
const char *path,
svn_wc_adm_access_t *adm_access,
svn_boolean_t show_hidden,
apr_pool_t *pool)
{
svn_wc__db_t *db = svn_wc__adm_get_db(adm_access);
const char *local_abspath;
svn_wc_adm_access_t *dir_access;
const char *entry_name;
apr_hash_t *entries;
SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
/* Does the provided path refer to a directory with an associated
access baton? */
dir_access = svn_wc__adm_retrieve_internal2(db, local_abspath, pool);
if (dir_access == NULL)
{
/* Damn. Okay. Assume the path is to a child, and let's look for
a baton associated with its parent. */
const char *dir_abspath;
svn_dirent_split(&dir_abspath, &entry_name, local_abspath, pool);
dir_access = svn_wc__adm_retrieve_internal2(db, dir_abspath, pool);
}
else
{
/* Woo! Got one. Look for "this dir" in the entries hash. */
entry_name = "";
}
if (dir_access == NULL)
{
/* Early exit. */
*entry = NULL;
return SVN_NO_ERROR;
}
/* Load an entries hash, and cache it into DIR_ACCESS. Go ahead and
fetch all entries here (optimization) since we know how to filter
out a "hidden" node. */
SVN_ERR(svn_wc__entries_read_internal(&entries, dir_access, TRUE, pool));
*entry = svn_hash_gets(entries, entry_name);
if (!show_hidden && *entry != NULL)
{
svn_boolean_t hidden;
SVN_ERR(svn_wc__entry_is_hidden(&hidden, *entry));
if (hidden)
*entry = NULL;
}
return SVN_NO_ERROR;
}
/* Copy the file or directory tree FROM_PATH to TO_PATH which must not exist
* beforehand. */
svn_error_t *
sbox_disk_copy(svn_test__sandbox_t *b, const char *from_path, const char *to_path)
{
const char *to_dir, *to_name;
from_path = sbox_wc_path(b, from_path);
to_path = sbox_wc_path(b, to_path);
svn_dirent_split(&to_dir, &to_name, to_path, b->pool);
return svn_io_copy_dir_recursively(from_path, to_dir, to_name,
FALSE, NULL, NULL, b->pool);
}
/* Use the visual editor to edit files. This requires that the file name itself
be shell-safe, although the path to reach that file need not be shell-safe.
*/
svn_error_t *
svn_cl__edit_file_externally(const char *path,
const char *editor_cmd,
apr_hash_t *config,
apr_pool_t *pool)
{
const char *editor, *cmd, *base_dir, *file_name, *base_dir_apr;
char *old_cwd;
int sys_err;
apr_status_t apr_err;
svn_dirent_split(&base_dir, &file_name, path, pool);
SVN_ERR(find_editor_binary(&editor, editor_cmd, config));
apr_err = apr_filepath_get(&old_cwd, APR_FILEPATH_NATIVE, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, _("Can't get working directory"));
/* APR doesn't like "" directories */
if (base_dir[0] == '\0')
base_dir_apr = ".";
else
SVN_ERR(svn_path_cstring_from_utf8(&base_dir_apr, base_dir, pool));
apr_err = apr_filepath_set(base_dir_apr, pool);
if (apr_err)
return svn_error_wrap_apr
(apr_err, _("Can't change working directory to '%s'"), base_dir);
cmd = apr_psprintf(pool, "%s %s", editor, file_name);
sys_err = system(cmd);
apr_err = apr_filepath_set(old_cwd, pool);
if (apr_err)
svn_handle_error2(svn_error_wrap_apr
(apr_err, _("Can't restore working directory")),
stderr, TRUE /* fatal */, "svn: ");
if (sys_err)
/* Extracting any meaning from sys_err is platform specific, so just
use the raw value. */
return svn_error_createf(SVN_ERR_EXTERNAL_PROGRAM, NULL,
_("system('%s') returned %d"), cmd, sys_err);
return SVN_NO_ERROR;
}
/* Make a relative path containing '..' elements as needed.
RELATIVE_TO_PATH must be the path to a directory (not a file!) and
TARGET_PATH must be the path to any file or directory. Both
RELATIVE_TO_PATH and TARGET_PATH must be based on the same parent path,
i.e. they can either both be absolute or they can both be relative to the
same parent directory. Both paths are expected to be canonical.
If above conditions are met, a relative path that leads to TARGET_ABSPATH
from RELATIVE_TO_PATH is returned, but there is no error checking involved.
The returned path is allocated from RESULT_POOL, all other allocations are
made in SCRATCH_POOL. */
static const char *
make_relpath(const char *relative_to_path,
const char *target_path,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *la;
const char *parent_dir_els = "";
/* An example:
* relative_to_path = /a/b/c
* target_path = /a/x/y/z
* result = ../../x/y/z
*
* Another example (Windows specific):
* relative_to_path = F:/wc
* target_path = C:/wc
* result = C:/wc
*/
/* Skip the common ancestor of both paths, here '/a'. */
la = svn_dirent_get_longest_ancestor(relative_to_path, target_path,
scratch_pool);
if (*la == '\0')
{
/* Nothing in common: E.g. C:/ vs F:/ on Windows */
return apr_pstrdup(result_pool, target_path);
}
relative_to_path = svn_dirent_skip_ancestor(la, relative_to_path);
target_path = svn_dirent_skip_ancestor(la, target_path);
/* In above example, we'd now have:
* relative_to_path = b/c
* target_path = x/y/z */
/* Count the elements of relative_to_path and prepend as many '..' elements
* to target_path. */
while (*relative_to_path)
{
svn_dirent_split(&relative_to_path, NULL, relative_to_path,
scratch_pool);
parent_dir_els = svn_dirent_join(parent_dir_els, "..", scratch_pool);
}
return svn_dirent_join(parent_dir_els, target_path, result_pool);
}
/* This is a wrapper around svn_uri_condense_targets() and
* svn_dirent_condense_targets() (the choice of which is made based on
* the value of TARGETS_ARE_URIS) which takes care of the
* single-target special case.
*
* Callers are expected to check for an empty *COMMON_PARENT (which
* means, "there was nothing common") for themselves.
*/
static svn_error_t *
condense_targets(const char **common_parent,
apr_array_header_t **target_relpaths,
const apr_array_header_t *targets,
svn_boolean_t targets_are_uris,
svn_boolean_t remove_redundancies,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
if (targets_are_uris)
{
SVN_ERR(svn_uri_condense_targets(common_parent, target_relpaths,
targets, remove_redundancies,
result_pool, scratch_pool));
}
else
{
SVN_ERR(svn_dirent_condense_targets(common_parent, target_relpaths,
targets, remove_redundancies,
result_pool, scratch_pool));
}
/* svn_*_condense_targets leaves *TARGET_RELPATHS empty if TARGETS only
had 1 member, so we special case that. */
if (apr_is_empty_array(*target_relpaths))
{
const char *base_name;
if (targets_are_uris)
{
svn_uri_split(common_parent, &base_name,
*common_parent, result_pool);
}
else
{
svn_dirent_split(common_parent, &base_name,
*common_parent, result_pool);
}
APR_ARRAY_PUSH(*target_relpaths, const char *) = base_name;
}
return SVN_NO_ERROR;
}
/* Remove the directory at LOCAL_ABSPATH from revision control, and do the
* same to any revision controlled directories underneath LOCAL_ABSPATH
* (including directories not referred to by parent svn administrative areas);
* then if LOCAL_ABSPATH is empty afterwards, remove it, else rename it to a
* unique name in the same parent directory.
*
* Pass CANCEL_FUNC, CANCEL_BATON to svn_wc_remove_from_revision_control.
*
* Use SCRATCH_POOL for all temporary allocation.
*/
static svn_error_t *
relegate_dir_external(svn_wc_context_t *wc_ctx,
const char *wri_abspath,
const char *local_abspath,
svn_cancel_func_t cancel_func,
void *cancel_baton,
svn_wc_notify_func2_t notify_func,
void *notify_baton,
apr_pool_t *scratch_pool)
{
svn_error_t *err = SVN_NO_ERROR;
SVN_ERR(svn_wc__acquire_write_lock(NULL, wc_ctx, local_abspath,
FALSE, scratch_pool, scratch_pool));
err = svn_wc__external_remove(wc_ctx, wri_abspath, local_abspath, FALSE,
cancel_func, cancel_baton, scratch_pool);
if (err && (err->apr_err == SVN_ERR_WC_LEFT_LOCAL_MOD))
{
const char *parent_dir;
const char *dirname;
const char *new_path;
svn_error_clear(err);
err = SVN_NO_ERROR;
svn_dirent_split(&parent_dir, &dirname, local_abspath, scratch_pool);
/* Reserve the new dir name. */
SVN_ERR(svn_io_open_uniquely_named(NULL, &new_path,
parent_dir, dirname, ".OLD",
svn_io_file_del_none,
scratch_pool, scratch_pool));
/* Sigh... We must fall ever so slightly from grace.
Ideally, there would be no window, however brief, when we
don't have a reservation on the new name. Unfortunately,
at least in the Unix (Linux?) version of apr_file_rename(),
you can't rename a directory over a file, because it's just
calling stdio rename(), which says:
ENOTDIR
A component used as a directory in oldpath or newpath
path is not, in fact, a directory. Or, oldpath is
a directory, and newpath exists but is not a directory
So instead, we get the name, then remove the file (ugh), then
rename the directory, hoping that nobody has gotten that name
in the meantime -- which would never happen in real life, so
no big deal.
*/
/* Do our best, but no biggy if it fails. The rename will fail. */
svn_error_clear(svn_io_remove_file2(new_path, TRUE, scratch_pool));
/* Rename. If this is still a working copy we should use the working
copy rename function (to release open handles) */
err = svn_wc__rename_wc(wc_ctx, local_abspath, new_path,
scratch_pool);
if (err && err->apr_err == SVN_ERR_WC_PATH_UNEXPECTED_STATUS)
{
svn_error_clear(err);
/* And if it is no longer a working copy, we should just rename
it */
err = svn_io_file_rename(local_abspath, new_path, scratch_pool);
}
/* ### TODO: We should notify the user about the rename */
if (notify_func)
{
svn_wc_notify_t *notify;
notify = svn_wc_create_notify(err ? local_abspath : new_path,
svn_wc_notify_left_local_modifications,
scratch_pool);
notify->kind = svn_node_dir;
notify->err = err;
notify_func(notify_baton, notify, scratch_pool);
}
}
return svn_error_trace(err);
}
/* Try to update a file external at LOCAL_ABSPATH to URL at REVISION using a
access baton that has a write lock. Use SCRATCH_POOL for temporary
allocations, and use the client context CTX. */
static svn_error_t *
switch_file_external(const char *local_abspath,
const char *url,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
const char *def_dir_abspath,
svn_ra_session_t *ra_session,
svn_client_ctx_t *ctx,
apr_pool_t *scratch_pool)
{
svn_config_t *cfg = ctx->config
? svn_hash_gets(ctx->config, SVN_CONFIG_CATEGORY_CONFIG)
: NULL;
svn_boolean_t use_commit_times;
const char *diff3_cmd;
const char *preserved_exts_str;
const apr_array_header_t *preserved_exts;
svn_node_kind_t kind, external_kind;
SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
/* See if the user wants last-commit timestamps instead of current ones. */
SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_USE_COMMIT_TIMES, FALSE));
/* Get the external diff3, if any. */
svn_config_get(cfg, &diff3_cmd, SVN_CONFIG_SECTION_HELPERS,
SVN_CONFIG_OPTION_DIFF3_CMD, NULL);
if (diff3_cmd != NULL)
SVN_ERR(svn_path_cstring_to_utf8(&diff3_cmd, diff3_cmd, scratch_pool));
/* See which files the user wants to preserve the extension of when
conflict files are made. */
svn_config_get(cfg, &preserved_exts_str, SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS, "");
preserved_exts = *preserved_exts_str
? svn_cstring_split(preserved_exts_str, "\n\r\t\v ", FALSE, scratch_pool)
: NULL;
{
const char *wcroot_abspath;
SVN_ERR(svn_wc__get_wcroot(&wcroot_abspath, ctx->wc_ctx, local_abspath,
scratch_pool, scratch_pool));
/* File externals can only be installed inside the current working copy.
So verify if the working copy that contains/will contain the target
is the defining abspath, or one of its ancestors */
if (!svn_dirent_is_ancestor(wcroot_abspath, def_dir_abspath))
return svn_error_createf(
SVN_ERR_WC_BAD_PATH, NULL,
_("Cannot insert a file external defined on '%s' "
"into the working copy '%s'."),
svn_dirent_local_style(def_dir_abspath,
scratch_pool),
svn_dirent_local_style(wcroot_abspath,
scratch_pool));
}
SVN_ERR(svn_wc_read_kind2(&kind, ctx->wc_ctx, local_abspath,
TRUE, FALSE, scratch_pool));
SVN_ERR(svn_wc__read_external_info(&external_kind, NULL, NULL, NULL, NULL,
ctx->wc_ctx, local_abspath, local_abspath,
TRUE, scratch_pool, scratch_pool));
/* If there is a versioned item with this name, ensure it's a file
external before working with it. If there is no entry in the
working copy, then create an empty file and add it to the working
copy. */
if (kind != svn_node_none && kind != svn_node_unknown)
{
if (external_kind != svn_node_file)
{
return svn_error_createf(
SVN_ERR_CLIENT_FILE_EXTERNAL_OVERWRITE_VERSIONED, 0,
_("The file external from '%s' cannot overwrite the existing "
"versioned item at '%s'"),
url, svn_dirent_local_style(local_abspath, scratch_pool));
}
}
else
{
svn_node_kind_t disk_kind;
SVN_ERR(svn_io_check_path(local_abspath, &disk_kind, scratch_pool));
if (kind == svn_node_file || kind == svn_node_dir)
return svn_error_createf(SVN_ERR_WC_PATH_FOUND, NULL,
_("The file external '%s' can not be "
"created because the node exists."),
svn_dirent_local_style(local_abspath,
scratch_pool));
}
{
const svn_ra_reporter3_t *reporter;
void *report_baton;
const svn_delta_editor_t *switch_editor;
void *switch_baton;
svn_client__pathrev_t *switch_loc;
svn_revnum_t revnum;
apr_array_header_t *inherited_props;
const char *dir_abspath;
const char *target;
svn_dirent_split(&dir_abspath, &target, local_abspath, scratch_pool);
/* ### Why do we open a new session? RA_SESSION is a valid
### session -- the caller used it to call svn_ra_check_path on
### this very URL, the caller also did the resolving and
### reparenting that is repeated here. */
SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &switch_loc,
url, dir_abspath,
peg_revision, revision,
ctx, scratch_pool));
/* Get the external file's iprops. */
SVN_ERR(svn_ra_get_inherited_props(ra_session, &inherited_props, "",
switch_loc->rev,
scratch_pool, scratch_pool));
SVN_ERR(svn_ra_reparent(ra_session, svn_uri_dirname(url, scratch_pool),
scratch_pool));
SVN_ERR(svn_wc__get_file_external_editor(&switch_editor, &switch_baton,
&revnum, ctx->wc_ctx,
local_abspath,
def_dir_abspath,
switch_loc->url,
switch_loc->repos_root_url,
switch_loc->repos_uuid,
inherited_props,
use_commit_times,
diff3_cmd, preserved_exts,
def_dir_abspath,
url, peg_revision, revision,
ctx->conflict_func2,
ctx->conflict_baton2,
ctx->cancel_func,
ctx->cancel_baton,
ctx->notify_func2,
ctx->notify_baton2,
scratch_pool, scratch_pool));
/* Tell RA to do an update of URL+TARGET to REVISION; if we pass an
invalid revnum, that means RA will use the latest revision. */
SVN_ERR(svn_ra_do_switch3(ra_session, &reporter, &report_baton,
switch_loc->rev,
target, svn_depth_unknown, switch_loc->url,
FALSE /* send_copyfrom */,
TRUE /* ignore_ancestry */,
switch_editor, switch_baton,
scratch_pool, scratch_pool));
SVN_ERR(svn_wc__crawl_file_external(ctx->wc_ctx, local_abspath,
reporter, report_baton,
TRUE, use_commit_times,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
scratch_pool));
if (ctx->notify_func2)
{
svn_wc_notify_t *notify
= svn_wc_create_notify(local_abspath, svn_wc_notify_update_completed,
scratch_pool);
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
notify->revision = revnum;
(*ctx->notify_func2)(ctx->notify_baton2, notify, scratch_pool);
}
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_wcroot_parse_local_abspath(svn_wc__db_wcroot_t **wcroot,
const char **local_relpath,
svn_wc__db_t *db,
const char *local_abspath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *local_dir_abspath;
const char *original_abspath = local_abspath;
svn_node_kind_t kind;
const char *build_relpath;
svn_wc__db_wcroot_t *probe_wcroot;
svn_wc__db_wcroot_t *found_wcroot = NULL;
const char *scan_abspath;
svn_sqlite__db_t *sdb = NULL;
svn_boolean_t moved_upwards = FALSE;
svn_boolean_t always_check = FALSE;
int wc_format = 0;
const char *adm_relpath;
/* Non-NULL if WCROOT is found through a symlink: */
const char *symlink_wcroot_abspath = NULL;
/* ### we need more logic for finding the database (if it is located
### outside of the wcroot) and then managing all of that within DB.
### for now: play quick & dirty. */
probe_wcroot = svn_hash_gets(db->dir_data, local_abspath);
if (probe_wcroot != NULL)
{
*wcroot = probe_wcroot;
/* We got lucky. Just return the thing BEFORE performing any I/O. */
/* ### validate SMODE against how we opened wcroot->sdb? and against
### DB->mode? (will we record per-dir mode?) */
/* ### for most callers, we could pass NULL for result_pool. */
*local_relpath = compute_relpath(probe_wcroot, local_abspath,
result_pool);
return SVN_NO_ERROR;
}
/* ### at some point in the future, we may need to find a way to get
### rid of this stat() call. it is going to happen for EVERY call
### into wc_db which references a file. calls for directories could
### get an early-exit in the hash lookup just above. */
SVN_ERR(get_path_kind(&kind, db, local_abspath, scratch_pool));
if (kind != svn_node_dir)
{
/* If the node specified by the path is NOT present, then it cannot
possibly be a directory containing ".svn/wc.db".
If it is a file, then it cannot contain ".svn/wc.db".
For both of these cases, strip the basename off of the path and
move up one level. Keep record of what we strip, though, since
we'll need it later to construct local_relpath. */
svn_dirent_split(&local_dir_abspath, &build_relpath, local_abspath,
scratch_pool);
/* Is this directory in our hash? */
probe_wcroot = svn_hash_gets(db->dir_data, local_dir_abspath);
if (probe_wcroot != NULL)
{
const char *dir_relpath;
*wcroot = probe_wcroot;
/* Stashed directory's local_relpath + basename. */
dir_relpath = compute_relpath(probe_wcroot, local_dir_abspath,
NULL);
*local_relpath = svn_relpath_join(dir_relpath,
build_relpath,
result_pool);
return SVN_NO_ERROR;
}
/* If the requested path is not on the disk, then we don't know how
many ancestors need to be scanned until we start hitting content
on the disk. Set ALWAYS_CHECK to keep looking for .svn/entries
rather than bailing out after the first check. */
if (kind == svn_node_none)
always_check = TRUE;
/* Start the scanning at LOCAL_DIR_ABSPATH. */
local_abspath = local_dir_abspath;
}
else
{
/* Start the local_relpath empty. If *this* directory contains the
wc.db, then relpath will be the empty string. */
build_relpath = "";
/* Remember the dir containing LOCAL_ABSPATH (they're the same). */
local_dir_abspath = local_abspath;
}
/* LOCAL_ABSPATH refers to a directory at this point. At this point,
we've determined that an associated WCROOT is NOT in the DB's hash
table for this directory. Let's find an existing one in the ancestors,
or create one when we find the actual wcroot. */
/* Assume that LOCAL_ABSPATH is a directory, and look for the SQLite
database in the right place. If we find it... great! If not, then
peel off some components, and try again. */
adm_relpath = svn_wc_get_adm_dir(scratch_pool);
while (TRUE)
{
svn_error_t *err;
svn_node_kind_t adm_subdir_kind;
const char *adm_subdir = svn_dirent_join(local_abspath, adm_relpath,
scratch_pool);
SVN_ERR(svn_io_check_path(adm_subdir, &adm_subdir_kind, scratch_pool));
if (adm_subdir_kind == svn_node_dir)
{
/* We always open the database in read/write mode. If the database
isn't writable in the filesystem, SQLite will internally open
it as read-only, and we'll get an error if we try to do a write
operation.
We could decide what to do on a per-operation basis, but since
we're caching database handles, it make sense to be as permissive
as the filesystem allows. */
err = svn_wc__db_util_open_db(&sdb, local_abspath, SDB_FILE,
svn_sqlite__mode_readwrite,
db->exclusive, db->timeout, NULL,
db->state_pool, scratch_pool);
if (err == NULL)
{
#ifdef SVN_DEBUG
/* Install self-verification trigger statements. */
err = svn_sqlite__exec_statements(sdb,
STMT_VERIFICATION_TRIGGERS);
if (err && err->apr_err == SVN_ERR_SQLITE_ERROR)
{
/* Verification triggers can fail to install on old 1.7-dev
* formats which didn't have a NODES table yet. Ignore sqlite
* errors so such working copies can be upgraded. */
svn_error_clear(err);
}
else
SVN_ERR(err);
#endif
break;
}
if (err->apr_err != SVN_ERR_SQLITE_ERROR
&& !APR_STATUS_IS_ENOENT(err->apr_err))
return svn_error_trace(err);
svn_error_clear(err);
/* If we have not moved upwards, then check for a wc-1 working copy.
Since wc-1 has a .svn in every directory, and we didn't find one
in the original directory, then we aren't looking at a wc-1.
If the original path is not present, then we have to check on every
iteration. The content may be the immediate parent, or possibly
five ancetors higher. We don't test for directory presence (just
for the presence of subdirs/files), so we don't know when we can
stop checking ... so just check always. */
if (!moved_upwards || always_check)
{
SVN_ERR(get_old_version(&wc_format, local_abspath,
scratch_pool));
if (wc_format != 0)
break;
}
}
/* We couldn't open the SDB within the specified directory, so
move up one more directory. */
if (svn_dirent_is_root(local_abspath, strlen(local_abspath)))
{
/* Hit the root without finding a wcroot. */
/* The wcroot could be a symlink to a directory.
* (Issue #2557, #3987). If so, try again, this time scanning
* for a db within the directory the symlink points to,
* rather than within the symlink's parent directory. */
if (kind == svn_node_symlink)
{
svn_node_kind_t resolved_kind;
local_abspath = original_abspath;
SVN_ERR(svn_io_check_resolved_path(local_abspath,
&resolved_kind,
scratch_pool));
if (resolved_kind == svn_node_dir)
{
/* Is this directory recorded in our hash? */
found_wcroot = svn_hash_gets(db->dir_data, local_abspath);
if (found_wcroot)
break;
symlink_wcroot_abspath = local_abspath;
SVN_ERR(read_link_target(&local_abspath, local_abspath,
scratch_pool));
try_symlink_as_dir:
kind = svn_node_dir;
moved_upwards = FALSE;
local_dir_abspath = local_abspath;
build_relpath = "";
continue;
}
}
return svn_error_createf(SVN_ERR_WC_NOT_WORKING_COPY, NULL,
_("'%s' is not a working copy"),
svn_dirent_local_style(original_abspath,
scratch_pool));
}
local_abspath = svn_dirent_dirname(local_abspath, scratch_pool);
moved_upwards = TRUE;
symlink_wcroot_abspath = NULL;
/* Is the parent directory recorded in our hash? */
found_wcroot = svn_hash_gets(db->dir_data, local_abspath);
if (found_wcroot != NULL)
break;
}
if (found_wcroot != NULL)
{
/* We found a hash table entry for an ancestor, so we stopped scanning
since all subdirectories use the same WCROOT. */
*wcroot = found_wcroot;
}
else if (wc_format == 0)
{
/* We finally found the database. Construct a wcroot_t for it. */
apr_int64_t wc_id;
int format;
svn_error_t *err;
err = fetch_sdb_info(&wc_id, &format, sdb, scratch_pool);
if (err)
{
if (err->apr_err == SVN_ERR_WC_CORRUPT)
return svn_error_quick_wrapf(
err, _("Missing a row in WCROOT for '%s'."),
svn_dirent_local_style(original_abspath, scratch_pool));
return svn_error_trace(err);
}
/* WCROOT.local_abspath may be NULL when the database is stored
inside the wcroot, but we know the abspath is this directory
(ie. where we found it). */
err = svn_wc__db_pdh_create_wcroot(wcroot,
apr_pstrdup(db->state_pool,
symlink_wcroot_abspath
? symlink_wcroot_abspath
: local_abspath),
sdb, wc_id, format,
db->verify_format,
db->state_pool, scratch_pool);
if (err && (err->apr_err == SVN_ERR_WC_UNSUPPORTED_FORMAT ||
err->apr_err == SVN_ERR_WC_UPGRADE_REQUIRED) &&
kind == svn_node_symlink)
{
/* We found an unsupported WC after traversing upwards from a
* symlink. Fall through to code below to check if the symlink
* points at a supported WC. */
svn_error_clear(err);
*wcroot = NULL;
}
else if (err)
{
/* Close handle if we are not going to use it to support
upgrading with exclusive wc locking. */
return svn_error_compose_create(err, svn_sqlite__close(sdb));
}
}
else
{
/* We found something that looks like a wc-1 working copy directory.
However, if the format version is 12 and the .svn/entries file
is only 3 bytes long, then it's a breadcrumb in a wc-ng working
copy that's missing an .svn/wc.db, or its .svn/wc.db is corrupt. */
if (wc_format == SVN_WC__WC_NG_VERSION /* 12 */)
{
apr_finfo_t info;
/* Check attributes of .svn/entries */
const char *admin_abspath = svn_wc__adm_child(
local_abspath, SVN_WC__ADM_ENTRIES, scratch_pool);
svn_error_t *err = svn_io_stat(&info, admin_abspath, APR_FINFO_SIZE,
scratch_pool);
/* If the former does not succeed, something is seriously wrong. */
if (err)
return svn_error_createf(
SVN_ERR_WC_CORRUPT, err,
_("The working copy at '%s' is corrupt."),
svn_dirent_local_style(local_abspath, scratch_pool));
svn_error_clear(err);
if (3 == info.size)
{
/* Check existence of .svn/wc.db */
admin_abspath = svn_wc__adm_child(local_abspath, SDB_FILE,
scratch_pool);
err = svn_io_stat(&info, admin_abspath, APR_FINFO_SIZE,
scratch_pool);
if (err && APR_STATUS_IS_ENOENT(err->apr_err))
{
svn_error_clear(err);
return svn_error_createf(
SVN_ERR_WC_CORRUPT, NULL,
_("The working copy database at '%s' is missing."),
svn_dirent_local_style(local_abspath, scratch_pool));
}
else
/* We should never have reached this point in the code
if .svn/wc.db exists; therefore it's best to assume
it's corrupt. */
return svn_error_createf(
SVN_ERR_WC_CORRUPT, err,
_("The working copy database at '%s' is corrupt."),
svn_dirent_local_style(local_abspath, scratch_pool));
}
}
SVN_ERR(svn_wc__db_pdh_create_wcroot(wcroot,
apr_pstrdup(db->state_pool,
symlink_wcroot_abspath
? symlink_wcroot_abspath
: local_abspath),
NULL, UNKNOWN_WC_ID, wc_format,
db->verify_format,
db->state_pool, scratch_pool));
}
if (*wcroot)
{
const char *dir_relpath;
if (symlink_wcroot_abspath)
{
/* The WCROOT was found through a symlink pointing at the root of
* the WC. Cache the WCROOT under the symlink's path. */
local_dir_abspath = symlink_wcroot_abspath;
}
/* The subdirectory's relpath is easily computed relative to the
wcroot that we just found. */
dir_relpath = compute_relpath(*wcroot, local_dir_abspath, NULL);
/* And the result local_relpath may include a filename. */
*local_relpath = svn_relpath_join(dir_relpath, build_relpath, result_pool);
}
if (kind == svn_node_symlink)
{
svn_boolean_t retry_if_dir = FALSE;
svn_wc__db_status_t status;
svn_boolean_t conflicted;
svn_error_t *err;
/* Check if the symlink is versioned or obstructs a versioned node
* in this DB -- in that case, use this wcroot. Else, if the symlink
* points to a directory, try to find a wcroot in that directory
* instead. */
if (*wcroot)
{
err = svn_wc__db_read_info_internal(&status, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, &conflicted,
NULL, NULL, NULL, NULL, NULL,
NULL, *wcroot, *local_relpath,
scratch_pool, scratch_pool);
if (err)
{
if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND
&& !SVN_WC__ERR_IS_NOT_CURRENT_WC(err))
return svn_error_trace(err);
svn_error_clear(err);
retry_if_dir = TRUE; /* The symlink is unversioned. */
}
else
{
/* The symlink is versioned, or obstructs a versioned node.
* Ignore non-conflicted not-present/excluded nodes.
* This allows the symlink to redirect the wcroot query to a
* directory, regardless of 'invisible' nodes in this WC. */
retry_if_dir = ((status == svn_wc__db_status_not_present ||
status == svn_wc__db_status_excluded ||
status == svn_wc__db_status_server_excluded)
&& !conflicted);
}
}
else
retry_if_dir = TRUE;
if (retry_if_dir)
{
svn_node_kind_t resolved_kind;
SVN_ERR(svn_io_check_resolved_path(original_abspath,
&resolved_kind,
scratch_pool));
if (resolved_kind == svn_node_dir)
{
symlink_wcroot_abspath = original_abspath;
SVN_ERR(read_link_target(&local_abspath, original_abspath,
scratch_pool));
/* This handle was opened in this function but is not going
to be used further so close it. */
if (sdb)
SVN_ERR(svn_sqlite__close(sdb));
goto try_symlink_as_dir;
}
}
}
/* We've found the appropriate WCROOT for the requested path. Stash
it into that path's directory. */
svn_hash_sets(db->dir_data,
apr_pstrdup(db->state_pool, local_dir_abspath),
*wcroot);
/* Did we traverse up to parent directories? */
if (!moved_upwards)
{
/* We did NOT move to a parent of the original requested directory.
We've constructed and filled in a WCROOT for the request, so we
are done. */
return SVN_NO_ERROR;
}
/* The WCROOT that we just found/built was for the LOCAL_ABSPATH originally
passed into this function. We stepped *at least* one directory above that.
We should now associate the WROOT for each parent directory that does
not (yet) have one. */
scan_abspath = local_dir_abspath;
do
{
const char *parent_dir = svn_dirent_dirname(scan_abspath, scratch_pool);
svn_wc__db_wcroot_t *parent_wcroot;
parent_wcroot = svn_hash_gets(db->dir_data, parent_dir);
if (parent_wcroot == NULL)
{
svn_hash_sets(db->dir_data, apr_pstrdup(db->state_pool, parent_dir),
*wcroot);
}
/* Move up a directory, stopping when we reach the directory where
we found/built the WCROOT. */
scan_abspath = parent_dir;
}
while (strcmp(scan_abspath, local_abspath) != 0);
return SVN_NO_ERROR;
}