static svn_error_t *
start_element(int *elem, void *baton, int parent_state, const char *nspace,
const char *elt_name, const char **atts)
{
replay_baton_t *rb = baton;
const svn_ra_neon__xml_elm_t *elm
= svn_ra_neon__lookup_xml_elem(editor_report_elements, nspace, elt_name);
if (! elm)
{
*elem = NE_XML_DECLINE;
return SVN_NO_ERROR;
}
if (parent_state == ELEM_root)
{
/* If we're at the root of the tree, the element has to be the editor
* report itself. */
if (elm->id != ELEM_editor_report)
return UNEXPECTED_ELEMENT(nspace, elt_name);
}
else if (parent_state != ELEM_editor_report)
{
/* If we're not at the root, our parent has to be the editor report,
* since we don't actually nest any elements. */
return UNEXPECTED_ELEMENT(nspace, elt_name);
}
switch (elm->id)
{
case ELEM_target_revision:
{
const char *crev = svn_xml_get_attr_value("rev", atts);
if (! crev)
return MISSING_ATTR(nspace, elt_name, "rev");
else
return rb->editor->set_target_revision(rb->edit_baton,
SVN_STR_TO_REV(crev),
rb->pool);
}
break;
case ELEM_open_root:
{
const char *crev = svn_xml_get_attr_value("rev", atts);
if (! crev)
return MISSING_ATTR(nspace, elt_name, "rev");
else
{
apr_pool_t *subpool = svn_pool_create(rb->pool);
void *dir_baton;
SVN_ERR(rb->editor->open_root(rb->edit_baton,
SVN_STR_TO_REV(crev), subpool,
&dir_baton));
push_dir(rb, dir_baton, "", subpool);
}
}
break;
case ELEM_delete_entry:
{
const char *path = svn_xml_get_attr_value("name", atts);
const char *crev = svn_xml_get_attr_value("rev", atts);
if (! path)
return MISSING_ATTR(nspace, elt_name, "name");
else if (! crev)
return MISSING_ATTR(nspace, elt_name, "rev");
else
{
dir_item_t *di = &TOP_DIR(rb);
SVN_ERR(rb->editor->delete_entry(path, SVN_STR_TO_REV(crev),
di->baton, di->pool));
}
}
break;
case ELEM_open_directory:
case ELEM_add_directory:
{
const char *crev = svn_xml_get_attr_value("rev", atts);
const char *name = svn_xml_get_attr_value("name", atts);
if (! name)
return MISSING_ATTR(nspace, elt_name, "name");
else
{
dir_item_t *parent = &TOP_DIR(rb);
apr_pool_t *subpool = svn_pool_create(parent->pool);
svn_revnum_t rev;
void *dir_baton;
if (crev)
rev = SVN_STR_TO_REV(crev);
else
rev = SVN_INVALID_REVNUM;
if (elm->id == ELEM_open_directory)
SVN_ERR(rb->editor->open_directory(name, parent->baton,
rev, subpool, &dir_baton));
else if (elm->id == ELEM_add_directory)
{
const char *cpath = svn_xml_get_attr_value("copyfrom-path",
atts);
crev = svn_xml_get_attr_value("copyfrom-rev", atts);
if (crev)
rev = SVN_STR_TO_REV(crev);
else
rev = SVN_INVALID_REVNUM;
SVN_ERR(rb->editor->add_directory(name, parent->baton,
cpath, rev, subpool,
&dir_baton));
}
else
SVN_ERR_MALFUNCTION();
push_dir(rb, dir_baton, name, subpool);
}
}
break;
case ELEM_open_file:
case ELEM_add_file:
{
const char *path = svn_xml_get_attr_value("name", atts);
svn_revnum_t rev;
dir_item_t *parent = &TOP_DIR(rb);
if (! path)
return MISSING_ATTR(nspace, elt_name, "name");
svn_pool_clear(parent->file_pool);
if (elm->id == ELEM_add_file)
{
const char *cpath = svn_xml_get_attr_value("copyfrom-path", atts);
const char *crev = svn_xml_get_attr_value("copyfrom-rev", atts);
if (crev)
rev = SVN_STR_TO_REV(crev);
else
rev = SVN_INVALID_REVNUM;
SVN_ERR(rb->editor->add_file(path, parent->baton, cpath, rev,
parent->file_pool, &rb->file_baton));
}
else
{
const char *crev = svn_xml_get_attr_value("rev", atts);
if (crev)
rev = SVN_STR_TO_REV(crev);
else
rev = SVN_INVALID_REVNUM;
SVN_ERR(rb->editor->open_file(path, parent->baton, rev,
parent->file_pool,
&rb->file_baton));
}
}
break;
case ELEM_apply_textdelta:
if (! rb->file_baton)
return svn_error_create
(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
_("Got apply-textdelta element without preceding "
"add-file or open-file"));
else
{
const char *checksum = svn_xml_get_attr_value("checksum", atts);
SVN_ERR(rb->editor->apply_textdelta(rb->file_baton,
checksum,
TOP_DIR(rb).file_pool,
&rb->whandler,
&rb->whandler_baton));
rb->svndiff_decoder = svn_txdelta_parse_svndiff
(rb->whandler, rb->whandler_baton,
TRUE, TOP_DIR(rb).file_pool);
rb->base64_decoder = svn_base64_decode(rb->svndiff_decoder,
TOP_DIR(rb).file_pool);
}
break;
case ELEM_close_file:
if (! rb->file_baton)
return svn_error_create
(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
_("Got close-file element without preceding "
"add-file or open-file"));
else
{
const char *checksum = svn_xml_get_attr_value("checksum", atts);
SVN_ERR(rb->editor->close_file(rb->file_baton,
checksum,
TOP_DIR(rb).file_pool));
rb->file_baton = NULL;
}
break;
case ELEM_close_directory:
if (rb->dirs->nelts == 0)
return svn_error_create
(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
_("Got close-directory element without ever opening "
"a directory"));
else
{
dir_item_t *di = &TOP_DIR(rb);
SVN_ERR(rb->editor->close_directory(di->baton, di->pool));
svn_pool_destroy(di->pool);
apr_array_pop(rb->dirs);
}
break;
case ELEM_change_file_prop:
case ELEM_change_dir_prop:
{
const char *name = svn_xml_get_attr_value("name", atts);
if (! name)
return MISSING_ATTR(nspace, elt_name, "name");
else
{
svn_pool_clear(rb->prop_pool);
if (svn_xml_get_attr_value("del", atts))
rb->prop_accum = NULL;
else
rb->prop_accum = svn_stringbuf_create_empty(rb->prop_pool);
rb->prop_name = apr_pstrdup(rb->prop_pool, name);
}
}
break;
}
*elem = elm->id;
return SVN_NO_ERROR;
}
SvnClientImpl::~SvnClientImpl()
{
svn_pool_destroy(_pool);
}
static int
l_propget (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
const char *propname = luaL_checkstring (L, 2);
svn_opt_revision_t peg_revision;
svn_opt_revision_t revision;
peg_revision.kind = svn_opt_revision_unspecified;
if (lua_gettop (L) < 3 || lua_isnil (L, 3)) {
revision.kind = svn_opt_revision_unspecified;
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 3);
}
svn_boolean_t recursive = FALSE;
int itable = 4;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
apr_hash_t *props;
const char *propname_utf8;
err = svn_utf_cstring_to_utf8 (&propname_utf8, propname, pool);
IF_ERROR_RETURN (err, pool, L);
err = svn_client_propget2 (&props, propname_utf8, path, &peg_revision, &revision, recursive, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
lua_newtable (L);
const void *key;
void *val;
apr_hash_index_t *hi;
for (hi = apr_hash_first (pool, props); hi; hi = apr_hash_next (hi)) {
apr_hash_this (hi, &key, NULL, &val);
svn_string_t *s = (svn_string_t *) val;
lua_pushstring (L, s->data);
lua_setfield (L, -2, (char *) key);
}
svn_pool_destroy (pool);
return 1;
}
/* Schedule directory DIRNAME, and some of the tree under it, for
* addition with access baton ADM_ACCESS. DEPTH is the depth at this
* point in the descent (it may be changed for recursive calls).
*
* If DIRNAME (or any item below directory DIRNAME) is already scheduled for
* addition, add will fail and return an error unless FORCE is TRUE.
*
* Files and directories that match ignore patterns will not be added unless
* NO_IGNORE is TRUE.
*
* If CTX->CANCEL_FUNC is non-null, call it with CTX->CANCEL_BATON to allow
* the user to cancel the operation
*/
static svn_error_t *
add_dir_recursive(const char *dirname,
svn_wc_adm_access_t *adm_access,
svn_depth_t depth,
svn_boolean_t force,
svn_boolean_t no_ignore,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
apr_dir_t *dir;
apr_finfo_t this_entry;
svn_error_t *err;
apr_pool_t *subpool;
apr_int32_t flags = APR_FINFO_TYPE | APR_FINFO_NAME;
svn_wc_adm_access_t *dir_access;
apr_array_header_t *ignores;
/* Check cancellation; note that this catches recursive calls too. */
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
/* Add this directory to revision control. */
err = svn_wc_add2(dirname, adm_access,
NULL, SVN_INVALID_REVNUM,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2, pool);
if (err && err->apr_err == SVN_ERR_ENTRY_EXISTS && force)
svn_error_clear(err);
else if (err)
return err;
SVN_ERR(svn_wc_adm_retrieve(&dir_access, adm_access, dirname, pool));
if (!no_ignore)
SVN_ERR(svn_wc_get_ignores(&ignores, ctx->config, dir_access, pool));
subpool = svn_pool_create(pool);
SVN_ERR(svn_io_dir_open(&dir, dirname, pool));
/* Read the directory entries one by one and add those things to
version control. */
while (1)
{
const char *fullpath;
svn_pool_clear(subpool);
err = svn_io_dir_read(&this_entry, flags, dir, subpool);
if (err)
{
/* Check if we're done reading the dir's entries. */
if (APR_STATUS_IS_ENOENT(err->apr_err))
{
apr_status_t apr_err;
svn_error_clear(err);
apr_err = apr_dir_close(dir);
if (apr_err)
return svn_error_wrap_apr
(apr_err, _("Can't close directory '%s'"),
svn_path_local_style(dirname, subpool));
break;
}
else
{
return svn_error_createf
(err->apr_err, err,
_("Error during add of '%s'"),
svn_path_local_style(dirname, subpool));
}
}
/* Skip entries for this dir and its parent. */
if (this_entry.name[0] == '.'
&& (this_entry.name[1] == '\0'
|| (this_entry.name[1] == '.' && this_entry.name[2] == '\0')))
continue;
/* Check cancellation so you can cancel during an
* add of a directory with lots of files. */
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
/* Skip over SVN admin directories. */
if (svn_wc_is_adm_dir(this_entry.name, subpool))
continue;
if ((!no_ignore) && svn_wc_match_ignore_list(this_entry.name,
ignores, subpool))
continue;
/* Construct the full path of the entry. */
fullpath = svn_path_join(dirname, this_entry.name, subpool);
/* Recurse on directories; add files; ignore the rest. */
if (this_entry.filetype == APR_DIR && depth >= svn_depth_immediates)
{
svn_depth_t depth_below_here = depth;
if (depth == svn_depth_immediates)
depth_below_here = svn_depth_empty;
SVN_ERR(add_dir_recursive(fullpath, dir_access, depth_below_here,
force, no_ignore, ctx, subpool));
}
else if (this_entry.filetype != APR_UNKFILE
&& this_entry.filetype != APR_DIR
&& depth >= svn_depth_files)
{
err = add_file(fullpath, ctx, dir_access, subpool);
if (err && err->apr_err == SVN_ERR_ENTRY_EXISTS && force)
svn_error_clear(err);
else if (err)
return err;
}
}
/* Opened by svn_wc_add */
SVN_ERR(svn_wc_adm_close(dir_access));
/* Destroy the per-iteration pool. */
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__add(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
apr_array_header_t *targets;
int i;
apr_pool_t *iterpool;
apr_array_header_t *errors = apr_array_make(pool, 0, sizeof(apr_status_t));
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE, pool));
if (! targets->nelts)
return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL);
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_infinity;
SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, pool));
SVN_ERR(svn_cl__check_targets_are_local_paths(targets));
iterpool = svn_pool_create(pool);
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_pool_clear(iterpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
SVN_ERR(svn_cl__try
(svn_client_add4(target,
opt_state->depth,
opt_state->force, opt_state->no_ignore,
opt_state->parents, ctx, iterpool),
errors, opt_state->quiet,
SVN_ERR_ENTRY_EXISTS,
SVN_ERR_WC_PATH_NOT_FOUND,
SVN_NO_ERROR));
}
svn_pool_destroy(iterpool);
if (errors->nelts > 0)
{
svn_error_t *err;
err = svn_error_create(SVN_ERR_ILLEGAL_TARGET, NULL, NULL);
for (i = 0; i < errors->nelts; i++)
{
apr_status_t status = APR_ARRAY_IDX(errors, i, apr_status_t);
if (status == SVN_ERR_WC_PATH_NOT_FOUND)
err = svn_error_quick_wrap(err,
_("Could not add all targets because "
"some targets don't exist"));
else if (status == SVN_ERR_ENTRY_EXISTS)
err = svn_error_quick_wrap(err,
_("Could not add all targets because "
"some targets are already versioned"));
}
return svn_error_trace(err);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_blame5(const char *target,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *start,
const svn_opt_revision_t *end,
const svn_diff_file_options_t *diff_options,
svn_boolean_t ignore_mime_type,
svn_boolean_t include_merged_revisions,
svn_client_blame_receiver3_t receiver,
void *receiver_baton,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
struct file_rev_baton frb;
svn_ra_session_t *ra_session;
svn_revnum_t start_revnum, end_revnum;
svn_client__pathrev_t *end_loc;
struct blame *walk, *walk_merged = NULL;
apr_pool_t *iterpool;
svn_stream_t *last_stream;
svn_stream_t *stream;
const char *target_abspath_or_url;
if (start->kind == svn_opt_revision_unspecified
|| end->kind == svn_opt_revision_unspecified)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL, NULL);
if (svn_path_is_url(target))
target_abspath_or_url = target;
else
SVN_ERR(svn_dirent_get_absolute(&target_abspath_or_url, target, pool));
/* Get an RA plugin for this filesystem object. */
SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &end_loc,
target, NULL, peg_revision, end,
ctx, pool));
end_revnum = end_loc->rev;
SVN_ERR(svn_client__get_revision_number(&start_revnum, NULL, ctx->wc_ctx,
target_abspath_or_url, ra_session,
start, pool));
if (end_revnum < start_revnum)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL,
_("Start revision must precede end revision"));
frb.start_rev = start_revnum;
frb.end_rev = end_revnum;
frb.target = target;
frb.ctx = ctx;
frb.diff_options = diff_options;
frb.ignore_mime_type = ignore_mime_type;
frb.include_merged_revisions = include_merged_revisions;
frb.last_filename = NULL;
frb.last_original_filename = NULL;
frb.chain = apr_palloc(pool, sizeof(*frb.chain));
frb.chain->blame = NULL;
frb.chain->avail = NULL;
frb.chain->pool = pool;
if (include_merged_revisions)
{
frb.merged_chain = apr_palloc(pool, sizeof(*frb.merged_chain));
frb.merged_chain->blame = NULL;
frb.merged_chain->avail = NULL;
frb.merged_chain->pool = pool;
}
SVN_ERR(svn_ra_get_repos_root2(ra_session, &frb.repos_root_url, pool));
frb.mainpool = pool;
/* The callback will flip the following two pools, because it needs
information from the previous call. Obviously, it can't rely on
the lifetime of the pool provided by get_file_revs. */
frb.lastpool = svn_pool_create(pool);
frb.currpool = svn_pool_create(pool);
if (include_merged_revisions)
{
frb.filepool = svn_pool_create(pool);
frb.prevfilepool = svn_pool_create(pool);
}
/* Collect all blame information.
We need to ensure that we get one revision before the start_rev,
if available so that we can know what was actually changed in the start
revision. */
SVN_ERR(svn_ra_get_file_revs2(ra_session, "",
start_revnum - (start_revnum > 0 ? 1 : 0),
end_revnum, include_merged_revisions,
file_rev_handler, &frb, pool));
if (end->kind == svn_opt_revision_working)
{
/* If the local file is modified we have to call the handler on the
working copy file with keywords unexpanded */
svn_wc_status3_t *status;
SVN_ERR(svn_wc_status3(&status, ctx->wc_ctx, target_abspath_or_url, pool,
pool));
if (status->text_status != svn_wc_status_normal)
{
apr_hash_t *props;
svn_stream_t *wcfile;
svn_string_t *keywords;
svn_stream_t *tempfile;
const char *temppath;
apr_hash_t *kw = NULL;
SVN_ERR(svn_wc_prop_list2(&props, ctx->wc_ctx, target_abspath_or_url,
pool, pool));
SVN_ERR(svn_stream_open_readonly(&wcfile, target, pool, pool));
keywords = apr_hash_get(props, SVN_PROP_KEYWORDS,
APR_HASH_KEY_STRING);
if (keywords)
SVN_ERR(svn_subst_build_keywords2(&kw, keywords->data, NULL, NULL,
0, NULL, pool));
wcfile = svn_subst_stream_translated(wcfile, "\n", TRUE, kw, FALSE,
pool);
SVN_ERR(svn_stream_open_unique(&tempfile, &temppath, NULL,
svn_io_file_del_on_pool_cleanup,
pool, pool));
SVN_ERR(svn_stream_copy3(wcfile, tempfile, ctx->cancel_func,
ctx->cancel_baton, pool));
SVN_ERR(add_file_blame(frb.last_filename, temppath, frb.chain, NULL,
frb.diff_options, pool));
frb.last_filename = temppath;
}
}
/* Report the blame to the caller. */
/* The callback has to have been called at least once. */
SVN_ERR_ASSERT(frb.last_filename != NULL);
/* Create a pool for the iteration below. */
iterpool = svn_pool_create(pool);
/* Open the last file and get a stream. */
SVN_ERR(svn_stream_open_readonly(&last_stream, frb.last_filename,
pool, pool));
stream = svn_subst_stream_translated(last_stream,
"\n", TRUE, NULL, FALSE, pool);
/* Perform optional merged chain normalization. */
if (include_merged_revisions)
{
/* If we never created any blame for the original chain, create it now,
with the most recent changed revision. This could occur if a file
was created on a branch and them merged to another branch. This is
semanticly a copy, and we want to use the revision on the branch as
the most recently changed revision. ### Is this really what we want
to do here? Do the sematics of copy change? */
if (!frb.chain->blame)
frb.chain->blame = blame_create(frb.chain, frb.rev, 0);
normalize_blames(frb.chain, frb.merged_chain, pool);
walk_merged = frb.merged_chain->blame;
}
/* Process each blame item. */
for (walk = frb.chain->blame; walk; walk = walk->next)
{
apr_off_t line_no;
svn_revnum_t merged_rev;
const char *merged_path;
apr_hash_t *merged_rev_props;
if (walk_merged)
{
merged_rev = walk_merged->rev->revision;
merged_rev_props = walk_merged->rev->rev_props;
merged_path = walk_merged->rev->path;
}
else
{
merged_rev = SVN_INVALID_REVNUM;
merged_rev_props = NULL;
merged_path = NULL;
}
for (line_no = walk->start;
!walk->next || line_no < walk->next->start;
++line_no)
{
svn_boolean_t eof;
svn_stringbuf_t *sb;
svn_pool_clear(iterpool);
SVN_ERR(svn_stream_readline(stream, &sb, "\n", &eof, iterpool));
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
if (!eof || sb->len)
{
if (walk->rev)
SVN_ERR(receiver(receiver_baton, start_revnum, end_revnum,
line_no, walk->rev->revision,
walk->rev->rev_props, merged_rev,
merged_rev_props, merged_path,
sb->data, FALSE, iterpool));
else
SVN_ERR(receiver(receiver_baton, start_revnum, end_revnum,
line_no, SVN_INVALID_REVNUM,
NULL, SVN_INVALID_REVNUM,
NULL, NULL,
sb->data, TRUE, iterpool));
}
if (eof) break;
}
if (walk_merged)
walk_merged = walk_merged->next;
}
SVN_ERR(svn_stream_close(stream));
svn_pool_destroy(frb.lastpool);
svn_pool_destroy(frb.currpool);
if (include_merged_revisions)
{
svn_pool_destroy(frb.filepool);
svn_pool_destroy(frb.prevfilepool);
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
void
svn_fs_close_root(svn_fs_root_t *root)
{
svn_pool_destroy(root->pool);
}
static gpointer delete_thread (gpointer user_data)
{
struct thread_args *args = user_data;
svn_error_t *err;
apr_array_header_t *paths;
svn_client_ctx_t *ctx = args->ctx;
apr_pool_t *subpool, *pool = args->pool;
TshNotifyDialog *dialog = args->dialog;
gchar **files = args->files;
gint size, i;
gchar *error_str;
#if CHECK_SVN_VERSION_S(1,6)
svn_commit_info_t *commit_info;
gchar *message;
gchar buffer[256];
#endif
g_free (args);
size = files?g_strv_length(files):0;
subpool = svn_pool_create (pool);
if(size)
{
paths = apr_array_make (subpool, size, sizeof (const char *));
for (i = 0; i < size; i++)
{
APR_ARRAY_PUSH (paths, const char *) = files[i];
}
}
else
{
paths = apr_array_make (subpool, 1, sizeof (const char *));
APR_ARRAY_PUSH (paths, const char *) = ""; // current directory
}
#if CHECK_SVN_VERSION_S(1,6)
if ((err = svn_client_delete3(&commit_info, paths, FALSE, FALSE, NULL, ctx, subpool)))
#else /* CHECK_SVN_VERSION(1,7) */
if ((err = svn_client_delete4(paths, FALSE, FALSE, NULL, tsh_commit_func2, dialog, ctx, subpool)))
#endif
{
svn_pool_destroy (subpool);
error_str = tsh_strerror(err);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_threads_enter();
tsh_notify_dialog_add(dialog, _("Failed"), error_str, NULL);
tsh_notify_dialog_done (dialog);
gdk_threads_leave();
G_GNUC_END_IGNORE_DEPRECATIONS
g_free(error_str);
svn_error_clear(err);
tsh_reset_cancel();
return GINT_TO_POINTER (FALSE);
}
#if CHECK_SVN_VERSION_S(1,6)
if(commit_info && SVN_IS_VALID_REVNUM(commit_info->revision))
{
g_snprintf(buffer, 256, _("At revision: %ld"), commit_info->revision);
message = buffer;
}
else
{
message = _("Local delete");
}
#endif
svn_pool_destroy (subpool);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_threads_enter();
#if CHECK_SVN_VERSION_S(1,6)
tsh_notify_dialog_add(dialog, _("Completed"), message, NULL);
#endif
tsh_notify_dialog_done (dialog);
gdk_threads_leave();
G_GNUC_END_IGNORE_DEPRECATIONS
tsh_reset_cancel();
return GINT_TO_POINTER (TRUE);
}
/* This function is the shared guts of add_file() and add_directory(),
which see for the meanings of the parameters. The only extra
parameter here is IS_DIR, which is TRUE when adding a directory,
and FALSE when adding a file. */
static svn_error_t *
add_file_or_directory(const char *path,
void *parent_baton,
const char *copy_path,
svn_revnum_t copy_revision,
svn_boolean_t is_dir,
apr_pool_t *pool,
void **return_baton)
{
struct dir_baton *pb = parent_baton;
struct edit_baton *eb = pb->edit_baton;
apr_pool_t *subpool = svn_pool_create(pool);
svn_boolean_t was_copied = FALSE;
const char *full_path;
full_path = svn_fspath__join(eb->base_path,
svn_relpath_canonicalize(path, pool), pool);
/* Sanity check. */
if (copy_path && (! SVN_IS_VALID_REVNUM(copy_revision)))
return svn_error_createf
(SVN_ERR_FS_GENERAL, NULL,
_("Got source path but no source revision for '%s'"), full_path);
if (copy_path)
{
const char *fs_path;
svn_fs_root_t *copy_root;
svn_node_kind_t kind;
size_t repos_url_len;
svn_repos_authz_access_t required;
/* Copy requires recursive write access to the destination path
and write access to the parent path. */
required = svn_authz_write | (is_dir ? svn_authz_recursive : 0);
SVN_ERR(check_authz(eb, full_path, eb->txn_root,
required, subpool));
SVN_ERR(check_authz(eb, pb->path, eb->txn_root,
svn_authz_write, subpool));
/* Check PATH in our transaction. Make sure it does not exist
unless its parent directory was copied (in which case, the
thing might have been copied in as well), else return an
out-of-dateness error. */
SVN_ERR(svn_fs_check_path(&kind, eb->txn_root, full_path, subpool));
if ((kind != svn_node_none) && (! pb->was_copied))
return out_of_date(full_path, kind);
/* For now, require that the url come from the same repository
that this commit is operating on. */
copy_path = svn_path_uri_decode(copy_path, subpool);
repos_url_len = strlen(eb->repos_url);
if (strncmp(copy_path, eb->repos_url, repos_url_len) != 0)
return svn_error_createf
(SVN_ERR_FS_GENERAL, NULL,
_("Source url '%s' is from different repository"), copy_path);
fs_path = apr_pstrdup(subpool, copy_path + repos_url_len);
/* Now use the "fs_path" as an absolute path within the
repository to make the copy from. */
SVN_ERR(svn_fs_revision_root(©_root, eb->fs,
copy_revision, subpool));
/* Copy also requires (recursive) read access to the source */
required = svn_authz_read | (is_dir ? svn_authz_recursive : 0);
SVN_ERR(check_authz(eb, fs_path, copy_root, required, subpool));
SVN_ERR(svn_fs_copy(copy_root, fs_path,
eb->txn_root, full_path, subpool));
was_copied = TRUE;
}
else
{
/* No ancestry given, just make a new directory or empty file.
Note that we don't perform an existence check here like the
copy-from case does -- that's because svn_fs_make_*()
already errors out if the file already exists. Verify write
access to the full path and to the parent. */
SVN_ERR(check_authz(eb, full_path, eb->txn_root,
svn_authz_write, subpool));
SVN_ERR(check_authz(eb, pb->path, eb->txn_root,
svn_authz_write, subpool));
if (is_dir)
SVN_ERR(svn_fs_make_dir(eb->txn_root, full_path, subpool));
else
SVN_ERR(svn_fs_make_file(eb->txn_root, full_path, subpool));
}
/* Cleanup our temporary subpool. */
svn_pool_destroy(subpool);
/* Build a new child baton. */
if (is_dir)
{
*return_baton = make_dir_baton(eb, pb, full_path, was_copied,
SVN_INVALID_REVNUM, pool);
}
else
{
struct file_baton *new_fb = apr_pcalloc(pool, sizeof(*new_fb));
new_fb->edit_baton = eb;
new_fb->path = full_path;
*return_baton = new_fb;
}
return SVN_NO_ERROR;
}
void
svn_handle_error2(svn_error_t *err,
FILE *stream,
svn_boolean_t fatal,
const char *prefix)
{
/* In a long error chain, there may be multiple errors with the same
error code and no custom message. We only want to print the
default message for that code once; printing it multiple times
would add no useful information. The 'empties' array below
remembers the codes of empty errors already seen in the chain.
We could allocate it in err->pool, but there's no telling how
long err will live or how many times it will get handled. So we
use a subpool. */
apr_pool_t *subpool;
apr_array_header_t *empties;
svn_error_t *tmp_err;
/* ### The rest of this file carefully avoids using svn_pool_*(),
preferring apr_pool_*() instead. I can't remember why -- it may
be an artifact of r3719, or it may be for some deeper reason --
but I'm playing it safe and using apr_pool_*() here too. */
apr_pool_create(&subpool, err->pool);
empties = apr_array_make(subpool, 0, sizeof(apr_status_t));
tmp_err = err;
while (tmp_err)
{
int i;
svn_boolean_t printed_already = FALSE;
if (! tmp_err->message)
{
for (i = 0; i < empties->nelts; i++)
{
if (tmp_err->apr_err == APR_ARRAY_IDX(empties, i, apr_status_t) )
{
printed_already = TRUE;
break;
}
}
}
if (! printed_already)
{
print_error(tmp_err, stream, prefix);
if (! tmp_err->message)
{
APR_ARRAY_PUSH(empties, apr_status_t) = tmp_err->apr_err;
}
}
tmp_err = tmp_err->child;
}
svn_pool_destroy(subpool);
fflush(stream);
if (fatal)
{
/* Avoid abort()s in maintainer mode. */
svn_error_clear(err);
/* We exit(1) here instead of abort()ing so that atexit handlers
get called. */
exit(EXIT_FAILURE);
}
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__propdel(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
const char *pname, *pname_utf8;
apr_array_header_t *args, *targets;
int i;
/* Get the property's name (and a UTF-8 version of that name). */
SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool));
pname = APR_ARRAY_IDX(args, 0, const char *);
SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool));
/* No need to check svn_prop_name_is_valid for *deleting*
properties, and it may even be useful to allow, in case invalid
properties sneaked through somehow. */
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
pool));
/* Add "." if user passed 0 file arguments */
svn_opt_push_implicit_dot_target(targets, pool);
if (opt_state->revprop) /* operate on a revprop */
{
svn_revnum_t rev;
const char *URL;
SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets,
&URL, pool));
/* Let libsvn_client do the real work. */
SVN_ERR(svn_client_revprop_set(pname_utf8, NULL,
URL, &(opt_state->start_revision),
&rev, FALSE, ctx, pool));
if (! opt_state->quiet)
{
SVN_ERR(svn_cmdline_printf(pool,
_("property '%s' deleted from"
" repository revision %ld\n"),
pname_utf8, rev));
}
}
else if (opt_state->start_revision.kind != svn_opt_revision_unspecified)
{
return svn_error_createf
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Cannot specify revision for deleting versioned property '%s'"),
pname);
}
else /* operate on a normal, versioned property (not a revprop) */
{
apr_pool_t *subpool = svn_pool_create(pool);
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
/* For each target, remove the property PNAME. */
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_commit_info_t *commit_info;
svn_boolean_t success;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Pass FALSE for 'skip_checks' because it doesn't matter here,
and opt_state->force doesn't apply to this command anyway. */
SVN_ERR(svn_cl__try(svn_client_propset3
(&commit_info, pname_utf8,
NULL, target,
opt_state->depth,
FALSE, SVN_INVALID_REVNUM,
opt_state->changelists, NULL,
ctx, subpool),
&success, opt_state->quiet,
SVN_ERR_UNVERSIONED_RESOURCE,
SVN_ERR_ENTRY_NOT_FOUND,
SVN_NO_ERROR));
if (success && (! opt_state->quiet))
{
SVN_ERR(svn_cmdline_printf
(subpool,
SVN_DEPTH_IS_RECURSIVE(opt_state->depth)
? _("property '%s' deleted (recursively) from '%s'.\n")
: _("property '%s' deleted from '%s'.\n"),
pname_utf8, svn_path_local_style(target, subpool)));
}
}
svn_pool_destroy(subpool);
}
return SVN_NO_ERROR;
}
/* 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;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__null_blame(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
apr_pool_t *iterpool;
apr_array_header_t *targets;
int i;
svn_boolean_t end_revision_unspecified = FALSE;
svn_boolean_t seen_nonexistent_target = FALSE;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE, pool));
/* Blame needs a file on which to operate. */
if (! targets->nelts)
return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL);
if (opt_state->end_revision.kind == svn_opt_revision_unspecified)
{
if (opt_state->start_revision.kind != svn_opt_revision_unspecified)
{
/* In the case that -rX was specified, we actually want to set the
range to be -r1:X. */
opt_state->end_revision = opt_state->start_revision;
opt_state->start_revision.kind = svn_opt_revision_number;
opt_state->start_revision.value.number = 1;
}
else
end_revision_unspecified = TRUE;
}
if (opt_state->start_revision.kind == svn_opt_revision_unspecified)
{
opt_state->start_revision.kind = svn_opt_revision_number;
opt_state->start_revision.value.number = 1;
}
/* The final conclusion from issue #2431 is that blame info
is client output (unlike 'svn cat' which plainly cats the file),
so the EOL style should be the platform local one.
*/
iterpool = svn_pool_create(pool);
for (i = 0; i < targets->nelts; i++)
{
svn_error_t *err;
const char *target = APR_ARRAY_IDX(targets, i, const char *);
const char *parsed_path;
svn_opt_revision_t peg_revision;
svn_pool_clear(iterpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Check for a peg revision. */
SVN_ERR(svn_opt_parse_path(&peg_revision, &parsed_path, target,
iterpool));
if (end_revision_unspecified)
{
if (peg_revision.kind != svn_opt_revision_unspecified)
opt_state->end_revision = peg_revision;
else if (svn_path_is_url(target))
opt_state->end_revision.kind = svn_opt_revision_head;
else
opt_state->end_revision.kind = svn_opt_revision_working;
}
err = bench_null_blame(parsed_path,
&peg_revision,
&opt_state->start_revision,
&opt_state->end_revision,
opt_state->use_merge_history,
opt_state->quiet,
ctx,
iterpool);
if (err)
{
if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND ||
err->apr_err == SVN_ERR_ENTRY_NOT_FOUND ||
err->apr_err == SVN_ERR_FS_NOT_FILE ||
err->apr_err == SVN_ERR_FS_NOT_FOUND)
{
svn_handle_warning2(stderr, err, "svn: ");
svn_error_clear(err);
err = NULL;
seen_nonexistent_target = TRUE;
}
else
{
return svn_error_trace(err);
}
}
}
svn_pool_destroy(iterpool);
if (seen_nonexistent_target)
return svn_error_create(
SVN_ERR_ILLEGAL_TARGET, NULL,
_("Could not perform blame on all targets because some "
"targets don't exist"));
else
return SVN_NO_ERROR;
}
static svn_error_t *
end_element(void *baton, int state, const char *nspace, const char *elt_name)
{
replay_baton_t *rb = baton;
const svn_ra_neon__xml_elm_t *elm
= svn_ra_neon__lookup_xml_elem(editor_report_elements, nspace, elt_name);
if (! elm)
return SVN_NO_ERROR;
switch (elm->id)
{
case ELEM_editor_report:
if (rb->dirs->nelts)
svn_pool_destroy(APR_ARRAY_IDX(rb->dirs, 0, dir_item_t).pool);
return SVN_NO_ERROR;
break;
case ELEM_apply_textdelta:
SVN_ERR(svn_stream_close(rb->base64_decoder));
rb->whandler = NULL;
rb->whandler_baton = NULL;
rb->svndiff_decoder = NULL;
rb->base64_decoder = NULL;
break;
case ELEM_change_file_prop:
case ELEM_change_dir_prop:
{
const svn_string_t *decoded_value;
if (rb->prop_accum)
{
const svn_string_t *prop;
prop = svn_stringbuf__morph_into_string(rb->prop_accum);
decoded_value = svn_base64_decode_string(prop, rb->prop_pool);
}
else
decoded_value = NULL; /* It's a delete */
if (elm->id == ELEM_change_dir_prop)
SVN_ERR(rb->editor->change_dir_prop(TOP_DIR(rb).baton,
rb->prop_name,
decoded_value,
TOP_DIR(rb).pool));
else
SVN_ERR(rb->editor->change_file_prop(rb->file_baton,
rb->prop_name,
decoded_value,
TOP_DIR(rb).file_pool));
}
break;
default:
break;
}
return SVN_NO_ERROR;
}
/* This implements `svn_log_entry_receiver_t'.
BATON is a `struct log_receiver_baton *'. */
static svn_error_t *
log_receiver(void *baton,
svn_log_entry_t *log_entry,
apr_pool_t *pool)
{
struct log_receiver_baton *lrb = baton;
apr_pool_t *iterpool = svn_pool_create(pool);
SVN_ERR(maybe_send_header(lrb));
if (log_entry->revision == SVN_INVALID_REVNUM)
{
/* If the stack depth is zero, we've seen the last revision, so don't
send it, just return. The footer will be sent later. */
if (lrb->stack_depth == 0)
return SVN_NO_ERROR;
else
lrb->stack_depth--;
}
SVN_ERR(dav_svn__brigade_printf(lrb->bb, lrb->output,
"<S:log-item>" DEBUG_CR "<D:version-name>%ld"
"</D:version-name>" DEBUG_CR,
log_entry->revision));
if (log_entry->revprops)
{
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, log_entry->revprops);
hi != NULL;
hi = apr_hash_next(hi))
{
char *name;
void *val;
const svn_string_t *value;
const char *encoding_str = "";
svn_pool_clear(iterpool);
apr_hash_this(hi, (void *)&name, NULL, &val);
value = val;
/* If the client is okay with us encoding binary (or really,
any non-XML-safe) property values, do so as necessary. */
if (lrb->encode_binary_props)
{
if (! svn_xml_is_xml_safe(value->data, value->len))
{
value = svn_base64_encode_string2(value, TRUE, iterpool);
encoding_str = " encoding=\"base64\"";
}
}
if (strcmp(name, SVN_PROP_REVISION_AUTHOR) == 0)
SVN_ERR(dav_svn__brigade_printf
(lrb->bb, lrb->output,
"<D:creator-displayname%s>%s</D:creator-displayname>"
DEBUG_CR, encoding_str,
apr_xml_quote_string(iterpool, value->data, 0)));
else if (strcmp(name, SVN_PROP_REVISION_DATE) == 0)
/* ### this should be DAV:creation-date, but we need to format
### that date a bit differently */
SVN_ERR(dav_svn__brigade_printf
(lrb->bb, lrb->output,
"<S:date%s>%s</S:date>" DEBUG_CR, encoding_str,
apr_xml_quote_string(iterpool, value->data, 0)));
else if (strcmp(name, SVN_PROP_REVISION_LOG) == 0)
SVN_ERR(dav_svn__brigade_printf
(lrb->bb, lrb->output,
"<D:comment%s>%s</D:comment>" DEBUG_CR, encoding_str,
apr_xml_quote_string(pool,
svn_xml_fuzzy_escape(value->data,
iterpool), 0)));
else
SVN_ERR(dav_svn__brigade_printf
(lrb->bb, lrb->output,
"<S:revprop name=\"%s\"%s>%s</S:revprop>" DEBUG_CR,
apr_xml_quote_string(iterpool, name, 0), encoding_str,
apr_xml_quote_string(iterpool, value->data, 0)));
}
}
if (log_entry->has_children)
{
SVN_ERR(dav_svn__brigade_puts(lrb->bb, lrb->output, "<S:has-children/>"));
lrb->stack_depth++;
}
if (log_entry->subtractive_merge)
SVN_ERR(dav_svn__brigade_puts(lrb->bb, lrb->output,
"<S:subtractive-merge/>"));
if (log_entry->changed_paths2)
{
apr_hash_index_t *hi;
char *path;
for (hi = apr_hash_first(pool, log_entry->changed_paths2);
hi != NULL;
hi = apr_hash_next(hi))
{
void *val;
svn_log_changed_path2_t *log_item;
const char *close_element = NULL;
svn_pool_clear(iterpool);
apr_hash_this(hi, (void *) &path, NULL, &val);
log_item = val;
/* ### todo: is there a D: namespace equivalent for
`changed-path'? Should use it if so. */
switch (log_item->action)
{
case 'A':
if (log_item->copyfrom_path
&& SVN_IS_VALID_REVNUM(log_item->copyfrom_rev))
SVN_ERR(dav_svn__brigade_printf
(lrb->bb, lrb->output,
"<S:added-path copyfrom-path=\"%s\""
" copyfrom-rev=\"%ld\"",
apr_xml_quote_string(iterpool,
log_item->copyfrom_path,
1), /* escape quotes */
log_item->copyfrom_rev));
else
SVN_ERR(dav_svn__brigade_puts(lrb->bb, lrb->output,
"<S:added-path"));
close_element = "S:added-path";
break;
case 'R':
if (log_item->copyfrom_path
&& SVN_IS_VALID_REVNUM(log_item->copyfrom_rev))
SVN_ERR(dav_svn__brigade_printf
(lrb->bb, lrb->output,
"<S:replaced-path copyfrom-path=\"%s\""
" copyfrom-rev=\"%ld\"",
apr_xml_quote_string(iterpool,
log_item->copyfrom_path,
1), /* escape quotes */
log_item->copyfrom_rev));
else
SVN_ERR(dav_svn__brigade_puts(lrb->bb, lrb->output,
"<S:replaced-path"));
close_element = "S:replaced-path";
break;
case 'D':
SVN_ERR(dav_svn__brigade_puts(lrb->bb, lrb->output,
"<S:deleted-path"));
close_element = "S:deleted-path";
break;
case 'M':
SVN_ERR(dav_svn__brigade_puts(lrb->bb, lrb->output,
"<S:modified-path"));
close_element = "S:modified-path";
break;
default:
break;
}
/* If we need to close the element, then send the attributes
that apply to all changed items and then close the element. */
if (close_element)
SVN_ERR(dav_svn__brigade_printf
(lrb->bb, lrb->output,
" node-kind=\"%s\""
" text-mods=\"%s\""
" prop-mods=\"%s\">%s</%s>" DEBUG_CR,
svn_node_kind_to_word(log_item->node_kind),
svn_tristate__to_word(log_item->text_modified),
svn_tristate__to_word(log_item->props_modified),
apr_xml_quote_string(iterpool, path, 0),
close_element));
}
}
svn_pool_destroy(iterpool);
SVN_ERR(dav_svn__brigade_puts(lrb->bb, lrb->output,
"</S:log-item>" DEBUG_CR));
return SVN_NO_ERROR;
}
SVNAuthData::~SVNAuthData(void)
{
svn_error_clear(Err);
svn_pool_destroy(m_pool); // free the allocated memory
}
svn_error_t *
svn_nls_init(void)
{
svn_error_t *err = SVN_NO_ERROR;
#ifdef ENABLE_NLS
if (getenv("SVN_LOCALE_DIR"))
{
bindtextdomain(PACKAGE_NAME, getenv("SVN_LOCALE_DIR"));
}
else
{
#ifdef WIN32
WCHAR ucs2_path[MAX_PATH];
char* utf8_path;
const char* internal_path;
apr_pool_t* pool;
apr_size_t inwords, outbytes, outlength;
apr_pool_create(&pool, 0);
/* get exe name - our locale info will be in '../share/locale' */
inwords = GetModuleFileNameW(0, ucs2_path,
sizeof(ucs2_path) / sizeof(ucs2_path[0]));
if (! inwords)
{
/* We must be on a Win9x machine, so attempt to get an ANSI path,
and convert it to Unicode. */
CHAR ansi_path[MAX_PATH];
if (GetModuleFileNameA(0, ansi_path, sizeof(ansi_path)))
{
inwords =
MultiByteToWideChar(CP_ACP, 0, ansi_path, -1, ucs2_path,
sizeof(ucs2_path) / sizeof(ucs2_path[0]));
if (! inwords)
{
err =
svn_error_createf(APR_EINVAL, NULL,
_("Can't convert string to UCS-2: '%s'"),
ansi_path);
}
}
else
{
err = svn_error_create(APR_EINVAL, NULL,
_("Can't get module file name"));
}
}
if (! err)
{
outbytes = outlength = 3 * (inwords + 1);
utf8_path = apr_palloc(pool, outlength);
outbytes = WideCharToMultiByte(CP_UTF8, 0, ucs2_path, inwords,
utf8_path, outbytes, NULL, NULL);
if (outbytes == 0)
{
err = svn_error_wrap_apr(apr_get_os_error(),
_("Can't convert module path "
"to UTF-8 from UCS-2: '%s'"),
ucs2_path);
}
else
{
utf8_path[outlength - outbytes] = '\0';
internal_path = svn_dirent_internal_style(utf8_path, pool);
/* get base path name */
internal_path = svn_dirent_dirname(internal_path, pool);
internal_path = svn_dirent_join(internal_path,
SVN_LOCALE_RELATIVE_PATH,
pool);
bindtextdomain(PACKAGE_NAME, internal_path);
}
}
svn_pool_destroy(pool);
}
#else /* ! WIN32 */
bindtextdomain(PACKAGE_NAME, SVN_LOCALE_DIR);
}
/* 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;
}
/* ### FIXME: Consider somehow sharing code with
### svnrdump/load_editor.c:renumber_mergeinfo_revs() */
static svn_error_t *
renumber_mergeinfo_revs(svn_string_t **final_val,
const svn_string_t *initial_val,
struct revision_baton *rb,
apr_pool_t *pool)
{
apr_pool_t *subpool = svn_pool_create(pool);
svn_mergeinfo_t mergeinfo, predates_stream_mergeinfo;
svn_mergeinfo_t final_mergeinfo = apr_hash_make(subpool);
apr_hash_index_t *hi;
SVN_ERR(svn_mergeinfo_parse(&mergeinfo, initial_val->data, subpool));
/* Issue #3020
http://subversion.tigris.org/issues/show_bug.cgi?id=3020#desc16
Remove mergeinfo older than the oldest revision in the dump stream
and adjust its revisions by the difference between the head rev of
the target repository and the current dump stream rev. */
if (rb->pb->oldest_old_rev > 1)
{
SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
&predates_stream_mergeinfo, mergeinfo,
rb->pb->oldest_old_rev - 1, 0,
TRUE, subpool, subpool));
SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
&mergeinfo, mergeinfo,
rb->pb->oldest_old_rev - 1, 0,
FALSE, subpool, subpool));
SVN_ERR(svn_mergeinfo__adjust_mergeinfo_rangelists(
&predates_stream_mergeinfo, predates_stream_mergeinfo,
-rb->rev_offset, subpool, subpool));
}
else
{
predates_stream_mergeinfo = NULL;
}
for (hi = apr_hash_first(subpool, mergeinfo); hi; hi = apr_hash_next(hi))
{
const char *merge_source;
svn_rangelist_t *rangelist;
struct parse_baton *pb = rb->pb;
int i;
const void *key;
void *val;
apr_hash_this(hi, &key, NULL, &val);
merge_source = key;
rangelist = val;
/* Possibly renumber revisions in merge source's rangelist. */
for (i = 0; i < rangelist->nelts; i++)
{
svn_revnum_t rev_from_map;
svn_merge_range_t *range = APR_ARRAY_IDX(rangelist, i,
svn_merge_range_t *);
rev_from_map = get_revision_mapping(pb->rev_map, range->start);
if (SVN_IS_VALID_REVNUM(rev_from_map))
{
range->start = rev_from_map;
}
else if (range->start == pb->oldest_old_rev - 1)
{
/* Since the start revision of svn_merge_range_t are not
inclusive there is one possible valid start revision that
won't be found in the PB->REV_MAP mapping of load stream
revsions to loaded revisions: The revision immediately
preceeding the oldest revision from the load stream.
This is a valid revision for mergeinfo, but not a valid
copy from revision (which PB->REV_MAP also maps for) so it
will never be in the mapping.
If that is what we have here, then find the mapping for the
oldest rev from the load stream and subtract 1 to get the
renumbered, non-inclusive, start revision. */
rev_from_map = get_revision_mapping(pb->rev_map,
pb->oldest_old_rev);
if (SVN_IS_VALID_REVNUM(rev_from_map))
range->start = rev_from_map - 1;
}
else
{
/* If we can't remap the start revision then don't even bother
trying to remap the end revision. It's possible we might
actually succeed at the latter, which can result in invalid
mergeinfo with a start rev > end rev. If that gets into the
repository then a world of bustage breaks loose anytime that
bogus mergeinfo is parsed. See
http://subversion.tigris.org/issues/show_bug.cgi?id=3020#desc16.
*/
continue;
}
rev_from_map = get_revision_mapping(pb->rev_map, range->end);
if (SVN_IS_VALID_REVNUM(rev_from_map))
range->end = rev_from_map;
}
svn_hash_sets(final_mergeinfo, merge_source, rangelist);
}
if (predates_stream_mergeinfo)
SVN_ERR(svn_mergeinfo_merge2(final_mergeinfo, predates_stream_mergeinfo,
subpool, subpool));
SVN_ERR(svn_mergeinfo__canonicalize_ranges(final_mergeinfo, subpool));
SVN_ERR(svn_mergeinfo_to_string(final_val, final_mergeinfo, pool));
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* Copy a packed shard containing revision REV, and which contains
* MAX_FILES_PER_DIR revisions, from SRC_FS to DST_FS.
* Update *DST_MIN_UNPACKED_REV in case the shard is new in DST_FS.
* Do not re-copy data which already exists in DST_FS.
* Set *SKIPPED_P to FALSE only if at least one part of the shard
* was copied, do not change the value in *SKIPPED_P otherwise.
* SKIPPED_P may be NULL if not required.
* Use SCRATCH_POOL for temporary allocations. */
static svn_error_t *
hotcopy_copy_packed_shard(svn_boolean_t *skipped_p,
svn_revnum_t *dst_min_unpacked_rev,
svn_fs_t *src_fs,
svn_fs_t *dst_fs,
svn_revnum_t rev,
int max_files_per_dir,
apr_pool_t *scratch_pool)
{
const char *src_subdir;
const char *dst_subdir;
const char *packed_shard;
const char *src_subdir_packed_shard;
svn_revnum_t revprop_rev;
apr_pool_t *iterpool;
fs_fs_data_t *src_ffd = src_fs->fsap_data;
/* Copy the packed shard. */
src_subdir = svn_dirent_join(src_fs->path, PATH_REVS_DIR, scratch_pool);
dst_subdir = svn_dirent_join(dst_fs->path, PATH_REVS_DIR, scratch_pool);
packed_shard = apr_psprintf(scratch_pool, "%ld" PATH_EXT_PACKED_SHARD,
rev / max_files_per_dir);
src_subdir_packed_shard = svn_dirent_join(src_subdir, packed_shard,
scratch_pool);
SVN_ERR(hotcopy_io_copy_dir_recursively(skipped_p, src_subdir_packed_shard,
dst_subdir, packed_shard,
TRUE /* copy_perms */,
NULL /* cancel_func */, NULL,
scratch_pool));
/* Copy revprops belonging to revisions in this pack. */
src_subdir = svn_dirent_join(src_fs->path, PATH_REVPROPS_DIR, scratch_pool);
dst_subdir = svn_dirent_join(dst_fs->path, PATH_REVPROPS_DIR, scratch_pool);
if ( src_ffd->format < SVN_FS_FS__MIN_PACKED_REVPROP_FORMAT
|| src_ffd->min_unpacked_rev < rev + max_files_per_dir)
{
/* copy unpacked revprops rev by rev */
iterpool = svn_pool_create(scratch_pool);
for (revprop_rev = rev;
revprop_rev < rev + max_files_per_dir;
revprop_rev++)
{
svn_pool_clear(iterpool);
SVN_ERR(hotcopy_copy_shard_file(skipped_p, src_subdir, dst_subdir,
revprop_rev, max_files_per_dir,
iterpool));
}
svn_pool_destroy(iterpool);
}
else
{
/* revprop for revision 0 will never be packed */
if (rev == 0)
SVN_ERR(hotcopy_copy_shard_file(skipped_p, src_subdir, dst_subdir,
0, max_files_per_dir,
scratch_pool));
/* packed revprops folder */
packed_shard = apr_psprintf(scratch_pool, "%ld" PATH_EXT_PACKED_SHARD,
rev / max_files_per_dir);
src_subdir_packed_shard = svn_dirent_join(src_subdir, packed_shard,
scratch_pool);
SVN_ERR(hotcopy_io_copy_dir_recursively(skipped_p,
src_subdir_packed_shard,
dst_subdir, packed_shard,
TRUE /* copy_perms */,
NULL /* cancel_func */, NULL,
scratch_pool));
}
/* If necessary, update the min-unpacked rev file in the hotcopy. */
if (*dst_min_unpacked_rev < rev + max_files_per_dir)
{
*dst_min_unpacked_rev = rev + max_files_per_dir;
SVN_ERR(svn_fs_fs__write_min_unpacked_rev(dst_fs,
*dst_min_unpacked_rev,
scratch_pool));
}
return SVN_NO_ERROR;
}
/* Apply WINDOW to the streams given by APPL. */
static svn_error_t *
apply_window(svn_txdelta_window_t *window, void *baton)
{
struct apply_baton *ab = (struct apply_baton *) baton;
apr_size_t len;
svn_error_t *err;
if (window == NULL)
{
/* We're done; just clean up. */
if (ab->result_digest)
apr_md5_final(ab->result_digest, &(ab->md5_context));
err = svn_stream_close(ab->target);
svn_pool_destroy(ab->pool);
return err;
}
/* Make sure the source view didn't slide backwards. */
SVN_ERR_ASSERT(window->sview_len == 0
|| (window->sview_offset >= ab->sbuf_offset
&& (window->sview_offset + window->sview_len
>= ab->sbuf_offset + ab->sbuf_len)));
/* Make sure there's enough room in the target buffer. */
SVN_ERR(size_buffer(&ab->tbuf, &ab->tbuf_size, window->tview_len, ab->pool));
/* Prepare the source buffer for reading from the input stream. */
if (window->sview_offset != ab->sbuf_offset
|| window->sview_len > ab->sbuf_size)
{
char *old_sbuf = ab->sbuf;
/* Make sure there's enough room. */
SVN_ERR(size_buffer(&ab->sbuf, &ab->sbuf_size, window->sview_len,
ab->pool));
/* If the existing view overlaps with the new view, copy the
* overlap to the beginning of the new buffer. */
if (ab->sbuf_offset + ab->sbuf_len > window->sview_offset)
{
apr_size_t start =
(apr_size_t)(window->sview_offset - ab->sbuf_offset);
memmove(ab->sbuf, old_sbuf + start, ab->sbuf_len - start);
ab->sbuf_len -= start;
}
else
ab->sbuf_len = 0;
ab->sbuf_offset = window->sview_offset;
}
/* Read the remainder of the source view into the buffer. */
if (ab->sbuf_len < window->sview_len)
{
len = window->sview_len - ab->sbuf_len;
err = svn_stream_read(ab->source, ab->sbuf + ab->sbuf_len, &len);
if (err == SVN_NO_ERROR && len != window->sview_len - ab->sbuf_len)
err = svn_error_create(SVN_ERR_INCOMPLETE_DATA, NULL,
"Delta source ended unexpectedly");
if (err != SVN_NO_ERROR)
return err;
ab->sbuf_len = window->sview_len;
}
/* Apply the window instructions to the source view to generate
the target view. */
len = window->tview_len;
svn_txdelta_apply_instructions(window, ab->sbuf, ab->tbuf, &len);
SVN_ERR_ASSERT(len == window->tview_len);
/* Write out the output. */
/* ### We've also considered just adding two (optionally null)
arguments to svn_stream_create(): read_checksum and
write_checksum. Then instead of every caller updating an md5
context when it calls svn_stream_write() or svn_stream_read(),
streams would do it automatically, and verify the checksum in
svn_stream_closed(). But this might be overkill for issue #689;
so for now we just update the context here. */
if (ab->result_digest)
apr_md5_update(&(ab->md5_context), ab->tbuf, len);
return svn_stream_write(ab->target, ab->tbuf, &len);
}
/* Copy the revision and revprop files (possibly sharded / packed) from
* SRC_FS to DST_FS. Do not re-copy data which already exists in DST_FS.
* When copying packed or unpacked shards, checkpoint the result in DST_FS
* for every shard by updating the 'current' file if necessary. Assume
* the >= SVN_FS_FS__MIN_NO_GLOBAL_IDS_FORMAT filesystem format without
* global next-ID counters. Indicate progress via the optional NOTIFY_FUNC
* callback using NOTIFY_BATON. Use POOL for temporary allocations.
*/
static svn_error_t *
hotcopy_revisions(svn_fs_t *src_fs,
svn_fs_t *dst_fs,
svn_revnum_t src_youngest,
svn_revnum_t dst_youngest,
svn_boolean_t incremental,
const char *src_revs_dir,
const char *dst_revs_dir,
const char *src_revprops_dir,
const char *dst_revprops_dir,
svn_fs_hotcopy_notify_t notify_func,
void* notify_baton,
svn_cancel_func_t cancel_func,
void* cancel_baton,
apr_pool_t *pool)
{
fs_fs_data_t *src_ffd = src_fs->fsap_data;
fs_fs_data_t *dst_ffd = dst_fs->fsap_data;
int max_files_per_dir = src_ffd->max_files_per_dir;
svn_revnum_t src_min_unpacked_rev;
svn_revnum_t dst_min_unpacked_rev;
svn_revnum_t rev;
apr_pool_t *iterpool;
/* Copy the min unpacked rev, and read its value. */
if (src_ffd->format >= SVN_FS_FS__MIN_PACKED_FORMAT)
{
SVN_ERR(svn_fs_fs__read_min_unpacked_rev(&src_min_unpacked_rev,
src_fs, pool));
SVN_ERR(svn_fs_fs__read_min_unpacked_rev(&dst_min_unpacked_rev,
dst_fs, pool));
/* We only support packs coming from the hotcopy source.
* The destination should not be packed independently from
* the source. This also catches the case where users accidentally
* swap the source and destination arguments. */
if (src_min_unpacked_rev < dst_min_unpacked_rev)
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("The hotcopy destination already contains "
"more packed revisions (%lu) than the "
"hotcopy source contains (%lu)"),
dst_min_unpacked_rev - 1,
src_min_unpacked_rev - 1);
SVN_ERR(svn_io_dir_file_copy(src_fs->path, dst_fs->path,
PATH_MIN_UNPACKED_REV, pool));
}
else
{
src_min_unpacked_rev = 0;
dst_min_unpacked_rev = 0;
}
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/*
* Copy the necessary rev files.
*/
iterpool = svn_pool_create(pool);
/* First, copy packed shards. */
for (rev = 0; rev < src_min_unpacked_rev; rev += max_files_per_dir)
{
svn_boolean_t skipped = TRUE;
svn_revnum_t pack_end_rev;
svn_pool_clear(iterpool);
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Copy the packed shard. */
SVN_ERR(hotcopy_copy_packed_shard(&skipped, &dst_min_unpacked_rev,
src_fs, dst_fs,
rev, max_files_per_dir,
iterpool));
pack_end_rev = rev + max_files_per_dir - 1;
/* Whenever this pack did not previously exist in the destination,
* update 'current' to the most recent packed rev (so readers can see
* new revisions which arrived in this pack). */
if (pack_end_rev > dst_youngest)
{
SVN_ERR(svn_fs_fs__write_current(dst_fs, pack_end_rev, 0, 0,
iterpool));
}
/* When notifying about packed shards, make things simpler by either
* reporting a full revision range, i.e [pack start, pack end] or
* reporting nothing. There is one case when this approach might not
* be exact (incremental hotcopy with a pack replacing last unpacked
* revisions), but generally this is good enough. */
if (notify_func && !skipped)
notify_func(notify_baton, rev, pack_end_rev, iterpool);
/* Remove revision files which are now packed. */
if (incremental)
{
SVN_ERR(hotcopy_remove_rev_files(dst_fs, rev,
rev + max_files_per_dir,
max_files_per_dir, iterpool));
if (dst_ffd->format >= SVN_FS_FS__MIN_PACKED_REVPROP_FORMAT)
SVN_ERR(hotcopy_remove_revprop_files(dst_fs, rev,
rev + max_files_per_dir,
max_files_per_dir,
iterpool));
}
/* Now that all revisions have moved into the pack, the original
* rev dir can be removed. */
SVN_ERR(remove_folder(svn_fs_fs__path_rev_shard(dst_fs, rev, iterpool),
cancel_func, cancel_baton, iterpool));
if (rev > 0 && dst_ffd->format >= SVN_FS_FS__MIN_PACKED_REVPROP_FORMAT)
SVN_ERR(remove_folder(svn_fs_fs__path_revprops_shard(dst_fs, rev,
iterpool),
cancel_func, cancel_baton, iterpool));
}
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
SVN_ERR_ASSERT(rev == src_min_unpacked_rev);
SVN_ERR_ASSERT(src_min_unpacked_rev == dst_min_unpacked_rev);
/* Now, copy pairs of non-packed revisions and revprop files.
* If necessary, update 'current' after copying all files from a shard. */
for (; rev <= src_youngest; rev++)
{
svn_boolean_t skipped = TRUE;
svn_pool_clear(iterpool);
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Copying non-packed revisions is racy in case the source repository is
* being packed concurrently with this hotcopy operation. The race can
* happen with FS formats prior to SVN_FS_FS__MIN_PACK_LOCK_FORMAT that
* support packed revisions. With the pack lock, however, the race is
* impossible, because hotcopy and pack operations block each other.
*
* We assume that all revisions coming after 'min-unpacked-rev' really
* are unpacked and that's not necessarily true with concurrent packing.
* Don't try to be smart in this edge case, because handling it properly
* might require copying *everything* from the start. Just abort the
* hotcopy with an ENOENT (revision file moved to a pack, so it is no
* longer where we expect it to be). */
/* Copy the rev file. */
SVN_ERR(hotcopy_copy_shard_file(&skipped,
src_revs_dir, dst_revs_dir, rev,
max_files_per_dir,
iterpool));
/* Copy the revprop file. */
SVN_ERR(hotcopy_copy_shard_file(&skipped,
src_revprops_dir, dst_revprops_dir,
rev, max_files_per_dir,
iterpool));
/* Whenever this revision did not previously exist in the destination,
* checkpoint the progress via 'current' (do that once per full shard
* in order not to slow things down). */
if (rev > dst_youngest)
{
if (max_files_per_dir && (rev % max_files_per_dir == 0))
{
SVN_ERR(svn_fs_fs__write_current(dst_fs, rev, 0, 0,
iterpool));
}
}
if (notify_func && !skipped)
notify_func(notify_baton, rev, rev, iterpool);
}
svn_pool_destroy(iterpool);
/* We assume that all revisions were copied now, i.e. we didn't exit the
* above loop early. 'rev' was last incremented during exit of the loop. */
SVN_ERR_ASSERT(rev == src_youngest + 1);
return SVN_NO_ERROR;
}
static svn_error_t *
mkdir_urls(svn_commit_info_t **commit_info_p,
const apr_array_header_t *urls,
svn_boolean_t make_parents,
const apr_hash_t *revprop_table,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_ra_session_t *ra_session = NULL;
const svn_delta_editor_t *editor;
void *edit_baton;
void *commit_baton;
const char *log_msg;
apr_array_header_t *targets;
apr_hash_t *targets_hash;
apr_hash_t *commit_revprops;
svn_error_t *err;
const char *common;
int i;
/* Find any non-existent parent directories */
if (make_parents)
{
apr_array_header_t *all_urls = apr_array_make(pool, urls->nelts,
sizeof(const char *));
const char *first_url = APR_ARRAY_IDX(urls, 0, const char *);
apr_pool_t *iterpool = svn_pool_create(pool);
SVN_ERR(svn_client__open_ra_session_internal(&ra_session, first_url,
NULL, NULL, NULL, FALSE,
TRUE, ctx, pool));
for (i = 0; i < urls->nelts; i++)
{
const char *url = APR_ARRAY_IDX(urls, i, const char *);
svn_pool_clear(iterpool);
SVN_ERR(add_url_parents(ra_session, url, all_urls, iterpool, pool));
}
svn_pool_destroy(iterpool);
urls = all_urls;
}
/* Condense our list of mkdir targets. */
SVN_ERR(svn_path_condense_targets(&common, &targets, urls, FALSE, pool));
SVN_ERR(svn_hash_from_cstring_keys(&targets_hash, targets, pool));
SVN_ERR(svn_hash_keys(&targets, targets_hash, pool));
if (! targets->nelts)
{
const char *bname;
svn_path_split(common, &common, &bname, pool);
APR_ARRAY_PUSH(targets, const char *) = bname;
}
else
{
svn_boolean_t resplit = FALSE;
/* We can't "mkdir" the root of an editor drive, so if one of
our targets is the empty string, we need to back everything
up by a path component. */
for (i = 0; i < targets->nelts; i++)
{
const char *path = APR_ARRAY_IDX(targets, i, const char *);
if (! *path)
{
resplit = TRUE;
break;
}
}
if (resplit)
{
const char *bname;
svn_path_split(common, &common, &bname, pool);
for (i = 0; i < targets->nelts; i++)
{
const char *path = APR_ARRAY_IDX(targets, i, const char *);
path = svn_path_join(bname, path, pool);
APR_ARRAY_IDX(targets, i, const char *) = path;
}
}
}
qsort(targets->elts, targets->nelts, targets->elt_size,
svn_sort_compare_paths);
/* Create new commit items and add them to the array. */
if (SVN_CLIENT__HAS_LOG_MSG_FUNC(ctx))
{
svn_client_commit_item3_t *item;
const char *tmp_file;
apr_array_header_t *commit_items
= apr_array_make(pool, targets->nelts, sizeof(item));
for (i = 0; i < targets->nelts; i++)
{
const char *path = APR_ARRAY_IDX(targets, i, const char *);
SVN_ERR(svn_client_commit_item_create
((const svn_client_commit_item3_t **) &item, pool));
item->url = svn_path_join(common, path, pool);
item->state_flags = SVN_CLIENT_COMMIT_ITEM_ADD;
APR_ARRAY_PUSH(commit_items, svn_client_commit_item3_t *) = item;
}
SVN_ERR(svn_client__get_log_msg(&log_msg, &tmp_file, commit_items,
ctx, pool));
if (! log_msg)
return SVN_NO_ERROR;
}
else
/* Getting a directory's entries */
static svn_error_t *
svn_ra_local__get_dir(svn_ra_session_t *session,
apr_hash_t **dirents,
svn_revnum_t *fetched_rev,
apr_hash_t **props,
const char *path,
svn_revnum_t revision,
apr_uint32_t dirent_fields,
apr_pool_t *pool)
{
svn_fs_root_t *root;
svn_revnum_t youngest_rev;
apr_hash_t *entries;
apr_hash_index_t *hi;
svn_ra_local__session_baton_t *sess = session->priv;
apr_pool_t *subpool;
const char *abs_path = svn_path_join(sess->fs_path->data, path, pool);
/* Open the revision's root. */
if (! SVN_IS_VALID_REVNUM(revision))
{
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, sess->fs, pool));
SVN_ERR(svn_fs_revision_root(&root, sess->fs, youngest_rev, pool));
if (fetched_rev != NULL)
*fetched_rev = youngest_rev;
}
else
SVN_ERR(svn_fs_revision_root(&root, sess->fs, revision, pool));
if (dirents)
{
/* Get the dir's entries. */
SVN_ERR(svn_fs_dir_entries(&entries, root, abs_path, pool));
/* Loop over the fs dirents, and build a hash of general
svn_dirent_t's. */
*dirents = apr_hash_make(pool);
subpool = svn_pool_create(pool);
for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_t *prophash;
const char *datestring, *entryname, *fullpath;
svn_fs_dirent_t *fs_entry;
svn_dirent_t *entry = apr_pcalloc(pool, sizeof(*entry));
svn_pool_clear(subpool);
apr_hash_this(hi, &key, NULL, &val);
entryname = (const char *) key;
fs_entry = (svn_fs_dirent_t *) val;
fullpath = svn_path_join(abs_path, entryname, subpool);
if (dirent_fields & SVN_DIRENT_KIND)
{
/* node kind */
entry->kind = fs_entry->kind;
}
if (dirent_fields & SVN_DIRENT_SIZE)
{
/* size */
if (entry->kind == svn_node_dir)
entry->size = 0;
else
SVN_ERR(svn_fs_file_length(&(entry->size), root,
fullpath, subpool));
}
if (dirent_fields & SVN_DIRENT_HAS_PROPS)
{
/* has_props? */
SVN_ERR(svn_fs_node_proplist(&prophash, root, fullpath,
subpool));
entry->has_props = (apr_hash_count(prophash) != 0);
}
if ((dirent_fields & SVN_DIRENT_TIME)
|| (dirent_fields & SVN_DIRENT_LAST_AUTHOR)
|| (dirent_fields & SVN_DIRENT_CREATED_REV))
{
/* created_rev & friends */
SVN_ERR(svn_repos_get_committed_info(&(entry->created_rev),
&datestring,
&(entry->last_author),
root, fullpath, subpool));
if (datestring)
SVN_ERR(svn_time_from_cstring(&(entry->time), datestring,
pool));
if (entry->last_author)
entry->last_author = apr_pstrdup(pool, entry->last_author);
}
/* Store. */
apr_hash_set(*dirents, entryname, APR_HASH_KEY_STRING, entry);
}
svn_pool_destroy(subpool);
}
/* Handle props if requested. */
if (props)
SVN_ERR(get_node_props(props, sess, root, abs_path, pool));
return SVN_NO_ERROR;
}
/* Helper func for recursively fetching svn_dirent_t's from a remote
directory and pushing them at an info-receiver callback.
DEPTH is the depth starting at DIR, even though RECEIVER is never
invoked on DIR: if DEPTH is svn_depth_immediates, then invoke
RECEIVER on all children of DIR, but none of their children; if
svn_depth_files, then invoke RECEIVER on file children of DIR but
not on subdirectories; if svn_depth_infinity, recurse fully.
*/
static svn_error_t *
push_dir_info(svn_ra_session_t *ra_session,
const char *session_URL,
const char *dir,
svn_revnum_t rev,
const char *repos_UUID,
const char *repos_root,
svn_info_receiver_t receiver,
void *receiver_baton,
svn_depth_t depth,
svn_client_ctx_t *ctx,
apr_hash_t *locks,
apr_pool_t *pool)
{
apr_hash_t *tmpdirents;
svn_dirent_t *the_ent;
svn_info_t *info;
apr_hash_index_t *hi;
apr_pool_t *subpool = svn_pool_create(pool);
SVN_ERR(svn_ra_get_dir2(ra_session, &tmpdirents, NULL, NULL,
dir, rev, DIRENT_FIELDS, pool));
for (hi = apr_hash_first(pool, tmpdirents); hi; hi = apr_hash_next(hi))
{
const char *path, *URL, *fs_path;
const void *key;
svn_lock_t *lock;
void *val;
svn_pool_clear(subpool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
apr_hash_this(hi, &key, NULL, &val);
the_ent = val;
path = svn_path_join(dir, key, subpool);
URL = svn_path_url_add_component(session_URL, key, subpool);
fs_path = svn_path_is_child(repos_root, URL, subpool);
fs_path = apr_pstrcat(subpool, "/", fs_path, NULL);
fs_path = svn_path_uri_decode(fs_path, subpool);
lock = apr_hash_get(locks, fs_path, APR_HASH_KEY_STRING);
SVN_ERR(build_info_from_dirent(&info, the_ent, lock, URL, rev,
repos_UUID, repos_root, subpool));
if (depth >= svn_depth_immediates
|| (depth == svn_depth_files && the_ent->kind == svn_node_file))
{
SVN_ERR(receiver(receiver_baton, path, info, subpool));
}
if (depth == svn_depth_infinity && the_ent->kind == svn_node_dir)
{
SVN_ERR(push_dir_info(ra_session, URL, path,
rev, repos_UUID, repos_root,
receiver, receiver_baton,
depth, ctx, locks, subpool));
}
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_blame (svn_ra_plugin_t *ra_lib, void *ra_session,
const char *target,
svn_revnum_t start_revnum,
svn_revnum_t end_revnum,
svn_client_blame_receiver_t receiver,
void *receiver_baton,
apr_pool_t *pool)
{
struct file_rev_baton frb;
struct blame *walk;
apr_file_t *tempfile;
apr_pool_t *iterpool;
svn_stream_t *stream;
svn_error_t *err;
// SVN_INVALID_REVNUM (=head revision)
if ((end_revnum < start_revnum) && (end_revnum != SVN_INVALID_REVNUM))
return svn_error_create(SVN_ERR_CLIENT_BAD_REVISION, NULL,
("Start revision must precede end revision"));
frb.start_rev = start_revnum;
frb.end_rev = end_revnum;
frb.target = target;
frb.last_filename = NULL;
frb.blame = NULL;
frb.avail = NULL;
frb.mainpool = pool;
/* The callback will flip the following two pools, because it needs
information from the previous call. Obviously, it can't rely on
the lifetime of the pool provided by get_file_revs. */
frb.lastpool = svn_pool_create (pool);
frb.currpool = svn_pool_create (pool);
// do the actual blame
err = do_blame (target, ra_lib, ra_session, &frb);
if (err) return err;
/* Report the blame to the caller. */
/* The callback has to have been called at least once. */
assert (frb.last_filename != NULL);
/* Create a pool for the iteration below. */
iterpool = svn_pool_create (pool);
/* Open the last file and get a stream. */
err = svn_io_file_open (&tempfile, frb.last_filename, APR_READ, APR_OS_DEFAULT, pool);
if (err) return err;
stream = svn_stream_from_aprfile(tempfile, pool);
/* Process each blame item. */
for (walk = frb.blame; walk; walk = walk->next)
{
apr_off_t line_no;
for (line_no = walk->start; !walk->next || line_no < walk->next->start; ++line_no)
{
svn_boolean_t eof;
svn_stringbuf_t *sb;
apr_pool_clear (iterpool);
err = svn_stream_readline (stream, &sb, "\n", &eof, iterpool);
if (err) return err;
if (!eof || sb->len)
SVN_ERR (receiver (receiver_baton, line_no, walk->rev->revision,
walk->rev->author, walk->rev->date,
sb->data, iterpool));
if (eof) break;
}
}
err = svn_stream_close (stream);
err = svn_io_file_close(tempfile, pool);
svn_pool_destroy(frb.lastpool);
svn_pool_destroy(frb.currpool);
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
static svn_error_t *
test_parse_unidiff(apr_pool_t *pool)
{
svn_patch_file_t *patch_file;
svn_boolean_t reverse;
svn_boolean_t ignore_whitespace;
int i;
apr_pool_t *iterpool;
reverse = FALSE;
ignore_whitespace = FALSE;
iterpool = svn_pool_create(pool);
for (i = 0; i < 2; i++)
{
svn_patch_t *patch;
svn_diff_hunk_t *hunk;
svn_pool_clear(iterpool);
SVN_ERR(create_patch_file(&patch_file, unidiff, pool));
/* We have two patches with one hunk each.
* Parse the first patch. */
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, reverse,
ignore_whitespace, iterpool,
iterpool));
SVN_TEST_ASSERT(patch);
SVN_TEST_STRING_ASSERT(patch->old_filename, "A/C/gamma");
SVN_TEST_STRING_ASSERT(patch->new_filename, "A/C/gamma");
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, ! reverse,
"This is the file 'gamma'." NL,
pool));
SVN_ERR(check_content(hunk, reverse,
"This is the file 'gamma'." NL
"some more bytes to 'gamma'" NL,
pool));
/* Parse the second patch. */
SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, reverse,
ignore_whitespace, pool, pool));
SVN_TEST_ASSERT(patch);
if (reverse)
{
SVN_TEST_STRING_ASSERT(patch->new_filename, "A/D/gamma.orig");
SVN_TEST_STRING_ASSERT(patch->old_filename, "A/D/gamma");
}
else
{
SVN_TEST_STRING_ASSERT(patch->old_filename, "A/D/gamma.orig");
SVN_TEST_STRING_ASSERT(patch->new_filename, "A/D/gamma");
}
SVN_TEST_ASSERT(patch->hunks->nelts == 1);
hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *);
SVN_ERR(check_content(hunk, ! reverse,
"This is the file 'gamma'." NL
"some less bytes to 'gamma'" NL,
pool));
SVN_ERR(check_content(hunk, reverse,
"This is the file 'gamma'." NL,
pool));
reverse = !reverse;
SVN_ERR(svn_diff_close_patch_file(patch_file, pool));
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__blame(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
apr_pool_t *subpool;
apr_array_header_t *targets;
blame_baton_t bl;
int i;
svn_boolean_t end_revision_unspecified = FALSE;
svn_diff_file_options_t *diff_options = svn_diff_file_options_create(pool);
svn_boolean_t seen_nonexistent_target = FALSE;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE, pool));
/* Blame needs a file on which to operate. */
if (! targets->nelts)
return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL);
if (opt_state->end_revision.kind == svn_opt_revision_unspecified)
{
if (opt_state->start_revision.kind != svn_opt_revision_unspecified)
{
/* In the case that -rX was specified, we actually want to set the
range to be -r1:X. */
opt_state->end_revision = opt_state->start_revision;
opt_state->start_revision.kind = svn_opt_revision_number;
opt_state->start_revision.value.number = 1;
}
else
end_revision_unspecified = TRUE;
}
if (opt_state->start_revision.kind == svn_opt_revision_unspecified)
{
opt_state->start_revision.kind = svn_opt_revision_number;
opt_state->start_revision.value.number = 1;
}
/* The final conclusion from issue #2431 is that blame info
is client output (unlike 'svn cat' which plainly cats the file),
so the EOL style should be the platform local one.
*/
if (! opt_state->xml)
SVN_ERR(svn_stream_for_stdout(&bl.out, pool));
else
bl.sbuf = svn_stringbuf_create("", pool);
bl.opt_state = opt_state;
subpool = svn_pool_create(pool);
if (opt_state->extensions)
{
apr_array_header_t *opts;
opts = svn_cstring_split(opt_state->extensions, " \t\n\r", TRUE, pool);
SVN_ERR(svn_diff_file_options_parse(diff_options, opts, pool));
}
if (opt_state->xml)
{
if (opt_state->verbose)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'verbose' option invalid in XML mode"));
/* If output is not incremental, output the XML header and wrap
everything in a top-level element. This makes the output in
its entirety a well-formed XML document. */
if (! opt_state->incremental)
SVN_ERR(svn_cl__xml_print_header("blame", pool));
}
else
{
if (opt_state->incremental)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'incremental' option only valid in XML "
"mode"));
}
for (i = 0; i < targets->nelts; i++)
{
svn_error_t *err;
const char *target = APR_ARRAY_IDX(targets, i, const char *);
const char *truepath;
svn_opt_revision_t peg_revision;
svn_client_blame_receiver3_t receiver;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Check for a peg revision. */
SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target,
subpool));
if (end_revision_unspecified)
{
if (peg_revision.kind != svn_opt_revision_unspecified)
opt_state->end_revision = peg_revision;
else if (svn_path_is_url(target))
opt_state->end_revision.kind = svn_opt_revision_head;
else
opt_state->end_revision.kind = svn_opt_revision_working;
}
if (opt_state->xml)
{
/* "<target ...>" */
/* We don't output this tag immediately, which avoids creating
a target element if this path is skipped. */
const char *outpath = truepath;
if (! svn_path_is_url(target))
outpath = svn_dirent_local_style(truepath, subpool);
svn_xml_make_open_tag(&bl.sbuf, pool, svn_xml_normal, "target",
"path", outpath, NULL);
receiver = blame_receiver_xml;
}
else
receiver = blame_receiver;
err = svn_client_blame5(truepath,
&peg_revision,
&opt_state->start_revision,
&opt_state->end_revision,
diff_options,
opt_state->force,
opt_state->use_merge_history,
receiver,
&bl,
ctx,
subpool);
if (err)
{
if (err->apr_err == SVN_ERR_CLIENT_IS_BINARY_FILE)
{
svn_error_clear(err);
SVN_ERR(svn_cmdline_fprintf(stderr, subpool,
_("Skipping binary file: '%s'\n"),
target));
}
else if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND ||
err->apr_err == SVN_ERR_FS_NOT_FILE ||
err->apr_err == SVN_ERR_FS_NOT_FOUND)
{
svn_handle_warning2(stderr, err, "svn: ");
svn_error_clear(err);
err = NULL;
seen_nonexistent_target = TRUE;
}
else
{
return svn_error_trace(err);
}
}
else if (opt_state->xml)
{
/* "</target>" */
svn_xml_make_close_tag(&(bl.sbuf), pool, "target");
SVN_ERR(svn_cl__error_checked_fputs(bl.sbuf->data, stdout));
}
if (opt_state->xml)
svn_stringbuf_setempty(bl.sbuf);
}
svn_pool_destroy(subpool);
if (opt_state->xml && ! opt_state->incremental)
SVN_ERR(svn_cl__xml_print_footer("blame", pool));
if (seen_nonexistent_target)
return svn_error_create(
SVN_ERR_ILLEGAL_TARGET, NULL,
_("Could not perform blame on all targets because some "
"targets don't exist"));
else
return SVN_NO_ERROR;
}
static int
l_proplist (lua_State *L) {
const char *path = (lua_gettop (L) < 1 || lua_isnil (L, 1)) ? "" : luaL_checkstring (L, 1);
svn_opt_revision_t peg_revision;
svn_opt_revision_t revision;
peg_revision.kind = svn_opt_revision_unspecified;
if (lua_gettop (L) < 2 || lua_isnil (L, 2)) {
revision.kind = svn_opt_revision_unspecified;
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 2);
}
svn_boolean_t recursive = FALSE;
int itable = 3;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "recursive");
if (lua_isboolean (L, -1)) {
recursive = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
apr_array_header_t *props;
int is_url = svn_path_is_url (path);
err = svn_client_proplist2 (&props, path, &peg_revision, &revision, recursive, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
lua_newtable (L);
int i;
for (i = 0; i < props->nelts; ++i)
{
const void *key;
void *val;
svn_client_proplist_item_t *item = ((svn_client_proplist_item_t **)props->elts)[i];
const char *name_local;
if (is_url) {
name_local = svn_path_local_style (item->node_name->data, pool);
} else {
name_local = item->node_name->data;
}
lua_pushstring (L, name_local);
lua_newtable (L);
apr_hash_index_t *hi;
for (hi = apr_hash_first (pool, item->prop_hash); hi; hi = apr_hash_next (hi)) {
const char *pname;
svn_string_t *pval;
apr_hash_this (hi, &key, NULL, &val);
pname = key;
pval = (svn_string_t *) val;
err = svn_cmdline_cstring_from_utf8 (&pname, pname, pool);
IF_ERROR_RETURN (err, pool, L);
lua_pushstring (L, pval->data);
lua_setfield (L, -2, pname);
}
lua_settable (L, -3);
}
svn_pool_destroy (pool);
return 1;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__resolve(apr_getopt_t *os,
void *baton,
apr_pool_t *scratch_pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
svn_wc_conflict_choice_t conflict_choice;
svn_error_t *err;
apr_array_header_t *targets;
int i;
apr_pool_t *iterpool;
svn_boolean_t had_error = FALSE;
svn_wc_conflict_resolver_func2_t conflict_func2;
void *conflict_baton2;
switch (opt_state->accept_which)
{
case svn_cl__accept_working:
conflict_choice = svn_wc_conflict_choose_merged;
break;
case svn_cl__accept_base:
conflict_choice = svn_wc_conflict_choose_base;
break;
case svn_cl__accept_theirs_conflict:
conflict_choice = svn_wc_conflict_choose_theirs_conflict;
break;
case svn_cl__accept_mine_conflict:
conflict_choice = svn_wc_conflict_choose_mine_conflict;
break;
case svn_cl__accept_theirs_full:
conflict_choice = svn_wc_conflict_choose_theirs_full;
break;
case svn_cl__accept_mine_full:
conflict_choice = svn_wc_conflict_choose_mine_full;
break;
case svn_cl__accept_unspecified:
if (opt_state->conflict_func == NULL)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("missing --accept option"));
conflict_choice = svn_wc_conflict_choose_unspecified;
break;
default:
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("invalid 'accept' ARG"));
}
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE,
scratch_pool));
if (! targets->nelts)
svn_opt_push_implicit_dot_target(targets, scratch_pool);
if (opt_state->depth == svn_depth_unknown)
{
if (opt_state->accept_which == svn_cl__accept_unspecified)
opt_state->depth = svn_depth_infinity;
else
opt_state->depth = svn_depth_empty;
}
SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool));
SVN_ERR(svn_cl__check_targets_are_local_paths(targets));
/* Store old state */
conflict_func2 = ctx->conflict_func2;
conflict_baton2 = ctx->conflict_baton2;
/* Store interactive resolver */
ctx->conflict_func2 = opt_state->conflict_func;
ctx->conflict_baton2 = opt_state->conflict_baton;
iterpool = svn_pool_create(scratch_pool);
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_pool_clear(iterpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
err = svn_client_resolve(target,
opt_state->depth, conflict_choice,
ctx,
iterpool);
if (err)
{
svn_handle_warning2(stderr, err, "svn: ");
svn_error_clear(err);
had_error = TRUE;
}
}
svn_pool_destroy(iterpool);
/* Restore state */
ctx->conflict_func2 = conflict_func2;
ctx->conflict_baton2 = conflict_baton2;
if (had_error)
return svn_error_create(SVN_ERR_CL_ERROR_PROCESSING_EXTERNALS, NULL,
_("Failure occurred resolving one or more "
"conflicts"));
return SVN_NO_ERROR;
}
