/* If the file at PATH is read-only, attempt to make it writable. The
* original state will be restored with RESULT_POOL gets cleaned up.
* SCRATCH_POOL is for temporary allocations. */
static svn_error_t *
auto_make_writable(const char *path,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_boolean_t is_read_only;
apr_finfo_t finfo;
SVN_ERR(svn_io_stat(&finfo, path, SVN__APR_FINFO_READONLY, scratch_pool));
SVN_ERR(svn_io__is_finfo_read_only(&is_read_only, &finfo, scratch_pool));
if (is_read_only)
{
/* Tell the pool to restore the r/o state upon cleanup
(assuming the file will still exist, failing silently otherwise). */
set_read_only_baton_t *baton = apr_pcalloc(result_pool,
sizeof(*baton));
baton->pool = result_pool;
baton->file_path = apr_pstrdup(result_pool, path);
apr_pool_cleanup_register(result_pool, baton,
set_read_only, apr_pool_cleanup_null);
/* Finally, allow write access (undoing it has already been scheduled
and is idempotent). */
SVN_ERR(svn_io_set_file_read_write(path, FALSE, scratch_pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_magic__detect_binary_mimetype(const char **mimetype,
const char *local_abspath,
svn_magic__cookie_t *magic_cookie,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *magic_mimetype = NULL;
#ifdef SVN_HAVE_LIBMAGIC
apr_finfo_t finfo;
/* Do not ask libmagic for the mime-types of empty files.
* This prevents mime-types like "application/x-empty" from making
* Subversion treat empty files as binary. */
SVN_ERR(svn_io_stat(&finfo, local_abspath, APR_FINFO_SIZE, scratch_pool));
if (finfo.size > 0)
{
magic_mimetype = magic_file(magic_cookie->magic, local_abspath);
if (magic_mimetype)
{
/* Only return binary mime-types. */
if (strncmp(magic_mimetype, "text/", 5) == 0)
magic_mimetype = NULL;
else
{
svn_error_t *err;
#ifndef MAGIC_MIME_TYPE
char *p;
/* Strip off trailing stuff like " charset=ascii". */
p = strchr(magic_mimetype, ' ');
if (p)
*p = '\0';
#endif
/* Make sure we got a valid mime type. */
err = svn_mime_type_validate(magic_mimetype, scratch_pool);
if (err)
{
if (err->apr_err == SVN_ERR_BAD_MIME_TYPE)
{
svn_error_clear(err);
magic_mimetype = NULL;
}
else
return svn_error_trace(err);
}
else
{
/* The string is allocated from memory managed by libmagic
* so we must copy it to the result pool. */
magic_mimetype = apr_pstrdup(result_pool, magic_mimetype);
}
}
}
}
#endif
*mimetype = magic_mimetype;
return SVN_NO_ERROR;
}
static svn_error_t *
test_readonly(apr_pool_t *pool)
{
const char *path;
apr_finfo_t finfo;
svn_boolean_t read_only;
apr_int32_t wanted = APR_FINFO_SIZE | APR_FINFO_MTIME | APR_FINFO_TYPE
| APR_FINFO_LINK | APR_FINFO_PROT;
SVN_ERR(svn_io_open_unique_file3(NULL, &path, NULL,
svn_io_file_del_on_pool_cleanup,
pool, pool));
/* File should be writable */
SVN_ERR(svn_io_stat(&finfo, path, wanted, pool));
SVN_ERR(svn_io__is_finfo_read_only(&read_only, &finfo, pool));
SVN_TEST_ASSERT(!read_only);
/* Set read only */
SVN_ERR(svn_io_set_file_read_only(path, FALSE, pool));
/* File should be read only */
SVN_ERR(svn_io_stat(&finfo, path, wanted, pool));
SVN_ERR(svn_io__is_finfo_read_only(&read_only, &finfo, pool));
SVN_TEST_ASSERT(read_only);
/* Set writable */
SVN_ERR(svn_io_set_file_read_write(path, FALSE, pool));
/* File should be writable */
SVN_ERR(svn_io_stat(&finfo, path, wanted, pool));
SVN_ERR(svn_io__is_finfo_read_only(&read_only, &finfo, pool));
SVN_TEST_ASSERT(!read_only);
return SVN_NO_ERROR;
}
/* Make an unversioned copy of the versioned file or directory tree at the
* source path FROM_ABSPATH. Copy it to the destination path TO_ABSPATH.
*
* If REVISION is svn_opt_revision_working, copy the working version,
* otherwise copy the base version.
*
* See copy_one_versioned_file() for details of file copying behaviour,
* including IGNORE_KEYWORDS and NATIVE_EOL.
*
* Include externals unless IGNORE_EXTERNALS is true.
*
* Recurse according to DEPTH.
*
*/
static svn_error_t *
copy_versioned_files(const char *from_abspath,
const char *to_abspath,
const svn_opt_revision_t *revision,
svn_boolean_t force,
svn_boolean_t ignore_externals,
svn_boolean_t ignore_keywords,
svn_depth_t depth,
const char *native_eol,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_error_t *err;
apr_pool_t *iterpool;
const apr_array_header_t *children;
svn_node_kind_t from_kind;
svn_depth_t node_depth;
SVN_ERR_ASSERT(svn_dirent_is_absolute(from_abspath));
SVN_ERR_ASSERT(svn_dirent_is_absolute(to_abspath));
/* Only export 'added' and 'replaced' files when the revision is WORKING;
when the revision is BASE (i.e. != WORKING), only export 'added' and
'replaced' files when they are part of a copy-/move-here. Otherwise, skip
them, since they don't have an associated text-base. This condition for
added/replaced simply is an optimization. Added and replaced files would
be handled similarly by svn_wc_get_pristine_contents2(), which would
return NULL if they have no base associated.
TODO: We may prefer not to duplicate this condition and rather use
svn_wc_get_pristine_contents2() or a dedicated new function instead.
Don't export 'deleted' files and directories unless it's a
revision other than WORKING. These files and directories
don't really exist in WORKING. */
if (revision->kind != svn_opt_revision_working)
{
svn_boolean_t is_added;
const char *repos_relpath;
SVN_ERR(svn_wc__node_get_origin(&is_added, NULL, &repos_relpath,
NULL, NULL, NULL,
ctx->wc_ctx, from_abspath, FALSE,
pool, pool));
if (is_added && !repos_relpath)
return SVN_NO_ERROR; /* Local addition */
}
else
{
svn_boolean_t is_deleted;
SVN_ERR(svn_wc__node_is_status_deleted(&is_deleted, ctx->wc_ctx,
from_abspath, pool));
if (is_deleted)
return SVN_NO_ERROR;
}
SVN_ERR(svn_wc_read_kind(&from_kind, ctx->wc_ctx, from_abspath, FALSE,
pool));
if (from_kind == svn_node_dir)
{
apr_fileperms_t perm = APR_OS_DEFAULT;
int j;
/* Try to make the new directory. If this fails because the
directory already exists, check our FORCE flag to see if we
care. */
/* Keep the source directory's permissions if applicable.
Skip retrieving the umask on windows. Apr does not implement setting
filesystem privileges on Windows.
Retrieving the file permissions with APR_FINFO_PROT | APR_FINFO_OWNER
is documented to be 'incredibly expensive' */
#ifndef WIN32
if (revision->kind == svn_opt_revision_working)
{
apr_finfo_t finfo;
SVN_ERR(svn_io_stat(&finfo, from_abspath, APR_FINFO_PROT, pool));
perm = finfo.protection;
}
#endif
err = svn_io_dir_make(to_abspath, perm, pool);
if (err)
{
if (! APR_STATUS_IS_EEXIST(err->apr_err))
return svn_error_trace(err);
if (! force)
SVN_ERR_W(err, _("Destination directory exists, and will not be "
"overwritten unless forced"));
else
svn_error_clear(err);
}
SVN_ERR(svn_wc__node_get_children(&children, ctx->wc_ctx, from_abspath,
FALSE, pool, pool));
iterpool = svn_pool_create(pool);
for (j = 0; j < children->nelts; j++)
{
const char *child_abspath = APR_ARRAY_IDX(children, j, const char *);
const char *child_name = svn_dirent_basename(child_abspath, NULL);
const char *target_abspath;
svn_node_kind_t child_kind;
svn_pool_clear(iterpool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
target_abspath = svn_dirent_join(to_abspath, child_name, iterpool);
SVN_ERR(svn_wc_read_kind(&child_kind, ctx->wc_ctx, child_abspath,
FALSE, iterpool));
if (child_kind == svn_node_dir)
{
if (depth == svn_depth_infinity
|| depth == svn_depth_immediates)
{
if (ctx->notify_func2)
{
svn_wc_notify_t *notify =
svn_wc_create_notify(target_abspath,
svn_wc_notify_update_add, pool);
notify->kind = svn_node_dir;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
if (depth == svn_depth_infinity)
SVN_ERR(copy_versioned_files(child_abspath, target_abspath,
revision, force,
ignore_externals,
ignore_keywords, depth,
native_eol, ctx, iterpool));
else
SVN_ERR(svn_io_make_dir_recursively(target_abspath,
iterpool));
}
}
else if (child_kind == svn_node_file
&& depth >= svn_depth_files)
{
svn_node_kind_t external_kind;
SVN_ERR(svn_wc__read_external_info(&external_kind,
NULL, NULL, NULL,
NULL, ctx->wc_ctx,
child_abspath,
child_abspath, TRUE,
pool, pool));
if (external_kind != svn_node_file)
SVN_ERR(copy_one_versioned_file(child_abspath, target_abspath,
ctx, revision,
native_eol, ignore_keywords,
iterpool));
}
}
SVN_ERR(svn_wc__node_get_depth(&node_depth, ctx->wc_ctx,
from_abspath, pool));
/* Handle externals. */
if (! ignore_externals && depth == svn_depth_infinity
&& node_depth == svn_depth_infinity)
{
apr_array_header_t *ext_items;
const svn_string_t *prop_val;
SVN_ERR(svn_wc_prop_get2(&prop_val, ctx->wc_ctx, from_abspath,
SVN_PROP_EXTERNALS, pool, pool));
if (prop_val != NULL)
{
int i;
SVN_ERR(svn_wc_parse_externals_description3(&ext_items,
from_abspath,
prop_val->data,
FALSE, pool));
for (i = 0; i < ext_items->nelts; ++i)
{
svn_wc_external_item2_t *ext_item;
const char *new_from, *new_to;
svn_pool_clear(iterpool);
ext_item = APR_ARRAY_IDX(ext_items, i,
svn_wc_external_item2_t *);
new_from = svn_dirent_join(from_abspath,
ext_item->target_dir,
iterpool);
new_to = svn_dirent_join(to_abspath, ext_item->target_dir,
iterpool);
/* The target dir might have parents that don't exist.
Guarantee the path upto the last component. */
if (!svn_dirent_is_root(ext_item->target_dir,
strlen(ext_item->target_dir)))
{
const char *parent = svn_dirent_dirname(new_to, iterpool);
SVN_ERR(svn_io_make_dir_recursively(parent, iterpool));
}
SVN_ERR(copy_versioned_files(new_from, new_to,
revision, force, FALSE,
ignore_keywords,
svn_depth_infinity, native_eol,
ctx, iterpool));
}
}
svn_error_t *
svn_atomic_namespace__create(svn_atomic_namespace__t **ns,
const char *name,
apr_pool_t *result_pool)
{
apr_status_t apr_err;
svn_error_t *err;
apr_file_t *file;
apr_mmap_t *mmap;
const char *shm_name, *lock_name;
apr_finfo_t finfo;
apr_pool_t *subpool = svn_pool_create(result_pool);
/* allocate the namespace data structure
*/
svn_atomic_namespace__t *new_ns = apr_pcalloc(result_pool, sizeof(**ns));
/* construct the names of the system objects that we need
*/
shm_name = apr_pstrcat(subpool, name, SHM_NAME_SUFFIX, NULL);
lock_name = apr_pstrcat(subpool, name, MUTEX_NAME_SUFFIX, NULL);
/* initialize the lock objects
*/
SVN_ERR(svn_atomic__init_once(&mutex_initialized, init_thread_mutex, NULL,
result_pool));
new_ns->mutex.pool = result_pool;
SVN_ERR(svn_io_file_open(&new_ns->mutex.lock_file, lock_name,
APR_READ | APR_WRITE | APR_CREATE,
APR_OS_DEFAULT,
result_pool));
/* Make sure the last user of our lock file will actually remove it.
* Please note that only the last file handle begin closed will actually
* remove the underlying file (see docstring for apr_file_remove).
*/
apr_pool_cleanup_register(result_pool, &new_ns->mutex,
delete_lock_file,
apr_pool_cleanup_null);
/* Prevent concurrent initialization.
*/
SVN_ERR(lock(&new_ns->mutex));
/* First, make sure that the underlying file exists. If it doesn't
* exist, create one and initialize its content.
*/
err = svn_io_file_open(&file, shm_name,
APR_READ | APR_WRITE | APR_CREATE,
APR_OS_DEFAULT,
result_pool);
if (!err)
{
err = svn_io_stat(&finfo, shm_name, APR_FINFO_SIZE, subpool);
if (!err && finfo.size < sizeof(struct shared_data_t))
{
/* Zero all counters, values and names.
*/
struct shared_data_t initial_data;
memset(&initial_data, 0, sizeof(initial_data));
err = svn_io_file_write_full(file, &initial_data,
sizeof(initial_data), NULL,
subpool);
}
}
/* Now, map it into memory.
*/
if (!err)
{
apr_err = apr_mmap_create(&mmap, file, 0, sizeof(*new_ns->data),
APR_MMAP_READ | APR_MMAP_WRITE , result_pool);
if (!apr_err)
new_ns->data = mmap->mm;
else
err = svn_error_createf(apr_err, NULL,
_("MMAP failed for file '%s'"), shm_name);
}
svn_pool_destroy(subpool);
if (!err && new_ns->data)
{
/* Detect severe cases of corruption (i.e. when some outsider messed
* with our data file)
*/
if (new_ns->data->count > MAX_ATOMIC_COUNT)
return svn_error_create(SVN_ERR_CORRUPTED_ATOMIC_STORAGE, 0,
_("Number of atomics in namespace is too large."));
/* Cache the number of existing, complete entries. There can't be
* incomplete ones from other processes because we hold the mutex.
* Our process will also not access this information since we are
* either being called from within svn_atomic__init_once or by
* svn_atomic_namespace__create for a new object.
*/
new_ns->min_used = new_ns->data->count;
*ns = new_ns;
}
/* Unlock to allow other processes may access the shared memory as well.
*/
return unlock(&new_ns->mutex, err);
}
/* Install the pristine text described by BATON into the pristine store of
* SDB. If it is already stored then just delete the new file
* BATON->tempfile_abspath.
*
* This function expects to be executed inside a SQLite txn that has already
* acquired a 'RESERVED' lock.
*
* Implements 'notes/wc-ng/pristine-store' section A-3(a).
*/
static svn_error_t *
pristine_install_txn(svn_sqlite__db_t *sdb,
/* The path to the source file that is to be moved into place. */
svn_stream_t *install_stream,
/* The target path for the file (within the pristine store). */
const char *pristine_abspath,
/* The pristine text's SHA-1 checksum. */
const svn_checksum_t *sha1_checksum,
/* The pristine text's MD-5 checksum. */
const svn_checksum_t *md5_checksum,
apr_pool_t *scratch_pool)
{
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
/* If this pristine text is already present in the store, just keep it:
* delete the new one and return. */
SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_SELECT_PRISTINE));
SVN_ERR(svn_sqlite__bind_checksum(stmt, 1, sha1_checksum, scratch_pool));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
SVN_ERR(svn_sqlite__reset(stmt));
if (have_row)
{
#ifdef SVN_DEBUG
/* Consistency checks. Verify both files exist and match.
* ### We could check much more. */
{
apr_finfo_t finfo1, finfo2;
SVN_ERR(svn_stream__install_get_info(&finfo1, install_stream, APR_FINFO_SIZE,
scratch_pool));
SVN_ERR(svn_io_stat(&finfo2, pristine_abspath, APR_FINFO_SIZE,
scratch_pool));
if (finfo1.size != finfo2.size)
{
return svn_error_createf(
SVN_ERR_WC_CORRUPT_TEXT_BASE, NULL,
_("New pristine text '%s' has different size: %s versus %s"),
svn_checksum_to_cstring_display(sha1_checksum, scratch_pool),
apr_off_t_toa(scratch_pool, finfo1.size),
apr_off_t_toa(scratch_pool, finfo2.size));
}
}
#endif
/* Remove the temp file: it's already there */
SVN_ERR(svn_stream__install_delete(install_stream, scratch_pool));
return SVN_NO_ERROR;
}
/* Move the file to its target location. (If it is already there, it is
* an orphan file and it doesn't matter if we overwrite it.) */
{
apr_finfo_t finfo;
SVN_ERR(svn_stream__install_get_info(&finfo, install_stream,
APR_FINFO_SIZE, scratch_pool));
SVN_ERR(svn_stream__install_stream(install_stream, pristine_abspath,
TRUE, scratch_pool));
SVN_ERR(svn_sqlite__get_statement(&stmt, sdb, STMT_INSERT_PRISTINE));
SVN_ERR(svn_sqlite__bind_checksum(stmt, 1, sha1_checksum, scratch_pool));
SVN_ERR(svn_sqlite__bind_checksum(stmt, 2, md5_checksum, scratch_pool));
SVN_ERR(svn_sqlite__bind_int64(stmt, 3, finfo.size));
SVN_ERR(svn_sqlite__insert(NULL, stmt));
SVN_ERR(svn_io_set_file_read_only(pristine_abspath, FALSE, 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;
}
