svn_error_t *
svn_fs_hotcopy2(const char *src_path, const char *dst_path,
svn_boolean_t clean, svn_boolean_t incremental,
svn_cancel_func_t cancel_func, void *cancel_baton,
apr_pool_t *scratch_pool)
{
fs_library_vtable_t *vtable;
const char *src_fs_type;
svn_fs_t *src_fs;
svn_fs_t *dst_fs;
const char *dst_fs_type;
svn_node_kind_t dst_kind;
if (strcmp(src_path, dst_path) == 0)
return svn_error_create(SVN_ERR_INCORRECT_PARAMS, NULL,
_("Hotcopy source and destination are equal"));
SVN_ERR(svn_fs_type(&src_fs_type, src_path, scratch_pool));
SVN_ERR(get_library_vtable(&vtable, src_fs_type, scratch_pool));
src_fs = fs_new(NULL, scratch_pool);
dst_fs = fs_new(NULL, scratch_pool);
SVN_ERR(svn_io_check_path(dst_path, &dst_kind, scratch_pool));
if (dst_kind == svn_node_file)
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("'%s' already exists and is a file"),
svn_dirent_local_style(dst_path,
scratch_pool));
if (dst_kind == svn_node_unknown)
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("'%s' already exists and has an unknown "
"node kind"),
svn_dirent_local_style(dst_path,
scratch_pool));
if (dst_kind == svn_node_dir)
{
svn_node_kind_t type_file_kind;
SVN_ERR(svn_io_check_path(svn_dirent_join(dst_path,
FS_TYPE_FILENAME,
scratch_pool),
&type_file_kind, scratch_pool));
if (type_file_kind != svn_node_none)
{
SVN_ERR(svn_fs_type(&dst_fs_type, dst_path, scratch_pool));
if (strcmp(src_fs_type, dst_fs_type) != 0)
return svn_error_createf(
SVN_ERR_ILLEGAL_TARGET, NULL,
_("The filesystem type of the hotcopy source "
"('%s') does not match the filesystem "
"type of the hotcopy destination ('%s')"),
src_fs_type, dst_fs_type);
}
}
SVN_ERR(vtable->hotcopy(src_fs, dst_fs, src_path, dst_path, clean,
incremental, cancel_func, cancel_baton,
scratch_pool));
return svn_error_trace(write_fs_type(dst_path, src_fs_type, scratch_pool));
}
svn_error_t *
svn_wc__ensure_directory(const char *path,
apr_pool_t *pool)
{
svn_node_kind_t kind;
SVN_ERR(svn_io_check_path(path, &kind, pool));
if (kind != svn_node_none && kind != svn_node_dir)
{
/* If got an error other than dir non-existence, then we can't
ensure this directory's existence, so just return the error.
Might happen if there's a file in the way, for example. */
return svn_error_createf(APR_ENOTDIR, NULL,
_("'%s' is not a directory"),
svn_dirent_local_style(path, pool));
}
else if (kind == svn_node_none)
{
/* The dir doesn't exist, and it's our job to change that. */
SVN_ERR(svn_io_make_dir_recursively(path, pool));
}
else /* No problem, the dir already existed, so just leave. */
SVN_ERR_ASSERT(kind == svn_node_dir);
return SVN_NO_ERROR;
}
/* The main logic of the public svn_client_add4; the only difference
is that this function uses an existing access baton.
(svn_client_add4 just generates an access baton and calls this func.) */
static svn_error_t *
add(const char *path,
svn_depth_t depth,
svn_boolean_t force,
svn_boolean_t no_ignore,
svn_wc_adm_access_t *adm_access,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_node_kind_t kind;
svn_error_t *err;
SVN_ERR(svn_io_check_path(path, &kind, pool));
if (kind == svn_node_dir && depth >= svn_depth_files)
err = add_dir_recursive(path, adm_access, depth,
force, no_ignore, ctx, pool);
else if (kind == svn_node_file)
err = add_file(path, ctx, adm_access, pool);
else
err = svn_wc_add2(path, adm_access, NULL, SVN_INVALID_REVNUM,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2, pool);
/* Ignore SVN_ERR_ENTRY_EXISTS when FORCE is set. */
if (err && err->apr_err == SVN_ERR_ENTRY_EXISTS && force)
{
svn_error_clear(err);
err = SVN_NO_ERROR;
}
return err;
}
static svn_error_t *
pack_even_filesystem(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
svn_node_kind_t kind;
const char *path;
*msg = "pack FSFS where revs % shard = 0";
if (msg_only)
return SVN_NO_ERROR;
/* Bail (with success) on known-untestable scenarios */
if ((strcmp(opts->fs_type, "fsfs") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 6)))
return SVN_NO_ERROR;
SVN_ERR(create_packed_filesystem(REPO_NAME, opts, MAX_REV, SHARD_SIZE,
pool));
path = svn_path_join_many(pool, REPO_NAME, "revs", "2.pack", NULL);
SVN_ERR(svn_io_check_path(path, &kind, pool));
if (kind != svn_node_dir)
return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,
"Packing did not complete as expected");
return SVN_NO_ERROR;
}
/**
* Delete all unused log files from DBD enviroment at @a live_path that exist
* in @a backup_path.
*/
static svn_error_t *
svn_fs_base__clean_logs(const char *live_path,
const char *backup_path,
apr_pool_t *pool)
{
apr_array_header_t *logfiles;
SVN_ERR(base_bdb_logfiles(&logfiles,
live_path,
TRUE, /* Only unused logs */
pool));
{ /* Process unused logs from live area */
int idx;
apr_pool_t *sub_pool = svn_pool_create(pool);
/* Process log files. */
for (idx = 0; idx < logfiles->nelts; idx++)
{
const char *log_file = APR_ARRAY_IDX(logfiles, idx, const char *);
const char *live_log_path;
const char *backup_log_path;
svn_pool_clear(sub_pool);
live_log_path = svn_dirent_join(live_path, log_file, sub_pool);
backup_log_path = svn_dirent_join(backup_path, log_file, sub_pool);
{ /* Compare files. No point in using MD5 and wasting CPU cycles as we
got full copies of both logs */
svn_boolean_t files_match = FALSE;
svn_node_kind_t kind;
/* Check to see if there is a corresponding log file in the backup
directory */
SVN_ERR(svn_io_check_path(backup_log_path, &kind, pool));
/* If the copy of the log exists, compare them */
if (kind == svn_node_file)
SVN_ERR(svn_io_files_contents_same_p(&files_match,
live_log_path,
backup_log_path,
sub_pool));
/* If log files do not match, go to the next log file. */
if (!files_match)
continue;
}
SVN_ERR(svn_io_remove_file2(live_log_path, FALSE, sub_pool));
}
svn_pool_destroy(sub_pool);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_util_open_db(svn_sqlite__db_t **sdb,
const char *dir_abspath,
const char *sdb_fname,
svn_sqlite__mode_t smode,
svn_boolean_t exclusive,
const char *const *my_statements,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *sdb_abspath = svn_wc__adm_child(dir_abspath, sdb_fname,
scratch_pool);
if (smode != svn_sqlite__mode_rwcreate)
{
svn_node_kind_t kind;
/* A file stat is much cheaper then a failed database open handled
by SQLite. */
SVN_ERR(svn_io_check_path(sdb_abspath, &kind, scratch_pool));
if (kind != svn_node_file)
return svn_error_createf(APR_ENOENT, NULL,
_("Working copy database '%s' not found"),
svn_dirent_local_style(sdb_abspath,
scratch_pool));
}
#ifndef WIN32
else
{
apr_file_t *f;
/* A standard SQLite build creates a DB with mode 644 ^ !umask
which means the file doesn't have group/world write access
even when umask allows it. By ensuring the file exists before
SQLite gets involved we give it the permissions allowed by
umask. */
SVN_ERR(svn_io_file_open(&f, sdb_abspath,
(APR_READ | APR_WRITE | APR_CREATE),
APR_OS_DEFAULT, scratch_pool));
SVN_ERR(svn_io_file_close(f, scratch_pool));
}
#endif
SVN_ERR(svn_sqlite__open(sdb, sdb_abspath, smode,
my_statements ? my_statements : statements,
0, NULL, result_pool, scratch_pool));
if (exclusive)
SVN_ERR(svn_sqlite__exec_statements(*sdb, STMT_PRAGMA_LOCKING_MODE));
SVN_ERR(svn_sqlite__create_scalar_function(*sdb, "relpath_depth", 1,
relpath_depth_sqlite, NULL));
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_fs__exists_rep_cache(svn_boolean_t *exists,
svn_fs_t *fs, apr_pool_t *pool)
{
svn_node_kind_t kind;
SVN_ERR(svn_io_check_path(path_rep_cache_db(fs->path, pool),
&kind, pool));
*exists = (kind != svn_node_none);
return SVN_NO_ERROR;
}
svn_error_t *
svn_cl__propset_print_binary_mime_type_warning(apr_array_header_t *targets,
const char *propname,
const svn_string_t *propval,
apr_pool_t *scratch_pool)
{
if (strcmp(propname, SVN_PROP_MIME_TYPE) == 0)
{
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
int i;
for (i = 0; i < targets->nelts; i++)
{
const char *detected_mimetype;
const char *target = APR_ARRAY_IDX(targets, i, const char *);
const char *local_abspath;
const svn_string_t *canon_propval;
svn_node_kind_t node_kind;
svn_pool_clear(iterpool);
SVN_ERR(svn_dirent_get_absolute(&local_abspath, target, iterpool));
SVN_ERR(svn_io_check_path(local_abspath, &node_kind, iterpool));
if (node_kind != svn_node_file)
continue;
SVN_ERR(svn_wc_canonicalize_svn_prop(&canon_propval,
propname, propval,
local_abspath,
svn_node_file,
FALSE, NULL, NULL,
iterpool));
if (svn_mime_type_is_binary(canon_propval->data))
{
SVN_ERR(svn_io_detect_mimetype2(&detected_mimetype,
local_abspath, NULL,
iterpool));
if (detected_mimetype == NULL ||
!svn_mime_type_is_binary(detected_mimetype))
svn_error_clear(svn_cmdline_fprintf(stderr, iterpool,
_("svn: warning: '%s' is a binary mime-type but file '%s' "
"looks like text; diff, merge, blame, and other "
"operations will stop working on this file\n"),
canon_propval->data,
svn_dirent_local_style(local_abspath, iterpool)));
}
}
svn_pool_destroy(iterpool);
}
/* Get the format version from a wc-1 directory. If it is not a working copy
directory, then it sets VERSION to zero and returns no error. */
static svn_error_t *
get_old_version(int *version,
const char *abspath,
apr_pool_t *scratch_pool)
{
svn_error_t *err;
const char *format_file_path;
svn_node_kind_t kind;
/* Try reading the format number from the entries file. */
format_file_path = svn_wc__adm_child(abspath, SVN_WC__ADM_ENTRIES,
scratch_pool);
/* Since trying to open a non-existent file is quite expensive, try a
quick stat call first. In wc-ng w/cs, this will be an early exit. */
SVN_ERR(svn_io_check_path(format_file_path, &kind, scratch_pool));
if (kind == svn_node_none)
{
*version = 0;
return SVN_NO_ERROR;
}
err = svn_io_read_version_file(version, format_file_path, scratch_pool);
if (err == NULL)
return SVN_NO_ERROR;
if (err->apr_err != SVN_ERR_BAD_VERSION_FILE_FORMAT
&& !APR_STATUS_IS_ENOENT(err->apr_err)
&& !APR_STATUS_IS_ENOTDIR(err->apr_err))
return svn_error_createf(SVN_ERR_WC_MISSING, err, _("'%s' does not exist"),
svn_dirent_local_style(abspath, scratch_pool));
svn_error_clear(err);
/* This must be a really old working copy! Fall back to reading the
format file.
Note that the format file might not exist in newer working copies
(format 7 and higher), but in that case, the entries file should
have contained the format number. */
format_file_path = svn_wc__adm_child(abspath, SVN_WC__ADM_FORMAT,
scratch_pool);
err = svn_io_read_version_file(version, format_file_path, scratch_pool);
if (err == NULL)
return SVN_NO_ERROR;
/* Whatever error may have occurred... we can just ignore. This is not
a working copy directory. Signal the caller. */
svn_error_clear(err);
*version = 0;
return SVN_NO_ERROR;
}
/* Remove/erase PATH from the working copy. This involves deleting PATH
* from the physical filesystem. PATH is assumed to be an unversioned file
* or directory.
*
* If ignore_enoent is TRUE, ignore missing targets.
*
* If CANCEL_FUNC is non-null, invoke it with CANCEL_BATON at various
* points, return any error immediately.
*/
static svn_error_t *
erase_unversioned_from_wc(const char *path,
svn_boolean_t ignore_enoent,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *scratch_pool)
{
svn_error_t *err;
/* Optimize the common case: try to delete the file */
err = svn_io_remove_file2(path, ignore_enoent, scratch_pool);
if (err)
{
/* Then maybe it was a directory? */
svn_error_clear(err);
err = svn_io_remove_dir2(path, ignore_enoent, cancel_func, cancel_baton,
scratch_pool);
if (err)
{
/* We're unlikely to end up here. But we need this fallback
to make sure we report the right error *and* try the
correct deletion at least once. */
svn_node_kind_t kind;
svn_error_clear(err);
SVN_ERR(svn_io_check_path(path, &kind, scratch_pool));
if (kind == svn_node_file)
SVN_ERR(svn_io_remove_file2(path, ignore_enoent, scratch_pool));
else if (kind == svn_node_dir)
SVN_ERR(svn_io_remove_dir2(path, ignore_enoent,
cancel_func, cancel_baton,
scratch_pool));
else if (kind == svn_node_none)
return svn_error_createf(SVN_ERR_BAD_FILENAME, NULL,
_("'%s' does not exist"),
svn_dirent_local_style(path,
scratch_pool));
else
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Unsupported node kind for path '%s'"),
svn_dirent_local_style(path,
scratch_pool));
}
}
return SVN_NO_ERROR;
}
svn_boolean_t
svn_wc__adm_area_exists(const char *adm_abspath,
apr_pool_t *pool)
{
const char *path = svn_wc__adm_child(adm_abspath, NULL, pool);
svn_node_kind_t kind;
svn_error_t *err;
err = svn_io_check_path(path, &kind, pool);
if (err)
{
svn_error_clear(err);
/* Return early, since kind is undefined in this case. */
return FALSE;
}
return kind != svn_node_none;
}
svn_error_t *
svn_wc__db_util_open_db(svn_sqlite__db_t **sdb,
const char *dir_abspath,
const char *sdb_fname,
svn_sqlite__mode_t smode,
svn_boolean_t exclusive,
apr_int32_t timeout,
const char *const *my_statements,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *sdb_abspath = svn_wc__adm_child(dir_abspath, sdb_fname,
scratch_pool);
if (smode != svn_sqlite__mode_rwcreate)
{
svn_node_kind_t kind;
/* A file stat is much cheaper than a failed database open handled
by SQLite. */
SVN_ERR(svn_io_check_path(sdb_abspath, &kind, scratch_pool));
if (kind != svn_node_file)
return svn_error_createf(APR_ENOENT, NULL,
_("Working copy database '%s' not found"),
svn_dirent_local_style(sdb_abspath,
scratch_pool));
}
SVN_ERR(svn_sqlite__open(sdb, sdb_abspath, smode,
my_statements ? my_statements : statements,
0, NULL, timeout, result_pool, scratch_pool));
if (exclusive)
SVN_ERR(svn_sqlite__exec_statements(*sdb, STMT_PRAGMA_LOCKING_MODE));
SVN_ERR(svn_sqlite__create_scalar_function(*sdb, "relpath_depth", 1,
TRUE /* deterministic */,
relpath_depth_sqlite, NULL));
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_type(const char **fs_type, const char *path, apr_pool_t *pool)
{
const char *filename;
char buf[128];
svn_error_t *err;
apr_file_t *file;
apr_size_t len;
/* Read the fsap-name file to get the FSAP name, or assume the (old)
default. For old repositories I suppose we could check some
other file, DB_CONFIG or strings say, but for now just check the
directory exists. */
filename = svn_dirent_join(path, FS_TYPE_FILENAME, pool);
err = svn_io_file_open(&file, filename, APR_READ|APR_BUFFERED, 0, pool);
if (err && APR_STATUS_IS_ENOENT(err->apr_err))
{
svn_node_kind_t kind;
svn_error_t *err2 = svn_io_check_path(path, &kind, pool);
if (err2)
{
svn_error_clear(err2);
return err;
}
if (kind == svn_node_dir)
{
svn_error_clear(err);
*fs_type = SVN_FS_TYPE_BDB;
return SVN_NO_ERROR;
}
return err;
}
else if (err)
return err;
len = sizeof(buf);
SVN_ERR(svn_io_read_length_line(file, buf, &len, pool));
SVN_ERR(svn_io_file_close(file, pool));
*fs_type = apr_pstrdup(pool, buf);
return SVN_NO_ERROR;
}
svn_error_t *
svn_config_read_auth_data(apr_hash_t **hash,
const char *cred_kind,
const char *realmstring,
const char *config_dir,
apr_pool_t *pool)
{
svn_node_kind_t kind;
const char *auth_path;
*hash = NULL;
SVN_ERR(svn_auth__file_path(&auth_path, cred_kind, realmstring, config_dir,
pool));
if (! auth_path)
return SVN_NO_ERROR;
SVN_ERR(svn_io_check_path(auth_path, &kind, pool));
if (kind == svn_node_file)
{
svn_stream_t *stream;
svn_string_t *stored_realm;
SVN_ERR_W(svn_stream_open_readonly(&stream, auth_path, pool, pool),
_("Unable to open auth file for reading"));
*hash = apr_hash_make(pool);
SVN_ERR_W(svn_hash_read2(*hash, stream, SVN_HASH_TERMINATOR, pool),
apr_psprintf(pool, _("Error parsing '%s'"),
svn_dirent_local_style(auth_path, pool)));
stored_realm = svn_hash_gets(*hash, SVN_CONFIG_REALMSTRING_KEY);
if (!stored_realm || strcmp(stored_realm->data, realmstring) != 0)
*hash = NULL; /* Hash collision, or somebody tampering with storage */
SVN_ERR(svn_stream_close(stream));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_fs__hotcopy_prepare_target(svn_fs_t *src_fs,
svn_fs_t *dst_fs,
const char *dst_path,
svn_boolean_t incremental,
apr_pool_t *pool)
{
if (incremental)
{
const char *dst_format_abspath;
svn_node_kind_t dst_format_kind;
/* Check destination format to be sure we know how to incrementally
* hotcopy to the destination FS. */
dst_format_abspath = svn_dirent_join(dst_path, PATH_FORMAT, pool);
SVN_ERR(svn_io_check_path(dst_format_abspath, &dst_format_kind, pool));
if (dst_format_kind == svn_node_none)
{
/* Destination doesn't exist yet. Perform a normal hotcopy to a
* empty destination using the same configuration as the source. */
SVN_ERR(hotcopy_create_empty_dest(src_fs, dst_fs, dst_path, pool));
}
else
{
/* Check the existing repository. */
SVN_ERR(svn_fs_fs__open(dst_fs, dst_path, pool));
SVN_ERR(hotcopy_incremental_check_preconditions(src_fs, dst_fs,
pool));
}
}
else
{
/* Start out with an empty destination using the same configuration
* as the source. */
SVN_ERR(hotcopy_create_empty_dest(src_fs, dst_fs, dst_path, pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_config_read_auth_data(apr_hash_t **hash,
const char *cred_kind,
const char *realmstring,
const char *config_dir,
apr_pool_t *pool)
{
svn_node_kind_t kind;
const char *auth_path;
*hash = NULL;
SVN_ERR(svn_auth__file_path(&auth_path, cred_kind, realmstring, config_dir,
pool));
if (! auth_path)
return SVN_NO_ERROR;
SVN_ERR(svn_io_check_path(auth_path, &kind, pool));
if (kind == svn_node_file)
{
svn_stream_t *stream;
SVN_ERR_W(svn_stream_open_readonly(&stream, auth_path, pool, pool),
_("Unable to open auth file for reading"));
*hash = apr_hash_make(pool);
SVN_ERR_W(svn_hash_read2(*hash, stream, SVN_HASH_TERMINATOR, pool),
apr_psprintf(pool, _("Error parsing '%s'"),
svn_dirent_local_style(auth_path, pool)));
SVN_ERR(svn_stream_close(stream));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_util_open_db(svn_sqlite__db_t **sdb,
const char *dir_abspath,
const char *sdb_fname,
svn_sqlite__mode_t smode,
const char *const *my_statements,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *sdb_abspath = svn_wc__adm_child(dir_abspath, sdb_fname,
scratch_pool);
if (smode != svn_sqlite__mode_rwcreate)
{
svn_node_kind_t kind;
/* A file stat is much cheaper then a failed database open handled
by SQLite. */
SVN_ERR(svn_io_check_path(sdb_abspath, &kind, scratch_pool));
if (kind != svn_node_file)
return svn_error_createf(APR_ENOENT, NULL,
_("Working copy database '%s' not found"),
svn_dirent_local_style(sdb_abspath,
scratch_pool));
}
SVN_ERR(svn_sqlite__open(sdb, sdb_abspath, smode,
my_statements ? my_statements : statements,
0, NULL, result_pool, scratch_pool));
SVN_ERR(svn_sqlite__create_scalar_function(*sdb, "relpath_depth", 1,
relpath_depth, NULL));
return SVN_NO_ERROR;
}
/* The guts of svn_wc_copy3() and svn_wc_move().
* The additional parameter IS_MOVE indicates whether this is a copy or
* a move operation.
*
* If MOVE_DEGRADED_TO_COPY is not NULL and a move had to be degraded
* to a copy, then set *MOVE_DEGRADED_TO_COPY. */
static svn_error_t *
copy_or_move(svn_boolean_t *move_degraded_to_copy,
svn_wc_context_t *wc_ctx,
const char *src_abspath,
const char *dst_abspath,
svn_boolean_t metadata_only,
svn_boolean_t is_move,
svn_boolean_t allow_mixed_revisions,
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_wc__db_t *db = wc_ctx->db;
svn_node_kind_t src_db_kind;
const char *dstdir_abspath;
svn_boolean_t conflicted;
const char *tmpdir_abspath;
const char *src_wcroot_abspath;
const char *dst_wcroot_abspath;
svn_boolean_t within_one_wc;
svn_wc__db_status_t src_status;
svn_error_t *err;
SVN_ERR_ASSERT(svn_dirent_is_absolute(src_abspath));
SVN_ERR_ASSERT(svn_dirent_is_absolute(dst_abspath));
dstdir_abspath = svn_dirent_dirname(dst_abspath, scratch_pool);
/* Ensure DSTDIR_ABSPATH belongs to the same repository as SRC_ABSPATH;
throw an error if not. */
{
svn_wc__db_status_t dstdir_status;
const char *src_repos_root_url, *dst_repos_root_url;
const char *src_repos_uuid, *dst_repos_uuid;
const char *src_repos_relpath;
err = svn_wc__db_read_info(&src_status, &src_db_kind, NULL,
&src_repos_relpath, &src_repos_root_url,
&src_repos_uuid, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, &conflicted, NULL, NULL, NULL, NULL,
NULL, NULL,
db, src_abspath, scratch_pool, scratch_pool);
if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
/* Replicate old error code and text */
svn_error_clear(err);
return svn_error_createf(SVN_ERR_ENTRY_NOT_FOUND, NULL,
_("'%s' is not under version control"),
svn_dirent_local_style(src_abspath,
scratch_pool));
}
else
SVN_ERR(err);
/* Do this now, as we know the right data is cached */
SVN_ERR(svn_wc__db_get_wcroot(&src_wcroot_abspath, db, src_abspath,
scratch_pool, scratch_pool));
switch (src_status)
{
case svn_wc__db_status_deleted:
return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
_("Deleted node '%s' can't be copied."),
svn_dirent_local_style(src_abspath,
scratch_pool));
case svn_wc__db_status_excluded:
case svn_wc__db_status_server_excluded:
case svn_wc__db_status_not_present:
return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
_("The node '%s' was not found."),
svn_dirent_local_style(src_abspath,
scratch_pool));
default:
break;
}
if (is_move && ! strcmp(src_abspath, src_wcroot_abspath))
{
return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
_("'%s' is the root of a working copy and "
"cannot be moved"),
svn_dirent_local_style(src_abspath,
scratch_pool));
}
if (is_move && src_repos_relpath && !src_repos_relpath[0])
{
return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
_("'%s' represents the repository root "
"and cannot be moved"),
svn_dirent_local_style(src_abspath,
scratch_pool));
}
err = svn_wc__db_read_info(&dstdir_status, NULL, NULL, NULL,
&dst_repos_root_url, &dst_repos_uuid, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
NULL, NULL, NULL,
db, dstdir_abspath,
scratch_pool, scratch_pool);
if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
/* An unversioned destination directory exists on disk. */
svn_error_clear(err);
return svn_error_createf(SVN_ERR_ENTRY_NOT_FOUND, NULL,
_("'%s' is not under version control"),
svn_dirent_local_style(dstdir_abspath,
scratch_pool));
}
else
SVN_ERR(err);
/* Do this now, as we know the right data is cached */
SVN_ERR(svn_wc__db_get_wcroot(&dst_wcroot_abspath, db, dstdir_abspath,
scratch_pool, scratch_pool));
if (!src_repos_root_url)
{
if (src_status == svn_wc__db_status_added)
SVN_ERR(svn_wc__db_scan_addition(NULL, NULL, NULL,
&src_repos_root_url,
&src_repos_uuid, NULL, NULL, NULL,
NULL,
db, src_abspath,
scratch_pool, scratch_pool));
else
/* If not added, the node must have a base or we can't copy */
SVN_ERR(svn_wc__db_scan_base_repos(NULL, &src_repos_root_url,
&src_repos_uuid,
db, src_abspath,
scratch_pool, scratch_pool));
}
if (!dst_repos_root_url)
{
if (dstdir_status == svn_wc__db_status_added)
SVN_ERR(svn_wc__db_scan_addition(NULL, NULL, NULL,
&dst_repos_root_url,
&dst_repos_uuid, NULL, NULL, NULL,
NULL,
db, dstdir_abspath,
scratch_pool, scratch_pool));
else
/* If not added, the node must have a base or we can't copy */
SVN_ERR(svn_wc__db_scan_base_repos(NULL, &dst_repos_root_url,
&dst_repos_uuid,
db, dstdir_abspath,
scratch_pool, scratch_pool));
}
if (strcmp(src_repos_root_url, dst_repos_root_url) != 0
|| strcmp(src_repos_uuid, dst_repos_uuid) != 0)
return svn_error_createf(
SVN_ERR_WC_INVALID_SCHEDULE, NULL,
_("Cannot copy to '%s', as it is not from repository '%s'; "
"it is from '%s'"),
svn_dirent_local_style(dst_abspath, scratch_pool),
src_repos_root_url, dst_repos_root_url);
if (dstdir_status == svn_wc__db_status_deleted)
return svn_error_createf(
SVN_ERR_WC_INVALID_SCHEDULE, NULL,
_("Cannot copy to '%s' as it is scheduled for deletion"),
svn_dirent_local_style(dst_abspath, scratch_pool));
/* ### should report dstdir_abspath instead of dst_abspath? */
}
/* TODO(#2843): Rework the error report. */
/* Check if the copy target is missing or hidden and thus not exist on the
disk, before actually doing the file copy. */
{
svn_wc__db_status_t dst_status;
err = svn_wc__db_read_info(&dst_status, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
db, dst_abspath, scratch_pool, scratch_pool);
if (err && err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND)
return svn_error_trace(err);
svn_error_clear(err);
if (!err)
switch (dst_status)
{
case svn_wc__db_status_excluded:
return svn_error_createf(
SVN_ERR_ENTRY_EXISTS, NULL,
_("'%s' is already under version control "
"but is excluded."),
svn_dirent_local_style(dst_abspath, scratch_pool));
case svn_wc__db_status_server_excluded:
return svn_error_createf(
SVN_ERR_ENTRY_EXISTS, NULL,
_("'%s' is already under version control"),
svn_dirent_local_style(dst_abspath, scratch_pool));
case svn_wc__db_status_deleted:
case svn_wc__db_status_not_present:
break; /* OK to add */
default:
return svn_error_createf(SVN_ERR_ENTRY_EXISTS, NULL,
_("There is already a versioned item '%s'"),
svn_dirent_local_style(dst_abspath,
scratch_pool));
}
}
/* Check that the target path is not obstructed, if required. */
if (!metadata_only)
{
svn_node_kind_t dst_kind;
/* (We need only to check the root of the copy, not every path inside
copy_versioned_file/_dir.) */
SVN_ERR(svn_io_check_path(dst_abspath, &dst_kind, scratch_pool));
if (dst_kind != svn_node_none)
return svn_error_createf(SVN_ERR_ENTRY_EXISTS, NULL,
_("'%s' already exists and is in the way"),
svn_dirent_local_style(dst_abspath,
scratch_pool));
}
SVN_ERR(svn_wc__db_temp_wcroot_tempdir(&tmpdir_abspath, db,
dstdir_abspath,
scratch_pool, scratch_pool));
within_one_wc = (strcmp(src_wcroot_abspath, dst_wcroot_abspath) == 0);
if (is_move
&& !within_one_wc)
{
if (move_degraded_to_copy)
*move_degraded_to_copy = TRUE;
is_move = FALSE;
}
if (!within_one_wc)
SVN_ERR(svn_wc__db_pristine_transfer(db, src_abspath, dst_wcroot_abspath,
cancel_func, cancel_baton,
scratch_pool));
if (src_db_kind == svn_node_file
|| src_db_kind == svn_node_symlink)
{
err = copy_versioned_file(db, src_abspath, dst_abspath, dst_abspath,
tmpdir_abspath,
metadata_only, conflicted, is_move,
cancel_func, cancel_baton,
notify_func, notify_baton,
scratch_pool);
}
else
{
if (is_move
&& src_status == svn_wc__db_status_normal)
{
svn_revnum_t min_rev;
svn_revnum_t max_rev;
/* Verify that the move source is a single-revision subtree. */
SVN_ERR(svn_wc__db_min_max_revisions(&min_rev, &max_rev, db,
src_abspath, FALSE, scratch_pool));
if (SVN_IS_VALID_REVNUM(min_rev) && SVN_IS_VALID_REVNUM(max_rev) &&
min_rev != max_rev)
{
if (!allow_mixed_revisions)
return svn_error_createf(SVN_ERR_WC_MIXED_REVISIONS, NULL,
_("Cannot move mixed-revision "
"subtree '%s' [%ld:%ld]; "
"try updating it first"),
svn_dirent_local_style(src_abspath,
scratch_pool),
min_rev, max_rev);
is_move = FALSE;
if (move_degraded_to_copy)
*move_degraded_to_copy = TRUE;
}
}
err = copy_versioned_dir(db, src_abspath, dst_abspath, dst_abspath,
tmpdir_abspath, metadata_only, is_move,
cancel_func, cancel_baton,
notify_func, notify_baton,
scratch_pool);
}
if (err && svn_error_find_cause(err, SVN_ERR_CANCELLED))
return svn_error_trace(err);
if (is_move)
err = svn_error_compose_create(err,
svn_wc__db_op_handle_move_back(NULL,
db, dst_abspath, src_abspath,
NULL /* work_items */,
scratch_pool));
/* Run the work queue with the remaining work */
SVN_ERR(svn_error_compose_create(
err,
svn_wc__wq_run(db, dst_abspath,
cancel_func, cancel_baton,
scratch_pool)));
return SVN_NO_ERROR;
}
/*
* Why is this not an svn subcommand? I have this vague idea that it could
* be run as part of the build process, with the output embedded in the svn
* program. Obviously we don't want to have to run svn when building svn.
*/
int
main(int argc, const char *argv[])
{
const char *wc_path, *trail_url;
apr_allocator_t *allocator;
apr_pool_t *pool;
int wc_format;
svn_wc_revision_status_t *res;
svn_boolean_t no_newline = FALSE, committed = FALSE;
svn_error_t *err;
apr_getopt_t *os;
const apr_getopt_option_t options[] =
{
{"no-newline", 'n', 0, N_("do not output the trailing newline")},
{"committed", 'c', 0, N_("last changed rather than current revisions")},
{"help", 'h', 0, N_("display this help")},
{"version", SVNVERSION_OPT_VERSION, 0,
N_("show program version information")},
{0, 0, 0, 0}
};
/* Initialize the app. */
if (svn_cmdline_init("svnversion", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create our top-level pool. Use a separate mutexless allocator,
* given this application is single threaded.
*/
if (apr_allocator_create(&allocator))
return EXIT_FAILURE;
apr_allocator_max_free_set(allocator, SVN_ALLOCATOR_RECOMMENDED_MAX_FREE);
pool = svn_pool_create_ex(NULL, allocator);
apr_allocator_owner_set(allocator, pool);
/* Check library versions */
err = check_lib_versions();
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
#if defined(WIN32) || defined(__CYGWIN__)
/* Set the working copy administrative directory name. */
if (getenv("SVN_ASP_DOT_NET_HACK"))
{
err = svn_wc_set_adm_dir("_svn", pool);
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
}
#endif
err = svn_cmdline__getopt_init(&os, argc, argv, pool);
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
os->interleave = 1;
while (1)
{
int opt;
const char *arg;
apr_status_t status = apr_getopt_long(os, options, &opt, &arg);
if (APR_STATUS_IS_EOF(status))
break;
if (status != APR_SUCCESS)
{
usage(pool);
return EXIT_FAILURE;
}
switch (opt)
{
case 'n':
no_newline = TRUE;
break;
case 'c':
committed = TRUE;
break;
case 'h':
help(options, pool);
break;
case SVNVERSION_OPT_VERSION:
SVN_INT_ERR(version(pool));
exit(0);
break;
default:
usage(pool);
return EXIT_FAILURE;
}
}
if (os->ind > argc || os->ind < argc - 2)
{
usage(pool);
return EXIT_FAILURE;
}
SVN_INT_ERR(svn_utf_cstring_to_utf8
(&wc_path, (os->ind < argc) ? os->argv[os->ind] : ".",
pool));
wc_path = svn_path_internal_style(wc_path, pool);
if (os->ind+1 < argc)
SVN_INT_ERR(svn_utf_cstring_to_utf8
(&trail_url, os->argv[os->ind+1], pool));
else
trail_url = NULL;
SVN_INT_ERR(svn_wc_check_wc(wc_path, &wc_format, pool));
if (! wc_format)
{
svn_node_kind_t kind;
SVN_INT_ERR(svn_io_check_path(wc_path, &kind, pool));
if (kind == svn_node_dir)
{
SVN_INT_ERR(svn_cmdline_printf(pool, _("exported%s"),
no_newline ? "" : "\n"));
svn_pool_destroy(pool);
return EXIT_SUCCESS;
}
else
{
svn_error_clear
(svn_cmdline_fprintf(stderr, pool,
_("'%s' not versioned, and not exported\n"),
wc_path));
svn_pool_destroy(pool);
return EXIT_FAILURE;
}
}
SVN_INT_ERR(svn_wc_revision_status(&res, wc_path, trail_url, committed,
NULL, NULL, pool));
/* Build compact '123[:456]M?S?' string. */
SVN_INT_ERR(svn_cmdline_printf(pool, "%ld", res->min_rev));
if (res->min_rev != res->max_rev)
SVN_INT_ERR(svn_cmdline_printf(pool, ":%ld", res->max_rev));
if (res->modified)
SVN_INT_ERR(svn_cmdline_fputs("M", stdout, pool));
if (res->switched)
SVN_INT_ERR(svn_cmdline_fputs("S", stdout, pool));
if (res->sparse_checkout)
SVN_INT_ERR(svn_cmdline_fputs("P", stdout, pool));
if (! no_newline)
SVN_INT_ERR(svn_cmdline_fputs("\n", stdout, pool));
svn_pool_destroy(pool);
/* Flush stdout to make sure that the user will see any printing errors. */
SVN_INT_ERR(svn_cmdline_fflush(stdout));
return EXIT_SUCCESS;
}
svn_error_t *
svn_client__checkout_internal(svn_revnum_t *result_rev,
const char *url,
const char *local_abspath,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
svn_depth_t depth,
svn_boolean_t ignore_externals,
svn_boolean_t allow_unver_obstructions,
svn_boolean_t *timestamp_sleep,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_node_kind_t kind;
apr_pool_t *session_pool = svn_pool_create(pool);
svn_ra_session_t *ra_session;
svn_client__pathrev_t *pathrev;
/* Sanity check. Without these, the checkout is meaningless. */
SVN_ERR_ASSERT(local_abspath != NULL);
SVN_ERR_ASSERT(svn_uri_is_canonical(url, pool));
SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
/* Fulfill the docstring promise of svn_client_checkout: */
if ((revision->kind != svn_opt_revision_number)
&& (revision->kind != svn_opt_revision_date)
&& (revision->kind != svn_opt_revision_head))
return svn_error_create(SVN_ERR_CLIENT_BAD_REVISION, NULL, NULL);
/* Get the RA connection. */
SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &pathrev,
url, NULL, peg_revision, revision,
ctx, session_pool));
pathrev = svn_client__pathrev_dup(pathrev, pool);
SVN_ERR(svn_ra_check_path(ra_session, "", pathrev->rev, &kind, pool));
svn_pool_destroy(session_pool);
if (kind == svn_node_none)
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("URL '%s' doesn't exist"), pathrev->url);
else if (kind == svn_node_file)
return svn_error_createf
(SVN_ERR_UNSUPPORTED_FEATURE , NULL,
_("URL '%s' refers to a file, not a directory"), pathrev->url);
SVN_ERR(svn_io_check_path(local_abspath, &kind, pool));
if (kind == svn_node_none)
{
/* Bootstrap: create an incomplete working-copy root dir. Its
entries file should only have an entry for THIS_DIR with a
URL, revnum, and an 'incomplete' flag. */
SVN_ERR(svn_io_make_dir_recursively(local_abspath, pool));
SVN_ERR(initialize_area(local_abspath, pathrev, depth, ctx, pool));
}
else if (kind == svn_node_dir)
{
int wc_format;
const char *entry_url;
SVN_ERR(svn_wc_check_wc2(&wc_format, ctx->wc_ctx, local_abspath, pool));
if (! wc_format)
{
SVN_ERR(initialize_area(local_abspath, pathrev, depth, ctx, pool));
}
else
{
/* Get PATH's URL. */
SVN_ERR(svn_wc__node_get_url(&entry_url, ctx->wc_ctx, local_abspath,
pool, pool));
/* If PATH's existing URL matches the incoming one, then
just update. This allows 'svn co' to restart an
interrupted checkout. Otherwise bail out. */
if (strcmp(entry_url, pathrev->url) != 0)
return svn_error_createf(
SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
_("'%s' is already a working copy for a"
" different URL"),
svn_dirent_local_style(local_abspath, pool));
}
}
else
{
return svn_error_createf(SVN_ERR_WC_NODE_KIND_CHANGE, NULL,
_("'%s' already exists and is not a directory"),
svn_dirent_local_style(local_abspath, pool));
}
/* Have update fix the incompleteness. */
SVN_ERR(svn_client__update_internal(result_rev, local_abspath,
revision, depth, TRUE,
ignore_externals,
allow_unver_obstructions,
TRUE /* adds_as_modification */,
FALSE, FALSE,
timestamp_sleep, ctx, pool));
return SVN_NO_ERROR;
}
/* 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;
}
/* Try to update a directory external at PATH to URL at REVISION.
Use POOL for temporary allocations, and use the client context CTX. */
static svn_error_t *
switch_dir_external(const char *local_abspath,
const char *url,
const char *url_from_externals_definition,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
const char *defining_abspath,
svn_boolean_t *timestamp_sleep,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_node_kind_t kind;
svn_error_t *err;
svn_revnum_t external_peg_rev = SVN_INVALID_REVNUM;
svn_revnum_t external_rev = SVN_INVALID_REVNUM;
apr_pool_t *subpool = svn_pool_create(pool);
const char *repos_root_url;
const char *repos_uuid;
SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
if (peg_revision->kind == svn_opt_revision_number)
external_peg_rev = peg_revision->value.number;
if (revision->kind == svn_opt_revision_number)
external_rev = revision->value.number;
/*
* The code below assumes existing versioned paths are *not* part of
* the external's defining working copy.
* The working copy library does not support registering externals
* on top of existing BASE nodes and will error out if we try.
* So if the external target is part of the defining working copy's
* BASE tree, don't attempt to create the external. Doing so would
* leave behind a switched path instead of an external (since the
* switch succeeds but registration of the external in the DB fails).
* The working copy then cannot be updated until the path is switched back.
* See issue #4085.
*/
SVN_ERR(svn_wc__node_get_base(&kind, NULL, NULL,
&repos_root_url, &repos_uuid,
NULL, ctx->wc_ctx, local_abspath,
TRUE, /* ignore_enoent */
TRUE, /* show hidden */
pool, pool));
if (kind != svn_node_unknown)
{
const char *wcroot_abspath;
const char *defining_wcroot_abspath;
SVN_ERR(svn_wc__get_wcroot(&wcroot_abspath, ctx->wc_ctx,
local_abspath, pool, pool));
SVN_ERR(svn_wc__get_wcroot(&defining_wcroot_abspath, ctx->wc_ctx,
defining_abspath, pool, pool));
if (strcmp(wcroot_abspath, defining_wcroot_abspath) == 0)
return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
_("The external '%s' defined in %s at '%s' "
"cannot be checked out because '%s' is "
"already a versioned path."),
url_from_externals_definition,
SVN_PROP_EXTERNALS,
svn_dirent_local_style(defining_abspath,
pool),
svn_dirent_local_style(local_abspath,
pool));
}
/* If path is a directory, try to update/switch to the correct URL
and revision. */
SVN_ERR(svn_io_check_path(local_abspath, &kind, pool));
if (kind == svn_node_dir)
{
const char *node_url;
/* Doubles as an "is versioned" check. */
err = svn_wc__node_get_url(&node_url, ctx->wc_ctx, local_abspath,
pool, subpool);
if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
svn_error_clear(err);
err = SVN_NO_ERROR;
goto relegate;
}
else if (err)
return svn_error_trace(err);
if (node_url)
{
/* If we have what appears to be a version controlled
subdir, and its top-level URL matches that of our
externals definition, perform an update. */
if (strcmp(node_url, url) == 0)
{
SVN_ERR(svn_client__update_internal(NULL, local_abspath,
revision, svn_depth_unknown,
FALSE, FALSE, FALSE, TRUE,
FALSE, TRUE,
timestamp_sleep,
ctx, subpool));
/* We just decided that this existing directory is an external,
so update the external registry with this information, like
when checking out an external */
SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
defining_abspath,
local_abspath, svn_node_dir,
repos_root_url, repos_uuid,
svn_uri_skip_ancestor(repos_root_url,
url, pool),
external_peg_rev,
external_rev,
pool));
svn_pool_destroy(subpool);
goto cleanup;
}
/* We'd really prefer not to have to do a brute-force
relegation -- blowing away the current external working
copy and checking it out anew -- so we'll first see if we
can get away with a generally cheaper relocation (if
required) and switch-style update.
To do so, we need to know the repository root URL of the
external working copy as it currently sits. */
err = svn_wc__node_get_repos_info(NULL, NULL,
&repos_root_url, &repos_uuid,
ctx->wc_ctx, local_abspath,
pool, subpool);
if (err)
{
if (err->apr_err != SVN_ERR_WC_PATH_NOT_FOUND
&& err->apr_err != SVN_ERR_WC_NOT_WORKING_COPY)
return svn_error_trace(err);
svn_error_clear(err);
repos_root_url = NULL;
repos_uuid = NULL;
}
if (repos_root_url)
{
/* If the new external target URL is not obviously a
child of the external working copy's current
repository root URL... */
if (! svn_uri__is_ancestor(repos_root_url, url))
{
const char *repos_root;
/* ... then figure out precisely which repository
root URL that target URL *is* a child of ... */
SVN_ERR(svn_client_get_repos_root(&repos_root, NULL, url,
ctx, subpool, subpool));
/* ... and use that to try to relocate the external
working copy to the target location. */
err = svn_client_relocate2(local_abspath, repos_root_url,
repos_root, FALSE, ctx, subpool);
/* If the relocation failed because the new URL
points to a totally different repository, we've
no choice but to relegate and check out a new WC. */
if (err
&& (err->apr_err == SVN_ERR_WC_INVALID_RELOCATION
|| (err->apr_err
== SVN_ERR_CLIENT_INVALID_RELOCATION)))
{
svn_error_clear(err);
goto relegate;
}
else if (err)
return svn_error_trace(err);
/* If the relocation went without a hitch, we should
have a new repository root URL. */
repos_root_url = repos_root;
}
SVN_ERR(svn_client__switch_internal(NULL, local_abspath, url,
peg_revision, revision,
svn_depth_infinity,
TRUE, FALSE, FALSE,
TRUE /* ignore_ancestry */,
timestamp_sleep,
ctx, subpool));
SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
defining_abspath,
local_abspath, svn_node_dir,
repos_root_url, repos_uuid,
svn_uri_skip_ancestor(
repos_root_url,
url, subpool),
external_peg_rev,
external_rev,
subpool));
svn_pool_destroy(subpool);
goto cleanup;
}
}
}
relegate:
/* Fall back on removing the WC and checking out a new one. */
/* Ensure that we don't have any RA sessions or WC locks from failed
operations above. */
svn_pool_destroy(subpool);
if (kind == svn_node_dir)
{
/* Buh-bye, old and busted ... */
SVN_ERR(relegate_dir_external(ctx->wc_ctx, defining_abspath,
local_abspath,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
pool));
}
else
{
/* The target dir might have multiple components. Guarantee
the path leading down to the last component. */
const char *parent = svn_dirent_dirname(local_abspath, pool);
SVN_ERR(svn_io_make_dir_recursively(parent, pool));
}
/* ... Hello, new hotness. */
SVN_ERR(svn_client__checkout_internal(NULL, url, local_abspath, peg_revision,
revision, svn_depth_infinity,
FALSE, FALSE, timestamp_sleep,
ctx, pool));
SVN_ERR(svn_wc__node_get_repos_info(NULL, NULL,
&repos_root_url,
&repos_uuid,
ctx->wc_ctx, local_abspath,
pool, pool));
SVN_ERR(svn_wc__external_register(ctx->wc_ctx,
defining_abspath,
local_abspath, svn_node_dir,
repos_root_url, repos_uuid,
svn_uri_skip_ancestor(repos_root_url,
url, pool),
external_peg_rev,
external_rev,
pool));
cleanup:
/* Issues #4123 and #4130: We don't need to keep the newly checked
out external's DB open. */
SVN_ERR(svn_wc__close_db(local_abspath, ctx->wc_ctx, pool));
return SVN_NO_ERROR;
}
/* Perform status operations on each external in EXTERNAL_MAP, a const char *
local_abspath of all externals mapping to the const char* defining_abspath.
All other options are the same as those passed to svn_client_status().
If ANCHOR_ABSPATH and ANCHOR-RELPATH are not null, use them to provide
properly formatted relative paths */
static svn_error_t *
do_external_status(svn_client_ctx_t *ctx,
apr_hash_t *external_map,
svn_depth_t depth,
svn_boolean_t get_all,
svn_boolean_t check_out_of_date,
svn_boolean_t check_working_copy,
svn_boolean_t no_ignore,
const apr_array_header_t *changelists,
const char *anchor_abspath,
const char *anchor_relpath,
svn_client_status_func_t status_func,
void *status_baton,
apr_pool_t *scratch_pool)
{
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
apr_array_header_t *externals;
int i;
externals = svn_sort__hash(external_map, svn_sort_compare_items_lexically,
scratch_pool);
/* Loop over the hash of new values (we don't care about the old
ones). This is a mapping of versioned directories to property
values. */
for (i = 0; i < externals->nelts; i++)
{
svn_node_kind_t external_kind;
svn_sort__item_t item = APR_ARRAY_IDX(externals, i, svn_sort__item_t);
const char *local_abspath = item.key;
const char *defining_abspath = item.value;
svn_node_kind_t kind;
svn_opt_revision_t opt_rev;
const char *status_path;
svn_pool_clear(iterpool);
/* Obtain information on the expected external. */
SVN_ERR(svn_wc__read_external_info(&external_kind, NULL, NULL, NULL,
&opt_rev.value.number,
ctx->wc_ctx, defining_abspath,
local_abspath, FALSE,
iterpool, iterpool));
if (external_kind != svn_node_dir)
continue;
SVN_ERR(svn_io_check_path(local_abspath, &kind, iterpool));
if (kind != svn_node_dir)
continue;
if (SVN_IS_VALID_REVNUM(opt_rev.value.number))
opt_rev.kind = svn_opt_revision_number;
else
opt_rev.kind = svn_opt_revision_unspecified;
/* Tell the client we're starting an external status set. */
if (ctx->notify_func2)
ctx->notify_func2(
ctx->notify_baton2,
svn_wc_create_notify(local_abspath,
svn_wc_notify_status_external,
iterpool), iterpool);
status_path = local_abspath;
if (anchor_abspath)
{
status_path = svn_dirent_join(anchor_relpath,
svn_dirent_skip_ancestor(anchor_abspath,
status_path),
iterpool);
}
/* And then do the status. */
SVN_ERR(svn_client_status6(NULL, ctx, status_path, &opt_rev, depth,
get_all, check_out_of_date,
check_working_copy, no_ignore,
FALSE /* ignore_exernals */,
FALSE /* depth_as_sticky */,
changelists, status_func, status_baton,
iterpool));
}
/* Destroy SUBPOOL and (implicitly) ITERPOOL. */
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* Perform a hotcopy, either normal or incremental.
*
* Normal hotcopy assumes that the destination exists as an empty
* directory. It behaves like an incremental hotcopy except that
* none of the copied files already exist in the destination.
*
* An incremental hotcopy copies only changed or new files to the destination,
* and removes files from the destination no longer present in the source.
* While the incremental hotcopy is running, readers should still be able
* to access the destintation repository without error and should not see
* revisions currently in progress of being copied. Readers are able to see
* new fully copied revisions even if the entire incremental hotcopy procedure
* has not yet completed.
*
* Writers are blocked out completely during the entire incremental hotcopy
* process to ensure consistency. This function assumes that the repository
* write-lock is held.
*/
static svn_error_t *
hotcopy_body(void *baton, apr_pool_t *pool)
{
struct hotcopy_body_baton *hbb = baton;
svn_fs_t *src_fs = hbb->src_fs;
fs_fs_data_t *src_ffd = src_fs->fsap_data;
svn_fs_t *dst_fs = hbb->dst_fs;
fs_fs_data_t *dst_ffd = dst_fs->fsap_data;
svn_boolean_t incremental = hbb->incremental;
svn_fs_hotcopy_notify_t notify_func = hbb->notify_func;
void* notify_baton = hbb->notify_baton;
svn_cancel_func_t cancel_func = hbb->cancel_func;
void* cancel_baton = hbb->cancel_baton;
svn_revnum_t src_youngest;
apr_uint64_t src_next_node_id;
apr_uint64_t src_next_copy_id;
svn_revnum_t dst_youngest;
const char *src_revprops_dir;
const char *dst_revprops_dir;
const char *src_revs_dir;
const char *dst_revs_dir;
const char *src_subdir;
const char *dst_subdir;
svn_node_kind_t kind;
/* Try to copy the config.
*
* ### We try copying the config file before doing anything else,
* ### because higher layers will abort the hotcopy if we throw
* ### an error from this function, and that renders the hotcopy
* ### unusable anyway. */
if (src_ffd->format >= SVN_FS_FS__MIN_CONFIG_FILE)
{
svn_error_t *err;
err = svn_io_dir_file_copy(src_fs->path, dst_fs->path, PATH_CONFIG,
pool);
if (err)
{
if (APR_STATUS_IS_ENOENT(err->apr_err))
{
/* 1.6.0 to 1.6.11 did not copy the configuration file during
* hotcopy. So if we're hotcopying a repository which has been
* created as a hotcopy itself, it's possible that fsfs.conf
* does not exist. Ask the user to re-create it.
*
* ### It would be nice to make this a non-fatal error,
* ### but this function does not get an svn_fs_t object
* ### so we have no way of just printing a warning via
* ### the fs->warning() callback. */
const char *src_abspath;
const char *dst_abspath;
const char *config_relpath;
svn_error_t *err2;
config_relpath = svn_dirent_join(src_fs->path, PATH_CONFIG, pool);
err2 = svn_dirent_get_absolute(&src_abspath, src_fs->path, pool);
if (err2)
return svn_error_trace(svn_error_compose_create(err, err2));
err2 = svn_dirent_get_absolute(&dst_abspath, dst_fs->path, pool);
if (err2)
return svn_error_trace(svn_error_compose_create(err, err2));
/* ### hack: strip off the 'db/' directory from paths so
* ### they make sense to the user */
src_abspath = svn_dirent_dirname(src_abspath, pool);
dst_abspath = svn_dirent_dirname(dst_abspath, pool);
return svn_error_quick_wrapf(err,
_("Failed to create hotcopy at '%s'. "
"The file '%s' is missing from the source "
"repository. Please create this file, for "
"instance by running 'svnadmin upgrade %s'"),
dst_abspath, config_relpath, src_abspath);
}
else
return svn_error_trace(err);
}
}
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Find the youngest revision in the source and destination.
* We only support hotcopies from sources with an equal or greater amount
* of revisions than the destination.
* This also catches the case where users accidentally swap the
* source and destination arguments. */
SVN_ERR(svn_fs_fs__read_current(&src_youngest, &src_next_node_id,
&src_next_copy_id, src_fs, pool));
if (incremental)
{
SVN_ERR(svn_fs_fs__youngest_rev(&dst_youngest, dst_fs, pool));
if (src_youngest < dst_youngest)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("The hotcopy destination already contains more revisions "
"(%lu) than the hotcopy source contains (%lu); are source "
"and destination swapped?"),
dst_youngest, src_youngest);
}
else
dst_youngest = 0;
src_revs_dir = svn_dirent_join(src_fs->path, PATH_REVS_DIR, pool);
dst_revs_dir = svn_dirent_join(dst_fs->path, PATH_REVS_DIR, pool);
src_revprops_dir = svn_dirent_join(src_fs->path, PATH_REVPROPS_DIR, pool);
dst_revprops_dir = svn_dirent_join(dst_fs->path, PATH_REVPROPS_DIR, pool);
/* Ensure that the required folders exist in the destination
* before actually copying the revisions and revprops. */
SVN_ERR(svn_io_make_dir_recursively(dst_revs_dir, pool));
SVN_ERR(svn_io_make_dir_recursively(dst_revprops_dir, pool));
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Split the logic for new and old FS formats. The latter is much simpler
* due to the absense of sharding and packing. However, it requires special
* care when updating the 'current' file (which contains not just the
* revision number, but also the next-ID counters). */
if (src_ffd->format >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT)
{
SVN_ERR(hotcopy_revisions(src_fs, dst_fs, src_youngest, dst_youngest,
incremental, src_revs_dir, dst_revs_dir,
src_revprops_dir, dst_revprops_dir,
notify_func, notify_baton,
cancel_func, cancel_baton, pool));
SVN_ERR(svn_fs_fs__write_current(dst_fs, src_youngest, 0, 0, pool));
}
else
{
SVN_ERR(hotcopy_revisions_old(src_fs, dst_fs, src_youngest,
src_revs_dir, dst_revs_dir,
src_revprops_dir, dst_revprops_dir,
notify_func, notify_baton,
cancel_func, cancel_baton, pool));
SVN_ERR(svn_fs_fs__write_current(dst_fs, src_youngest, src_next_node_id,
src_next_copy_id, pool));
}
/* Replace the locks tree.
* This is racy in case readers are currently trying to list locks in
* the destination. However, we need to get rid of stale locks.
* This is the simplest way of doing this, so we accept this small race. */
dst_subdir = svn_dirent_join(dst_fs->path, PATH_LOCKS_DIR, pool);
SVN_ERR(svn_io_remove_dir2(dst_subdir, TRUE, cancel_func, cancel_baton,
pool));
src_subdir = svn_dirent_join(src_fs->path, PATH_LOCKS_DIR, pool);
SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
if (kind == svn_node_dir)
SVN_ERR(svn_io_copy_dir_recursively(src_subdir, dst_fs->path,
PATH_LOCKS_DIR, TRUE,
cancel_func, cancel_baton, pool));
/* Now copy the node-origins cache tree. */
src_subdir = svn_dirent_join(src_fs->path, PATH_NODE_ORIGINS_DIR, pool);
SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
if (kind == svn_node_dir)
SVN_ERR(hotcopy_io_copy_dir_recursively(NULL, src_subdir, dst_fs->path,
PATH_NODE_ORIGINS_DIR, TRUE,
cancel_func, cancel_baton, pool));
/*
* NB: Data copied below is only read by writers, not readers.
* Writers are still locked out at this point.
*/
if (dst_ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT)
{
/* Copy the rep cache and then remove entries for revisions
* that did not make it into the destination. */
src_subdir = svn_dirent_join(src_fs->path, REP_CACHE_DB_NAME, pool);
dst_subdir = svn_dirent_join(dst_fs->path, REP_CACHE_DB_NAME, pool);
SVN_ERR(svn_io_check_path(src_subdir, &kind, pool));
if (kind == svn_node_file)
{
SVN_ERR(svn_sqlite__hotcopy(src_subdir, dst_subdir, pool));
/* The source might have r/o flags set on it - which would be
carried over to the copy. */
SVN_ERR(svn_io_set_file_read_write(dst_subdir, FALSE, pool));
SVN_ERR(svn_fs_fs__del_rep_reference(dst_fs, src_youngest, pool));
}
}
/* Copy the txn-current file. */
if (dst_ffd->format >= SVN_FS_FS__MIN_TXN_CURRENT_FORMAT)
SVN_ERR(svn_io_dir_file_copy(src_fs->path, dst_fs->path,
PATH_TXN_CURRENT, pool));
return SVN_NO_ERROR;
}
/* Parse the file at DIGEST_PATH, populating the lock LOCK_P in that
file (if it exists, and if *LOCK_P is non-NULL) and the hash of
CHILDREN_P (if any exist, and if *CHILDREN_P is non-NULL). Use POOL
for all allocations. */
static svn_error_t *
read_digest_file(apr_hash_t **children_p,
svn_lock_t **lock_p,
const char *fs_path,
const char *digest_path,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
svn_lock_t *lock;
apr_hash_t *hash;
svn_stream_t *stream;
const char *val;
svn_node_kind_t kind;
if (lock_p)
*lock_p = NULL;
if (children_p)
*children_p = apr_hash_make(pool);
SVN_ERR(svn_io_check_path(digest_path, &kind, pool));
if (kind == svn_node_none)
return SVN_NO_ERROR;
/* If our caller doesn't care about anything but the presence of the
file... whatever. */
if (kind == svn_node_file && !lock_p && !children_p)
return SVN_NO_ERROR;
SVN_ERR(svn_stream_open_readonly(&stream, digest_path, pool, pool));
hash = apr_hash_make(pool);
if ((err = svn_hash_read2(hash, stream, SVN_HASH_TERMINATOR, pool)))
{
svn_error_clear(svn_stream_close(stream));
return svn_error_createf(err->apr_err,
err,
_("Can't parse lock/entries hashfile '%s'"),
svn_dirent_local_style(digest_path, pool));
}
SVN_ERR(svn_stream_close(stream));
/* If our caller cares, see if we have a lock path in our hash. If
so, we'll assume we have a lock here. */
val = hash_fetch(hash, PATH_KEY);
if (val && lock_p)
{
const char *path = val;
/* Create our lock and load it up. */
lock = svn_lock_create(pool);
lock->path = path;
if (! ((lock->token = hash_fetch(hash, TOKEN_KEY))))
return svn_error_trace(err_corrupt_lockfile(fs_path, path));
if (! ((lock->owner = hash_fetch(hash, OWNER_KEY))))
return svn_error_trace(err_corrupt_lockfile(fs_path, path));
if (! ((val = hash_fetch(hash, IS_DAV_COMMENT_KEY))))
return svn_error_trace(err_corrupt_lockfile(fs_path, path));
lock->is_dav_comment = (val[0] == '1');
if (! ((val = hash_fetch(hash, CREATION_DATE_KEY))))
return svn_error_trace(err_corrupt_lockfile(fs_path, path));
SVN_ERR(svn_time_from_cstring(&(lock->creation_date), val, pool));
if ((val = hash_fetch(hash, EXPIRATION_DATE_KEY)))
SVN_ERR(svn_time_from_cstring(&(lock->expiration_date), val, pool));
lock->comment = hash_fetch(hash, COMMENT_KEY);
*lock_p = lock;
}
/* If our caller cares, see if we have any children for this path. */
val = hash_fetch(hash, CHILDREN_KEY);
if (val && children_p)
{
apr_array_header_t *kiddos = svn_cstring_split(val, "\n", FALSE, pool);
int i;
for (i = 0; i < kiddos->nelts; i++)
{
svn_hash_sets(*children_p, APR_ARRAY_IDX(kiddos, i, const char *),
(void *)1);
}
}
static svn_error_t *
entries_dump(const char *dir_path, svn_wc_adm_access_t *related, apr_pool_t *pool)
{
svn_wc_adm_access_t *adm_access = NULL;
apr_hash_t *entries;
apr_hash_index_t *hi;
svn_boolean_t locked;
svn_error_t *err;
svn_wc_context_t *wc_ctx = NULL;
const char *dir_abspath;
err = svn_wc_adm_open3(&adm_access, related, dir_path, FALSE, 0,
NULL, NULL, pool);
if (!err)
{
SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
svn_wc__adm_get_db(adm_access),
pool));
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc_locked2(NULL, &locked, wc_ctx, dir_abspath, pool));
SVN_ERR(svn_wc_entries_read(&entries, adm_access, TRUE, pool));
}
else if (err && err->apr_err == SVN_ERR_WC_LOCKED
&& related
&& ! strcmp(dir_path, svn_wc_adm_access_path(related)))
{
/* Common caller error: Can't open a baton when there is one. */
svn_error_clear(err);
SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
svn_wc__adm_get_db(related),
pool));
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc_locked2(NULL, &locked, wc_ctx, dir_abspath, pool));
SVN_ERR(svn_wc_entries_read(&entries, related, TRUE, pool));
}
else
{
const char *lockfile_path;
svn_node_kind_t kind;
/* ### Should svn_wc_adm_open3 be returning UPGRADE_REQUIRED? */
if (err->apr_err != SVN_ERR_WC_NOT_DIRECTORY)
return err;
svn_error_clear(err);
adm_access = NULL;
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc__read_entries_old(&entries, dir_abspath, pool, pool));
lockfile_path = svn_dirent_join_many(pool, dir_path,
svn_wc_get_adm_dir(pool),
"lock", SVN_VA_NULL);
SVN_ERR(svn_io_check_path(lockfile_path, &kind, pool));
locked = (kind == svn_node_file);
}
for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi))
{
const char *key = apr_hash_this_key(hi);
const svn_wc_entry_t *entry = apr_hash_this_val(hi);
SVN_ERR_ASSERT(strcmp(key, entry->name) == 0);
printf("e = Entry()\n");
str_value("name", entry->name);
int_value("revision", entry->revision);
str_value("url", entry->url);
str_value("repos", entry->repos);
str_value("uuid", entry->uuid);
int_value("kind", entry->kind);
int_value("schedule", entry->schedule);
bool_value("copied", entry->copied);
bool_value("deleted", entry->deleted);
bool_value("absent", entry->absent);
bool_value("incomplete", entry->incomplete);
str_value("copyfrom_url", entry->copyfrom_url);
int_value("copyfrom_rev", entry->copyfrom_rev);
str_value("conflict_old", entry->conflict_old);
str_value("conflict_new", entry->conflict_new);
str_value("conflict_wrk", entry->conflict_wrk);
str_value("prejfile", entry->prejfile);
/* skip: text_time */
/* skip: prop_time */
/* skip: checksum */
int_value("cmt_rev", entry->cmt_rev);
/* skip: cmt_date */
str_value("cmt_author", entry->cmt_author);
str_value("lock_token", entry->lock_token);
str_value("lock_owner", entry->lock_owner);
str_value("lock_comment", entry->lock_comment);
/* skip: lock_creation_date */
/* skip: has_props */
/* skip: has_prop_mods */
/* skip: cachable_props */
/* skip: present_props */
str_value("changelist", entry->changelist);
/* skip: working_size */
/* skip: keep_local */
int_value("depth", entry->depth);
/* skip: tree_conflict_data */
bool_value("file_external", entry->file_external_path != NULL);
/* skip: file_external_peg_rev */
/* skip: file_external_rev */
bool_value("locked", locked && *entry->name == '\0');
printf("entries['%s'] = e\n", (const char *)key);
}
if (wc_ctx)
SVN_ERR(svn_wc_context_destroy(wc_ctx));
if (adm_access)
SVN_ERR(svn_wc_adm_close2(adm_access, pool));
return SVN_NO_ERROR;
}
/* Like svn_io_copy_dir_recursively() but doesn't copy regular files that
* exist in the destination and do not differ from the source in terms of
* kind, size, and mtime. Set *SKIPPED_P to FALSE only if at least one
* file was copied, do not change the value in *SKIPPED_P otherwise.
* SKIPPED_P may be NULL if not required. */
static svn_error_t *
hotcopy_io_copy_dir_recursively(svn_boolean_t *skipped_p,
const char *src,
const char *dst_parent,
const char *dst_basename,
svn_boolean_t copy_perms,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
svn_node_kind_t kind;
apr_status_t status;
const char *dst_path;
apr_dir_t *this_dir;
apr_finfo_t this_entry;
apr_int32_t flags = APR_FINFO_TYPE | APR_FINFO_NAME;
/* Make a subpool for recursion */
apr_pool_t *subpool = svn_pool_create(pool);
/* The 'dst_path' is simply dst_parent/dst_basename */
dst_path = svn_dirent_join(dst_parent, dst_basename, pool);
/* Sanity checks: SRC and DST_PARENT are directories, and
DST_BASENAME doesn't already exist in DST_PARENT. */
SVN_ERR(svn_io_check_path(src, &kind, subpool));
if (kind != svn_node_dir)
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("Source '%s' is not a directory"),
svn_dirent_local_style(src, pool));
SVN_ERR(svn_io_check_path(dst_parent, &kind, subpool));
if (kind != svn_node_dir)
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("Destination '%s' is not a directory"),
svn_dirent_local_style(dst_parent, pool));
SVN_ERR(svn_io_check_path(dst_path, &kind, subpool));
/* Create the new directory. */
/* ### TODO: copy permissions (needs apr_file_attrs_get()) */
SVN_ERR(svn_io_make_dir_recursively(dst_path, pool));
/* Loop over the dirents in SRC. ('.' and '..' are auto-excluded) */
SVN_ERR(svn_io_dir_open(&this_dir, src, subpool));
for (status = apr_dir_read(&this_entry, flags, this_dir);
status == APR_SUCCESS;
status = apr_dir_read(&this_entry, flags, this_dir))
{
if ((this_entry.name[0] == '.')
&& ((this_entry.name[1] == '\0')
|| ((this_entry.name[1] == '.')
&& (this_entry.name[2] == '\0'))))
{
continue;
}
else
{
const char *entryname_utf8;
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
SVN_ERR(entry_name_to_utf8(&entryname_utf8, this_entry.name,
src, subpool));
if (this_entry.filetype == APR_REG) /* regular file */
{
SVN_ERR(hotcopy_io_dir_file_copy(skipped_p, src, dst_path,
entryname_utf8, subpool));
}
else if (this_entry.filetype == APR_LNK) /* symlink */
{
const char *src_target = svn_dirent_join(src, entryname_utf8,
subpool);
const char *dst_target = svn_dirent_join(dst_path,
entryname_utf8,
subpool);
SVN_ERR(svn_io_copy_link(src_target, dst_target,
subpool));
}
else if (this_entry.filetype == APR_DIR) /* recurse */
{
const char *src_target;
/* Prevent infinite recursion by filtering off our
newly created destination path. */
if (strcmp(src, dst_parent) == 0
&& strcmp(entryname_utf8, dst_basename) == 0)
continue;
src_target = svn_dirent_join(src, entryname_utf8, subpool);
SVN_ERR(hotcopy_io_copy_dir_recursively(skipped_p,
src_target,
dst_path,
entryname_utf8,
copy_perms,
cancel_func,
cancel_baton,
subpool));
}
/* ### support other APR node types someday?? */
}
}
if (! (APR_STATUS_IS_ENOENT(status)))
return svn_error_wrap_apr(status, _("Can't read directory '%s'"),
svn_dirent_local_style(src, pool));
status = apr_dir_close(this_dir);
if (status)
return svn_error_wrap_apr(status, _("Error closing directory '%s'"),
svn_dirent_local_style(src, pool));
/* Free any memory used by recursion */
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_pristine_check(svn_boolean_t *present,
svn_wc__db_t *db,
const char *wri_abspath,
const svn_checksum_t *sha1_checksum,
apr_pool_t *scratch_pool)
{
svn_wc__db_wcroot_t *wcroot;
const char *local_relpath;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
SVN_ERR_ASSERT(svn_dirent_is_absolute(wri_abspath));
SVN_ERR_ASSERT(sha1_checksum != NULL);
if (sha1_checksum->kind != svn_checksum_sha1)
{
*present = FALSE;
return SVN_NO_ERROR;
}
SVN_ERR(svn_wc__db_wcroot_parse_local_abspath(&wcroot, &local_relpath, db,
wri_abspath, scratch_pool, scratch_pool));
VERIFY_USABLE_WCROOT(wcroot);
/* A filestat is much cheaper than a sqlite transaction especially on NFS,
so first check if there is a pristine file and then if we are allowed
to use it. */
{
const char *pristine_abspath;
svn_node_kind_t kind_on_disk;
svn_error_t *err;
SVN_ERR(get_pristine_fname(&pristine_abspath, wcroot->abspath,
sha1_checksum, scratch_pool, scratch_pool));
err = svn_io_check_path(pristine_abspath, &kind_on_disk, scratch_pool);
#ifdef WIN32
if (err && err->apr_err == APR_FROM_OS_ERROR(ERROR_ACCESS_DENIED))
{
svn_error_clear(err);
/* Possible race condition: The filename is locked, but there is no
file or dir with this name. Let's fall back on checking the DB.
This case is triggered by the pristine store tests on deleting
a file that is still open via another handle, where this other
handle has a FILE_SHARE_DELETE share mode.
*/
}
else
#endif
if (err)
return svn_error_trace(err);
else if (kind_on_disk != svn_node_file)
{
*present = FALSE;
return SVN_NO_ERROR;
}
}
/* Check that there is an entry in the PRISTINE table. */
SVN_ERR(svn_sqlite__get_statement(&stmt, wcroot->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));
*present = have_row;
return SVN_NO_ERROR;
}
/* The main logic of the public svn_client_add4.
*
* EXISTING_PARENT_ABSPATH is the absolute path to the first existing
* parent directory of local_abspath. If not NULL, all missing parents
* of LOCAL_ABSPATH must be created before LOCAL_ABSPATH can be added. */
static svn_error_t *
add(const char *local_abspath,
svn_depth_t depth,
svn_boolean_t force,
svn_boolean_t no_ignore,
const char *existing_parent_abspath,
svn_client_ctx_t *ctx,
apr_pool_t *scratch_pool)
{
svn_node_kind_t kind;
svn_error_t *err;
svn_magic__cookie_t *magic_cookie;
svn_magic__init(&magic_cookie, scratch_pool);
if (existing_parent_abspath)
{
const char *parent_abspath;
const char *child_relpath;
apr_array_header_t *components;
int i;
apr_pool_t *iterpool;
parent_abspath = existing_parent_abspath;
child_relpath = svn_dirent_is_child(existing_parent_abspath,
local_abspath, NULL);
components = svn_path_decompose(child_relpath, scratch_pool);
iterpool = svn_pool_create(scratch_pool);
for (i = 0; i < components->nelts - 1; i++)
{
const char *component;
svn_node_kind_t disk_kind;
svn_pool_clear(iterpool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
component = APR_ARRAY_IDX(components, i, const char *);
parent_abspath = svn_dirent_join(parent_abspath, component,
scratch_pool);
SVN_ERR(svn_io_check_path(parent_abspath, &disk_kind, iterpool));
if (disk_kind != svn_node_none && disk_kind != svn_node_dir)
return svn_error_createf(SVN_ERR_CLIENT_NO_VERSIONED_PARENT, NULL,
_("'%s' prevents creating parent of '%s'"),
parent_abspath, local_abspath);
SVN_ERR(svn_io_make_dir_recursively(parent_abspath, scratch_pool));
SVN_ERR(svn_wc_add_from_disk(ctx->wc_ctx, parent_abspath,
ctx->notify_func2, ctx->notify_baton2,
scratch_pool));
}
svn_pool_destroy(iterpool);
}
SVN_ERR(svn_io_check_path(local_abspath, &kind, scratch_pool));
if (kind == svn_node_dir)
{
/* We use add_dir_recursive for all directory targets
and pass depth along no matter what it is, so that the
target's depth will be set correctly. */
err = add_dir_recursive(local_abspath, depth, force, no_ignore,
magic_cookie, ctx, scratch_pool);
}
else if (kind == svn_node_file)
err = add_file(local_abspath, magic_cookie, ctx, scratch_pool);
else if (kind == svn_node_none)
{
svn_boolean_t tree_conflicted;
/* Provide a meaningful error message if the node does not exist
* on disk but is a tree conflict victim. */
err = svn_wc_conflicted_p3(NULL, NULL, &tree_conflicted,
ctx->wc_ctx, local_abspath,
scratch_pool);
if (err)
svn_error_clear(err);
else if (tree_conflicted)
return svn_error_createf(SVN_ERR_WC_FOUND_CONFLICT, NULL,
_("'%s' is an existing item in conflict; "
"please mark the conflict as resolved "
"before adding a new item here"),
svn_dirent_local_style(local_abspath,
scratch_pool));
return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
_("'%s' not found"),
svn_dirent_local_style(local_abspath,
scratch_pool));
}
else
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Unsupported node kind for path '%s'"),
svn_dirent_local_style(local_abspath,
scratch_pool));
/* Ignore SVN_ERR_ENTRY_EXISTS when FORCE is set. */
if (err && err->apr_err == SVN_ERR_ENTRY_EXISTS && force)
{
svn_error_clear(err);
err = SVN_NO_ERROR;
}
return svn_error_trace(err);
}
/* Helper for svn_wc__delete and svn_wc__delete_many */
static svn_error_t *
create_delete_wq_items(svn_skel_t **work_items,
svn_wc__db_t *db,
const char *local_abspath,
svn_node_kind_t kind,
svn_boolean_t conflicted,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
*work_items = NULL;
/* Schedule the on-disk delete */
if (kind == svn_node_dir)
SVN_ERR(svn_wc__wq_build_dir_remove(work_items, db, local_abspath,
local_abspath,
TRUE /* recursive */,
result_pool, scratch_pool));
else
SVN_ERR(svn_wc__wq_build_file_remove(work_items, db, local_abspath,
local_abspath,
result_pool, scratch_pool));
/* Read conflicts, to allow deleting the markers after updating the DB */
if (conflicted)
{
svn_skel_t *conflict;
const apr_array_header_t *markers;
int i;
SVN_ERR(svn_wc__db_read_conflict(&conflict, db, local_abspath,
scratch_pool, scratch_pool));
SVN_ERR(svn_wc__conflict_read_markers(&markers, db, local_abspath,
conflict,
scratch_pool, scratch_pool));
/* Maximum number of markers is 4, so no iterpool */
for (i = 0; markers && i < markers->nelts; i++)
{
const char *marker_abspath;
svn_node_kind_t marker_kind;
marker_abspath = APR_ARRAY_IDX(markers, i, const char *);
SVN_ERR(svn_io_check_path(marker_abspath, &marker_kind,
scratch_pool));
if (marker_kind == svn_node_file)
{
svn_skel_t *work_item;
SVN_ERR(svn_wc__wq_build_file_remove(&work_item, db,
local_abspath,
marker_abspath,
result_pool,
scratch_pool));
*work_items = svn_wc__wq_merge(*work_items, work_item,
result_pool);
}
}
}
return SVN_NO_ERROR;
}