/* Do a modifed check for LOCAL_ABSPATH, and all working children, to force
timestamp repair. */
static svn_error_t *
repair_timestamps(svn_wc__db_t *db,
const char *local_abspath,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *scratch_pool)
{
svn_kind_t kind;
svn_wc__db_status_t status;
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
SVN_ERR(svn_wc__db_read_info(&status, &kind,
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, local_abspath, scratch_pool, scratch_pool));
if (status == svn_wc__db_status_server_excluded
|| status == svn_wc__db_status_deleted
|| status == svn_wc__db_status_excluded
|| status == svn_wc__db_status_not_present)
return SVN_NO_ERROR;
if (kind == svn_kind_file
|| kind == svn_kind_symlink)
{
svn_boolean_t modified;
SVN_ERR(svn_wc__internal_file_modified_p(&modified,
db, local_abspath, FALSE,
scratch_pool));
}
else if (kind == svn_kind_dir)
{
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
const apr_array_header_t *children;
int i;
SVN_ERR(svn_wc__db_read_children_of_working_node(&children, db,
local_abspath,
scratch_pool,
iterpool));
for (i = 0; i < children->nelts; ++i)
{
const char *child_abspath;
svn_pool_clear(iterpool);
child_abspath = svn_dirent_join(local_abspath,
APR_ARRAY_IDX(children, i,
const char *),
iterpool);
SVN_ERR(repair_timestamps(db, child_abspath,
cancel_func, cancel_baton, iterpool));
}
svn_pool_destroy(iterpool);
}
svn_error_t *
svn_wc__expand_keywords(apr_hash_t **keywords,
svn_wc__db_t *db,
const char *local_abspath,
const char *wri_abspath,
const char *keyword_list,
svn_boolean_t for_normalization,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_revnum_t changed_rev;
apr_time_t changed_date;
const char *changed_author;
const char *url;
const char *repos_root_url;
if (! for_normalization)
{
const char *repos_relpath;
SVN_ERR(svn_wc__db_read_info(NULL, NULL, NULL, &repos_relpath,
&repos_root_url, NULL, &changed_rev,
&changed_date, &changed_author, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
db, local_abspath,
scratch_pool, scratch_pool));
/* Handle special statuses (e.g. added) */
if (!repos_relpath)
SVN_ERR(svn_wc__db_read_repos_info(NULL, &repos_relpath,
&repos_root_url, NULL,
db, local_abspath,
scratch_pool, scratch_pool));
url = svn_path_url_add_component2(repos_root_url, repos_relpath,
scratch_pool);
}
else
{
url = "";
changed_rev = SVN_INVALID_REVNUM;
changed_date = 0;
changed_author = "";
repos_root_url = "";
}
SVN_ERR(svn_subst_build_keywords3(keywords, keyword_list,
apr_psprintf(scratch_pool, "%ld",
changed_rev),
url, repos_root_url,
changed_date, changed_author,
result_pool));
if (apr_hash_count(*keywords) == 0)
*keywords = NULL;
return SVN_NO_ERROR;
}
/* Implements svn_wc_status_func3_t */
static svn_error_t *
diff_status_callback(void *baton,
const char *local_abspath,
const svn_wc_status3_t *status,
apr_pool_t *scratch_pool)
{
struct diff_baton *eb = baton;
svn_wc__db_t *db = eb->db;
if (! status->versioned)
return SVN_NO_ERROR; /* unversioned (includes dir externals) */
if (status->node_status == svn_wc_status_conflicted
&& status->text_status == svn_wc_status_none
&& status->prop_status == svn_wc_status_none)
{
/* Node is an actual only node describing a tree conflict */
return SVN_NO_ERROR;
}
/* Not text/prop modified, not copied. Easy out */
if (status->node_status == svn_wc_status_normal && !status->copied)
return SVN_NO_ERROR;
/* Mark all directories where we are no longer inside as closed */
while (eb->cur
&& !svn_dirent_is_ancestor(eb->cur->local_abspath, local_abspath))
{
struct node_state_t *ns = eb->cur;
if (!ns->skip)
{
if (ns->propchanges)
SVN_ERR(eb->processor->dir_changed(ns->relpath,
ns->left_src,
ns->right_src,
ns->left_props,
ns->right_props,
ns->propchanges,
ns->baton,
eb->processor,
ns->pool));
else
SVN_ERR(eb->processor->dir_closed(ns->relpath,
ns->left_src,
ns->right_src,
ns->baton,
eb->processor,
ns->pool));
}
eb->cur = ns->parent;
svn_pool_clear(ns->pool);
}
SVN_ERR(ensure_state(eb, svn_dirent_dirname(local_abspath, scratch_pool),
FALSE, scratch_pool));
if (eb->cur && eb->cur->skip_children)
return SVN_NO_ERROR;
if (eb->changelist_hash != NULL
&& (!status->changelist
|| ! svn_hash_gets(eb->changelist_hash, status->changelist)))
return SVN_NO_ERROR; /* Filtered via changelist */
/* This code does about the same thing as the inner body of
walk_local_nodes_diff() in diff_editor.c, except that
it is already filtered by the status walker, doesn't have to
account for remote changes (and many tiny other details) */
{
svn_boolean_t repos_only;
svn_boolean_t local_only;
svn_wc__db_status_t db_status;
svn_boolean_t have_base;
svn_node_kind_t base_kind;
svn_node_kind_t db_kind = status->kind;
svn_depth_t depth_below_here = svn_depth_unknown;
const char *child_abspath = local_abspath;
const char *child_relpath = svn_dirent_skip_ancestor(eb->anchor_abspath,
local_abspath);
repos_only = FALSE;
local_only = FALSE;
/* ### optimize away this call using status info. Should
be possible in almost every case (except conflict, missing, obst.)*/
SVN_ERR(svn_wc__db_read_info(&db_status, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
&have_base, NULL, NULL,
eb->db, local_abspath,
scratch_pool, scratch_pool));
if (!have_base)
{
local_only = TRUE; /* Only report additions */
}
else if (db_status == svn_wc__db_status_normal)
{
/* Simple diff */
base_kind = db_kind;
}
else if (db_status == svn_wc__db_status_deleted)
{
svn_wc__db_status_t base_status;
repos_only = TRUE;
SVN_ERR(svn_wc__db_base_get_info(&base_status, &base_kind, NULL,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL,
eb->db, local_abspath,
scratch_pool, scratch_pool));
if (base_status != svn_wc__db_status_normal)
return SVN_NO_ERROR;
}
else
{
/* working status is either added or deleted */
svn_wc__db_status_t base_status;
SVN_ERR(svn_wc__db_base_get_info(&base_status, &base_kind, NULL,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL,
eb->db, local_abspath,
scratch_pool, scratch_pool));
if (base_status != svn_wc__db_status_normal)
local_only = TRUE;
else if (base_kind != db_kind || !eb->ignore_ancestry)
{
repos_only = TRUE;
local_only = TRUE;
}
}
if (repos_only)
{
/* Report repository form deleted */
if (base_kind == svn_node_file)
SVN_ERR(svn_wc__diff_base_only_file(db, child_abspath,
child_relpath,
SVN_INVALID_REVNUM,
eb->processor,
eb->cur ? eb->cur->baton : NULL,
scratch_pool));
else if (base_kind == svn_node_dir)
SVN_ERR(svn_wc__diff_base_only_dir(db, child_abspath,
child_relpath,
SVN_INVALID_REVNUM,
depth_below_here,
eb->processor,
eb->cur ? eb->cur->baton : NULL,
eb->cancel_func,
eb->cancel_baton,
scratch_pool));
}
else if (!local_only)
{
/* Diff base against actual */
if (db_kind == svn_node_file)
{
SVN_ERR(svn_wc__diff_base_working_diff(db, child_abspath,
child_relpath,
SVN_INVALID_REVNUM,
eb->changelist_hash,
eb->processor,
eb->cur
? eb->cur->baton
: NULL,
FALSE,
eb->cancel_func,
eb->cancel_baton,
scratch_pool));
}
else if (db_kind == svn_node_dir)
{
SVN_ERR(ensure_state(eb, local_abspath, FALSE, scratch_pool));
if (status->prop_status != svn_wc_status_none
&& status->prop_status != svn_wc_status_normal)
{
apr_array_header_t *propchanges;
SVN_ERR(svn_wc__db_base_get_props(&eb->cur->left_props,
eb->db, local_abspath,
eb->cur->pool,
scratch_pool));
SVN_ERR(svn_wc__db_read_props(&eb->cur->right_props,
eb->db, local_abspath,
eb->cur->pool,
scratch_pool));
SVN_ERR(svn_prop_diffs(&propchanges,
eb->cur->right_props,
eb->cur->left_props,
eb->cur->pool));
eb->cur->propchanges = propchanges;
}
}
}
if (local_only && (db_status != svn_wc__db_status_deleted))
{
if (db_kind == svn_node_file)
SVN_ERR(svn_wc__diff_local_only_file(db, child_abspath,
child_relpath,
eb->processor,
eb->cur ? eb->cur->baton : NULL,
eb->changelist_hash,
FALSE,
eb->cancel_func,
eb->cancel_baton,
scratch_pool));
else if (db_kind == svn_node_dir)
SVN_ERR(svn_wc__diff_local_only_dir(db, child_abspath,
child_relpath, depth_below_here,
eb->processor,
eb->cur ? eb->cur->baton : NULL,
eb->changelist_hash,
FALSE,
eb->cancel_func,
eb->cancel_baton,
scratch_pool));
}
if (db_kind == svn_node_dir && (local_only || repos_only))
SVN_ERR(ensure_state(eb, local_abspath, TRUE /* skip */, scratch_pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc_relocate4(svn_wc_context_t *wc_ctx,
const char *local_abspath,
const char *from,
const char *to,
svn_wc_relocation_validator3_t validator,
void *validator_baton,
apr_pool_t *scratch_pool)
{
svn_node_kind_t kind;
const char *repos_relpath;
const char *old_repos_root, *old_url;
const char *new_repos_root, *new_url;
size_t from_len;
size_t old_url_len;
const char *uuid;
svn_boolean_t is_wc_root;
SVN_ERR(svn_wc__is_wcroot(&is_wc_root, wc_ctx, local_abspath,
scratch_pool));
if (! is_wc_root)
{
const char *wcroot_abspath;
svn_error_t *err;
err = svn_wc__db_get_wcroot(&wcroot_abspath, wc_ctx->db,
local_abspath, scratch_pool, scratch_pool);
if (err)
{
svn_error_clear(err);
return svn_error_createf(
SVN_ERR_WC_INVALID_OP_ON_CWD, NULL,
_("Cannot relocate '%s' as it is not the root of a working copy"),
svn_dirent_local_style(local_abspath, scratch_pool));
}
else
{
return svn_error_createf(
SVN_ERR_WC_INVALID_OP_ON_CWD, NULL,
_("Cannot relocate '%s' as it is not the root of a working copy; "
"try relocating '%s' instead"),
svn_dirent_local_style(local_abspath, scratch_pool),
svn_dirent_local_style(wcroot_abspath, scratch_pool));
}
}
SVN_ERR(svn_wc__db_read_info(NULL, &kind, NULL, &repos_relpath,
&old_repos_root, &uuid,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL,
wc_ctx->db, local_abspath, scratch_pool,
scratch_pool));
if (kind != svn_node_dir)
return svn_error_create(SVN_ERR_CLIENT_INVALID_RELOCATION, NULL,
_("Cannot relocate a single file"));
old_url = svn_path_url_add_component2(old_repos_root, repos_relpath,
scratch_pool);
old_url_len = strlen(old_url);
from_len = strlen(from);
if ((from_len > old_url_len) || (strncmp(old_url, from, strlen(from)) != 0))
return svn_error_createf(SVN_ERR_WC_INVALID_RELOCATION, NULL,
_("Invalid source URL prefix: '%s' (does not "
"overlap target's URL '%s')"),
from, old_url);
if (old_url_len == from_len)
new_url = to;
else
new_url = apr_pstrcat(scratch_pool, to, old_url + from_len, (char *)NULL);
if (! svn_path_is_url(new_url))
return svn_error_createf(SVN_ERR_WC_INVALID_RELOCATION, NULL,
_("Invalid relocation destination: '%s' "
"(not a URL)"), new_url);
new_repos_root = url_remove_final_relpath(new_url, repos_relpath,
scratch_pool, scratch_pool);
if (!new_repos_root)
return svn_error_createf(SVN_ERR_WC_INVALID_RELOCATION, NULL,
_("Invalid relocation destination: '%s' "
"(does not point to target)" ), new_url);
SVN_ERR(validator(validator_baton, uuid, new_url, new_repos_root,
scratch_pool));
return svn_error_trace(svn_wc__db_global_relocate(wc_ctx->db, local_abspath,
new_repos_root,
scratch_pool));
}
svn_error_t *
svn_wc__sync_flags_with_props(svn_boolean_t *did_set,
svn_wc__db_t *db,
const char *local_abspath,
apr_pool_t *scratch_pool)
{
svn_wc__db_status_t status;
svn_node_kind_t kind;
svn_wc__db_lock_t *lock;
apr_hash_t *props = NULL;
svn_boolean_t had_props;
svn_boolean_t props_mod;
if (did_set)
*did_set = FALSE;
/* ### We'll consolidate these info gathering statements in a future
commit. */
SVN_ERR(svn_wc__db_read_info(&status, &kind, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, &lock, NULL, NULL, NULL, NULL, NULL,
&had_props, &props_mod, NULL, NULL, NULL,
db, local_abspath,
scratch_pool, scratch_pool));
/* We actually only care about the following flags on files, so just
early-out for all other types.
Also bail if there is no in-wc representation of the file. */
if (kind != svn_node_file
|| (status != svn_wc__db_status_normal
&& status != svn_wc__db_status_added))
return SVN_NO_ERROR;
if (props_mod || had_props)
SVN_ERR(svn_wc__db_read_props(&props, db, local_abspath, scratch_pool,
scratch_pool));
else
props = NULL;
/* If we get this far, we're going to change *something*, so just set
the flag appropriately. */
if (did_set)
*did_set = TRUE;
/* Handle the read-write bit. */
if (status != svn_wc__db_status_normal
|| props == NULL
|| ! svn_hash_gets(props, SVN_PROP_NEEDS_LOCK)
|| lock)
{
SVN_ERR(svn_io_set_file_read_write(local_abspath, FALSE, scratch_pool));
}
else
{
/* Special case: If we have an uncommitted svn:needs-lock, we don't
set the file read_only just yet. That happens upon commit. */
apr_hash_t *pristine_props;
if (! props_mod)
pristine_props = props;
else if (had_props)
SVN_ERR(svn_wc__db_read_pristine_props(&pristine_props, db, local_abspath,
scratch_pool, scratch_pool));
else
pristine_props = NULL;
if (pristine_props
&& svn_hash_gets(pristine_props, SVN_PROP_NEEDS_LOCK) )
/*&& props
&& apr_hash_get(props, SVN_PROP_NEEDS_LOCK, APR_HASH_KEY_STRING) )*/
SVN_ERR(svn_io_set_file_read_only(local_abspath, FALSE, scratch_pool));
}
/* Windows doesn't care about the execute bit. */
#ifndef WIN32
if (props == NULL
|| ! svn_hash_gets(props, SVN_PROP_EXECUTABLE))
{
/* Turn off the execute bit */
SVN_ERR(svn_io_set_file_executable(local_abspath, FALSE, FALSE,
scratch_pool));
}
else
SVN_ERR(svn_io_set_file_executable(local_abspath, TRUE, FALSE,
scratch_pool));
#endif
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__delete_many(svn_wc_context_t *wc_ctx,
const apr_array_header_t *targets,
svn_boolean_t keep_local,
svn_boolean_t delete_unversioned_target,
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_error_t *err;
svn_wc__db_status_t status;
svn_node_kind_t kind;
svn_skel_t *work_items = NULL;
apr_array_header_t *versioned_targets;
const char *local_abspath;
int i;
apr_pool_t *iterpool;
iterpool = svn_pool_create(scratch_pool);
versioned_targets = apr_array_make(scratch_pool, targets->nelts,
sizeof(const char *));
for (i = 0; i < targets->nelts; i++)
{
svn_boolean_t conflicted = FALSE;
const char *repos_relpath;
svn_pool_clear(iterpool);
local_abspath = APR_ARRAY_IDX(targets, i, const char *);
err = svn_wc__db_read_info(&status, &kind, NULL, &repos_relpath, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, &conflicted,
NULL, NULL, NULL, NULL, NULL, NULL,
db, local_abspath, iterpool, iterpool);
if (err)
{
if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
svn_error_clear(err);
if (delete_unversioned_target && !keep_local)
SVN_ERR(erase_unversioned_from_wc(local_abspath, FALSE,
cancel_func, cancel_baton,
iterpool));
continue;
}
else
return svn_error_trace(err);
}
APR_ARRAY_PUSH(versioned_targets, const char *) = local_abspath;
switch (status)
{
/* svn_wc__db_status_server_excluded handled by
* svn_wc__db_op_delete_many */
case svn_wc__db_status_excluded:
case svn_wc__db_status_not_present:
return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
_("'%s' cannot be deleted"),
svn_dirent_local_style(local_abspath,
iterpool));
/* Explicitly ignore other statii */
default:
break;
}
if (status == svn_wc__db_status_normal
&& kind == svn_node_dir)
{
svn_boolean_t is_wcroot;
SVN_ERR(svn_wc__db_is_wcroot(&is_wcroot, db, local_abspath,
iterpool));
if (is_wcroot)
return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
_("'%s' is the root of a working copy and "
"cannot be deleted"),
svn_dirent_local_style(local_abspath,
iterpool));
}
if (repos_relpath && !repos_relpath[0])
return svn_error_createf(SVN_ERR_WC_PATH_UNEXPECTED_STATUS, NULL,
_("'%s' represents the repository root "
"and cannot be deleted"),
svn_dirent_local_style(local_abspath,
iterpool));
/* Verify if we have a write lock on the parent of this node as we might
be changing the childlist of that directory. */
SVN_ERR(svn_wc__write_check(db, svn_dirent_dirname(local_abspath,
iterpool),
iterpool));
/* Prepare the on-disk delete */
if (!keep_local)
{
svn_skel_t *work_item;
SVN_ERR(create_delete_wq_items(&work_item, db, local_abspath, kind,
conflicted,
scratch_pool, iterpool));
work_items = svn_wc__wq_merge(work_items, work_item,
scratch_pool);
}
}
if (versioned_targets->nelts == 0)
return SVN_NO_ERROR;
SVN_ERR(svn_wc__db_op_delete_many(db, versioned_targets,
!keep_local /* delete_dir_externals */,
work_items,
cancel_func, cancel_baton,
notify_func, notify_baton,
iterpool));
if (work_items != NULL)
{
/* Our only caller locked the wc, so for now assume it only passed
nodes from a single wc (asserted in svn_wc__db_op_delete_many) */
local_abspath = APR_ARRAY_IDX(versioned_targets, 0, const char *);
SVN_ERR(svn_wc__wq_run(db, local_abspath, cancel_func, cancel_baton,
iterpool));
}
/* Helper function that crops the children of the LOCAL_ABSPATH, under the
* constraint of NEW_DEPTH. The DIR_PATH itself will never be cropped. The
* whole subtree should have been locked.
*
* DIR_DEPTH is the current depth of LOCAL_ABSPATH as stored in DB.
*
* If NOTIFY_FUNC is not null, each file and ROOT of subtree will be reported
* upon remove.
*/
static svn_error_t *
crop_children(svn_wc__db_t *db,
const char *local_abspath,
svn_depth_t dir_depth,
svn_depth_t new_depth,
svn_wc_notify_func2_t notify_func,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
const apr_array_header_t *children;
apr_pool_t *iterpool;
int i;
SVN_ERR_ASSERT(new_depth >= svn_depth_empty
&& new_depth <= svn_depth_infinity);
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
iterpool = svn_pool_create(pool);
if (dir_depth == svn_depth_unknown)
dir_depth = svn_depth_infinity;
/* Update the depth of target first, if needed. */
if (dir_depth > new_depth)
SVN_ERR(svn_wc__db_op_set_base_depth(db, local_abspath, new_depth,
iterpool));
/* Looping over current directory's SVN entries: */
SVN_ERR(svn_wc__db_read_children(&children, db, local_abspath, pool,
iterpool));
for (i = 0; i < children->nelts; i++)
{
const char *child_name = APR_ARRAY_IDX(children, i, const char *);
const char *child_abspath;
svn_wc__db_status_t child_status;
svn_wc__db_kind_t kind;
svn_depth_t child_depth;
svn_pool_clear(iterpool);
/* Get the next node */
child_abspath = svn_dirent_join(local_abspath, child_name, iterpool);
SVN_ERR(svn_wc__db_read_info(&child_status, &kind, NULL, NULL, NULL,
NULL,NULL, NULL, NULL, &child_depth,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
db, child_abspath, iterpool, iterpool));
if (child_status == svn_wc__db_status_server_excluded ||
child_status == svn_wc__db_status_excluded ||
child_status == svn_wc__db_status_not_present)
{
svn_depth_t remove_below = (kind == svn_wc__db_kind_dir)
? svn_depth_immediates
: svn_depth_files;
if (new_depth < remove_below)
SVN_ERR(svn_wc__db_op_remove_node(db, local_abspath,
SVN_INVALID_REVNUM,
svn_wc__db_kind_unknown,
iterpool));
continue;
}
else if (kind == svn_wc__db_kind_file)
{
/* We currently crop on a directory basis. So don't worry about
svn_depth_exclude here. And even we permit excluding a single
file in the future, svn_wc_remove_from_revision_control() can
also handle it. We only need to skip the notification in that
case. */
if (new_depth == svn_depth_empty)
IGNORE_LOCAL_MOD(
svn_wc__internal_remove_from_revision_control(
db,
child_abspath,
TRUE, /* destroy */
FALSE, /* instant error */
cancel_func, cancel_baton,
iterpool));
else
continue;
}
else if (kind == svn_wc__db_kind_dir)
{
if (new_depth < svn_depth_immediates)
{
IGNORE_LOCAL_MOD(
svn_wc__internal_remove_from_revision_control(
db,
child_abspath,
TRUE, /* destroy */
FALSE, /* instant error */
cancel_func,
cancel_baton,
iterpool));
}
else
{
SVN_ERR(crop_children(db,
child_abspath,
child_depth,
svn_depth_empty,
notify_func,
notify_baton,
cancel_func,
cancel_baton,
iterpool));
continue;
}
}
else
{
return svn_error_createf
(SVN_ERR_NODE_UNKNOWN_KIND, NULL, _("Unknown node kind for '%s'"),
svn_dirent_local_style(child_abspath, iterpool));
}
if (notify_func)
{
svn_wc_notify_t *notify;
notify = svn_wc_create_notify(child_abspath,
svn_wc_notify_delete,
iterpool);
(*notify_func)(notify_baton, notify, iterpool);
}
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc_crop_tree2(svn_wc_context_t *wc_ctx,
const char *local_abspath,
svn_depth_t depth,
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_wc__db_status_t status;
svn_wc__db_kind_t kind;
svn_depth_t dir_depth;
/* Only makes sense when the depth is restrictive. */
if (depth == svn_depth_infinity)
return SVN_NO_ERROR; /* Nothing to crop */
if (!(depth >= svn_depth_empty && depth < svn_depth_infinity))
return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Can only crop a working copy with a restrictive depth"));
SVN_ERR(svn_wc__db_read_info(&status, &kind, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, &dir_depth, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
db, local_abspath,
scratch_pool, scratch_pool));
if (kind != svn_wc__db_kind_dir)
return svn_error_create(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Can only crop directories"));
switch (status)
{
case svn_wc__db_status_not_present:
case svn_wc__db_status_server_excluded:
return svn_error_createf(SVN_ERR_WC_PATH_NOT_FOUND, NULL,
_("The node '%s' was not found."),
svn_dirent_local_style(local_abspath,
scratch_pool));
case svn_wc__db_status_deleted:
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot crop '%s': it is going to be removed "
"from repository. Try commit instead"),
svn_dirent_local_style(local_abspath,
scratch_pool));
case svn_wc__db_status_added:
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot crop '%s': it is to be added "
"to the repository. Try commit instead"),
svn_dirent_local_style(local_abspath,
scratch_pool));
case svn_wc__db_status_excluded:
return SVN_NO_ERROR; /* Nothing to do */
case svn_wc__db_status_normal:
case svn_wc__db_status_incomplete:
break;
default:
SVN_ERR_MALFUNCTION();
}
return crop_children(db, local_abspath, dir_depth, depth,
notify_func, notify_baton,
cancel_func, cancel_baton, scratch_pool);
}
svn_error_t *
svn_wc_exclude(svn_wc_context_t *wc_ctx,
const char *local_abspath,
svn_cancel_func_t cancel_func,
void *cancel_baton,
svn_wc_notify_func2_t notify_func,
void *notify_baton,
apr_pool_t *scratch_pool)
{
svn_boolean_t is_root, is_switched;
svn_wc__db_status_t status;
svn_wc__db_kind_t kind;
svn_revnum_t revision;
const char *repos_relpath, *repos_root, *repos_uuid;
SVN_ERR(svn_wc__check_wc_root(&is_root, NULL, &is_switched,
wc_ctx->db, local_abspath, scratch_pool));
if (is_root)
{
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot exclude '%s': "
"it is a working copy root"),
svn_dirent_local_style(local_abspath,
scratch_pool));
}
if (is_switched)
{
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot exclude '%s': "
"it is a switched path"),
svn_dirent_local_style(local_abspath,
scratch_pool));
}
SVN_ERR(svn_wc__db_read_info(&status, &kind, &revision, &repos_relpath,
&repos_root, &repos_uuid, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL,
wc_ctx->db, local_abspath,
scratch_pool, scratch_pool));
switch (status)
{
case svn_wc__db_status_server_excluded:
case svn_wc__db_status_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(local_abspath,
scratch_pool));
case svn_wc__db_status_added:
/* Would have to check parents if we want to allow this */
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot exclude '%s': it is to be added "
"to the repository. Try commit instead"),
svn_dirent_local_style(local_abspath,
scratch_pool));
case svn_wc__db_status_deleted:
/* Would have to check parents if we want to allow this */
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Cannot exclude '%s': it is to be deleted "
"from the repository. Try commit instead"),
svn_dirent_local_style(local_abspath,
scratch_pool));
case svn_wc__db_status_normal:
case svn_wc__db_status_incomplete:
default:
break; /* Ok to exclude */
}
/* ### This could use some kind of transaction */
/* Remove all working copy data below local_abspath */
IGNORE_LOCAL_MOD(svn_wc__internal_remove_from_revision_control(
wc_ctx->db,
local_abspath,
TRUE,
FALSE,
cancel_func, cancel_baton,
scratch_pool));
SVN_ERR(svn_wc__db_base_add_excluded_node(wc_ctx->db,
local_abspath,
repos_relpath,
repos_root,
repos_uuid,
revision,
kind,
svn_wc__db_status_excluded,
NULL, NULL,
scratch_pool));
if (notify_func)
{
svn_wc_notify_t *notify;
notify = svn_wc_create_notify(local_abspath,
svn_wc_notify_exclude,
scratch_pool);
notify_func(notify_baton, notify, scratch_pool);
}
return SVN_NO_ERROR;
}
/* Diff the file PATH against its text base. At this
* stage we are dealing with a file that does exist in the working copy.
*
* DIR_BATON is the parent directory baton, PATH is the path to the file to
* be compared.
*
* Do all allocation in POOL.
*
* ### TODO: Need to work on replace if the new filename used to be a
* directory.
*/
static svn_error_t *
file_diff(struct diff_baton *eb,
const char *local_abspath,
const char *path,
apr_pool_t *scratch_pool)
{
svn_wc__db_t *db = eb->db;
const char *empty_file;
const char *original_repos_relpath;
svn_wc__db_status_t status;
svn_kind_t kind;
svn_revnum_t revision;
const svn_checksum_t *checksum;
svn_boolean_t op_root;
svn_boolean_t had_props, props_mod;
svn_boolean_t have_base, have_more_work;
svn_boolean_t replaced = FALSE;
svn_boolean_t base_replace = FALSE;
svn_wc__db_status_t base_status;
svn_revnum_t base_revision = SVN_INVALID_REVNUM;
const svn_checksum_t *base_checksum;
const char *pristine_abspath;
SVN_ERR(svn_wc__db_read_info(&status, &kind, &revision, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, &checksum, NULL,
&original_repos_relpath, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
&op_root, &had_props, &props_mod,
&have_base, &have_more_work, NULL,
db, local_abspath, scratch_pool, scratch_pool));
if ((status == svn_wc__db_status_added) && (have_base || have_more_work))
{
SVN_ERR(svn_wc__db_node_check_replace(&replaced, &base_replace,
NULL, db, local_abspath,
scratch_pool));
if (replaced && base_replace /* && !have_more_work */)
{
svn_kind_t base_kind;
SVN_ERR(svn_wc__db_base_get_info(&base_status, &base_kind,
&base_revision,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, &base_checksum, NULL,
NULL, NULL, NULL,
db, local_abspath,
scratch_pool, scratch_pool));
if (base_status != svn_wc__db_status_normal
|| base_kind != kind)
{
/* We can't show a replacement here */
replaced = FALSE;
base_replace = FALSE;
}
}
else
{
/* We can't look in this middle working layer (yet).
We just report the change itself.
And if we could look at it, how would we report the addition
of this middle layer (and maybe different layers below that)?
For 1.7 we just do what we did before: Ignore this layering
problem and just show how the current file got in your wc.
*/
replaced = FALSE;
base_replace = FALSE;
}
}
/* Now refine ADDED to one of: ADDED, COPIED, MOVED_HERE. Note that only
the latter two have corresponding pristine info to diff against. */
if (status == svn_wc__db_status_added)
SVN_ERR(svn_wc__db_scan_addition(&status, NULL, NULL, NULL, NULL,
&original_repos_relpath, NULL, NULL,
NULL, NULL, NULL, db, local_abspath,
scratch_pool, scratch_pool));
SVN_ERR(get_empty_file(eb, &empty_file, scratch_pool));
/* When we show a delete, we show a diff of the original pristine against
* an empty file.
* A base-replace is treated like a delete plus an add.
*
* For this kind of diff we prefer to show the deletion of what was checked
* out over showing what was actually deleted (if that was defined by
* a higher layer). */
if (status == svn_wc__db_status_deleted ||
(base_replace && ! eb->ignore_ancestry))
{
apr_hash_t *del_props;
const svn_checksum_t *del_checksum;
const char *del_text_abspath;
const char *del_mimetype;
if (base_replace && ! eb->ignore_ancestry)
{
/* We show a deletion of the information in the BASE layer */
SVN_ERR(svn_wc__db_base_get_props(&del_props, db, local_abspath,
scratch_pool, scratch_pool));
del_checksum = base_checksum;
}
else
{
/* We show a deletion of what was actually deleted */
SVN_ERR_ASSERT(status == svn_wc__db_status_deleted);
SVN_ERR(svn_wc__get_pristine_props(&del_props, db, local_abspath,
scratch_pool, scratch_pool));
SVN_ERR(svn_wc__db_read_pristine_info(NULL, NULL, NULL, NULL, NULL,
NULL, &del_checksum, NULL,
NULL, db, local_abspath,
scratch_pool, scratch_pool));
}
SVN_ERR_ASSERT(del_checksum != NULL);
SVN_ERR(svn_wc__db_pristine_get_path(&del_text_abspath, db,
local_abspath, del_checksum,
scratch_pool, scratch_pool));
if (del_props == NULL)
del_props = apr_hash_make(scratch_pool);
del_mimetype = get_prop_mimetype(del_props);
SVN_ERR(eb->callbacks->file_deleted(NULL, NULL, path,
del_text_abspath,
empty_file,
del_mimetype,
NULL,
del_props,
eb->callback_baton,
scratch_pool));
if (status == svn_wc__db_status_deleted)
{
/* We're here only for showing a delete, so we're done. */
return SVN_NO_ERROR;
}
}
if (checksum != NULL)
SVN_ERR(svn_wc__db_pristine_get_path(&pristine_abspath, db, local_abspath,
checksum,
scratch_pool, scratch_pool));
else if (base_replace && eb->ignore_ancestry)
SVN_ERR(svn_wc__db_pristine_get_path(&pristine_abspath, db, local_abspath,
base_checksum,
scratch_pool, scratch_pool));
else
pristine_abspath = empty_file;
/* Now deal with showing additions, or the add-half of replacements.
* If the item is schedule-add *with history*, then we usually want
* to see the usual working vs. text-base comparison, which will show changes
* made since the file was copied. But in case we're showing copies as adds,
* we need to compare the copied file to the empty file. If we're doing a git
* diff, and the file was copied, we need to report the file as added and
* diff it against the text base, so that a "copied" git diff header, and
* possibly a diff against the copy source, will be generated for it. */
if ((! base_replace && status == svn_wc__db_status_added) ||
(base_replace && ! eb->ignore_ancestry) ||
((status == svn_wc__db_status_copied ||
status == svn_wc__db_status_moved_here) &&
(eb->show_copies_as_adds || eb->use_git_diff_format)))
{
const char *translated = NULL;
apr_hash_t *pristine_props;
apr_hash_t *actual_props;
const char *actual_mimetype;
apr_array_header_t *propchanges;
/* Get svn:mime-type from ACTUAL props of PATH. */
SVN_ERR(svn_wc__get_actual_props(&actual_props, db, local_abspath,
scratch_pool, scratch_pool));
actual_mimetype = get_prop_mimetype(actual_props);
/* Set the original properties to empty, then compute "changes" from
that. Essentially, all ACTUAL props will be "added". */
pristine_props = apr_hash_make(scratch_pool);
SVN_ERR(svn_prop_diffs(&propchanges, actual_props, pristine_props,
scratch_pool));
SVN_ERR(svn_wc__internal_translated_file(
&translated, local_abspath, db, local_abspath,
SVN_WC_TRANSLATE_TO_NF | SVN_WC_TRANSLATE_USE_GLOBAL_TMP,
eb->cancel_func, eb->cancel_baton,
scratch_pool, scratch_pool));
SVN_ERR(eb->callbacks->file_added(NULL, NULL, NULL, path,
(! eb->show_copies_as_adds &&
eb->use_git_diff_format &&
status != svn_wc__db_status_added) ?
pristine_abspath : empty_file,
translated,
0, revision,
NULL,
actual_mimetype,
original_repos_relpath,
SVN_INVALID_REVNUM, propchanges,
pristine_props, eb->callback_baton,
scratch_pool));
}
else
{
const char *translated = NULL;
apr_hash_t *pristine_props;
const char *pristine_mimetype;
const char *actual_mimetype;
apr_hash_t *actual_props;
apr_array_header_t *propchanges;
svn_boolean_t modified;
/* Here we deal with showing pure modifications. */
SVN_ERR(svn_wc__internal_file_modified_p(&modified, db, local_abspath,
FALSE, scratch_pool));
if (modified)
{
/* Note that this might be the _second_ time we translate
the file, as svn_wc__text_modified_internal_p() might have used a
tmp translated copy too. But what the heck, diff is
already expensive, translating twice for the sake of code
modularity is liveable. */
SVN_ERR(svn_wc__internal_translated_file(
&translated, local_abspath, db, local_abspath,
SVN_WC_TRANSLATE_TO_NF | SVN_WC_TRANSLATE_USE_GLOBAL_TMP,
eb->cancel_func, eb->cancel_baton,
scratch_pool, scratch_pool));
}
/* Get the properties, the svn:mime-type values, and compute the
differences between the two. */
if (base_replace
&& eb->ignore_ancestry)
{
/* We don't want the normal pristine properties (which are
from the WORKING tree). We want the pristines associated
with the BASE tree, which are saved as "revert" props. */
SVN_ERR(svn_wc__db_base_get_props(&pristine_props,
db, local_abspath,
scratch_pool, scratch_pool));
}
else
{
/* We can only fetch the pristine props (from BASE or WORKING) if
the node has not been replaced, or it was copied/moved here. */
SVN_ERR_ASSERT(!replaced
|| status == svn_wc__db_status_copied
|| status == svn_wc__db_status_moved_here);
SVN_ERR(svn_wc__db_read_pristine_props(&pristine_props, db,
local_abspath,
scratch_pool, scratch_pool));
/* baseprops will be NULL for added nodes */
if (!pristine_props)
pristine_props = apr_hash_make(scratch_pool);
}
pristine_mimetype = get_prop_mimetype(pristine_props);
SVN_ERR(svn_wc__db_read_props(&actual_props, db, local_abspath,
scratch_pool, scratch_pool));
actual_mimetype = get_prop_mimetype(actual_props);
SVN_ERR(svn_prop_diffs(&propchanges, actual_props, pristine_props,
scratch_pool));
if (modified || propchanges->nelts > 0)
{
SVN_ERR(eb->callbacks->file_changed(NULL, NULL, NULL,
path,
modified ? pristine_abspath
: NULL,
translated,
revision,
SVN_INVALID_REVNUM,
pristine_mimetype,
actual_mimetype,
propchanges,
pristine_props,
eb->callback_baton,
scratch_pool));
}
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__move2(svn_wc_context_t *wc_ctx,
const char *src_abspath,
const char *dst_abspath,
svn_boolean_t metadata_only,
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_boolean_t move_degraded_to_copy = FALSE;
svn_node_kind_t kind;
svn_boolean_t conflicted;
/* Verify that we have the required write locks. */
SVN_ERR(svn_wc__write_check(wc_ctx->db,
svn_dirent_dirname(src_abspath, scratch_pool),
scratch_pool));
SVN_ERR(svn_wc__write_check(wc_ctx->db,
svn_dirent_dirname(dst_abspath, scratch_pool),
scratch_pool));
SVN_ERR(copy_or_move(&move_degraded_to_copy,
wc_ctx, src_abspath, dst_abspath,
TRUE /* metadata_only */,
TRUE /* is_move */,
allow_mixed_revisions,
cancel_func, cancel_baton,
notify_func, notify_baton,
scratch_pool));
/* An interrupt at this point will leave the new copy marked as
moved-here but the source has not yet been deleted or marked as
moved-to. */
/* Should we be using a workqueue for this move? It's not clear.
What should happen if the copy above is interrupted? The user
may want to abort the move and a workqueue might interfere with
that.
BH: On Windows it is not unlikely to encounter an access denied on
this line. Installing the move in the workqueue via the copy_or_move
might make it hard to recover from that situation, while the DB
is still in a valid state. So be careful when switching this over
to the workqueue. */
if (!metadata_only)
SVN_ERR(svn_io_file_rename(src_abspath, dst_abspath, scratch_pool));
SVN_ERR(svn_wc__db_read_info(NULL, &kind, NULL, NULL, NULL, NULL, 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 (kind == svn_node_dir)
SVN_ERR(remove_all_conflict_markers(db, src_abspath, dst_abspath,
scratch_pool));
if (conflicted)
SVN_ERR(remove_node_conflict_markers(db, src_abspath, dst_abspath,
scratch_pool));
SVN_ERR(svn_wc__db_op_delete(db, src_abspath,
move_degraded_to_copy ? NULL : dst_abspath,
TRUE /* delete_dir_externals */,
NULL /* conflict */, NULL /* work_items */,
cancel_func, cancel_baton,
notify_func, notify_baton,
scratch_pool));
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;
}
svn_error_t *
svn_wc__internal_ensure_adm(svn_wc__db_t *db,
const char *local_abspath,
const char *url,
const char *repos_root_url,
const char *repos_uuid,
svn_revnum_t revision,
svn_depth_t depth,
apr_pool_t *scratch_pool)
{
int format;
const char *repos_relpath;
svn_wc__db_status_t status;
const char *db_repos_relpath, *db_repos_root_url, *db_repos_uuid;
svn_revnum_t db_revision;
SVN_ERR_ASSERT(svn_dirent_is_absolute(local_abspath));
SVN_ERR_ASSERT(url != NULL);
SVN_ERR_ASSERT(repos_root_url != NULL);
SVN_ERR_ASSERT(repos_uuid != NULL);
SVN_ERR_ASSERT(svn_uri__is_ancestor(repos_root_url, url));
SVN_ERR(svn_wc__internal_check_wc(&format, db, local_abspath, TRUE,
scratch_pool));
repos_relpath = svn_uri__is_child(repos_root_url, url, scratch_pool);
if (repos_relpath == NULL)
repos_relpath = "";
/* Early out: we know we're not dealing with an existing wc, so
just create one. */
if (format == 0)
return svn_error_trace(init_adm(db, local_abspath,
repos_relpath, repos_root_url, repos_uuid,
revision, depth, scratch_pool));
SVN_ERR(svn_wc__db_read_info(&status, NULL,
&db_revision, &db_repos_relpath,
&db_repos_root_url, &db_repos_uuid,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL,
NULL, NULL, NULL,
db, local_abspath, scratch_pool, scratch_pool));
/* When the directory exists and is scheduled for deletion or is not-present
* do not check the revision or the URL. The revision can be any
* arbitrary revision and the URL may differ if the add is
* being driven from a merge which will have a different URL. */
if (status != svn_wc__db_status_deleted
&& status != svn_wc__db_status_not_present)
{
/* ### Should we match copyfrom_revision? */
if (db_revision != revision)
return
svn_error_createf(SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
_("Revision %ld doesn't match existing "
"revision %ld in '%s'"),
revision, db_revision, local_abspath);
if (!db_repos_root_url)
{
if (status == svn_wc__db_status_added)
SVN_ERR(svn_wc__db_scan_addition(NULL, NULL,
&db_repos_relpath,
&db_repos_root_url,
&db_repos_uuid,
NULL, NULL, NULL, NULL,
db, local_abspath,
scratch_pool, scratch_pool));
else
SVN_ERR(svn_wc__db_scan_base_repos(&db_repos_relpath,
&db_repos_root_url,
&db_repos_uuid,
db, local_abspath,
scratch_pool, scratch_pool));
}
/* The caller gives us a URL which should match the entry. However,
some callers compensate for an old problem in entry->url and pass
the copyfrom_url instead. See ^/notes/api-errata/wc002.txt. As
a result, we allow the passed URL to match copyfrom_url if it
does not match the entry's primary URL. */
/* ### comparing URLs, should they be canonicalized first? */
if (strcmp(db_repos_uuid, repos_uuid)
|| strcmp(db_repos_root_url, repos_root_url)
|| !svn_relpath__is_ancestor(db_repos_relpath, repos_relpath))
{
const char *copyfrom_root_url, *copyfrom_repos_relpath;
SVN_ERR(svn_wc__internal_get_copyfrom_info(©from_root_url,
©from_repos_relpath,
NULL, NULL, NULL,
db, local_abspath,
scratch_pool,
scratch_pool));
if (copyfrom_root_url == NULL
|| strcmp(copyfrom_root_url, repos_root_url)
|| strcmp(copyfrom_repos_relpath, repos_relpath))
return
svn_error_createf(SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
_("URL '%s' (uuid: '%s') doesn't match existing "
"URL '%s' (uuid: '%s') in '%s'"),
url,
db_repos_uuid,
svn_path_url_add_component2(db_repos_root_url,
db_repos_relpath,
scratch_pool),
repos_uuid,
local_abspath);
}
}
return SVN_NO_ERROR;
}
