svn_error_t *
svn_wc__prop_path(const char **prop_path,
const char *path,
svn_node_kind_t node_kind,
svn_wc__props_kind_t props_kind,
apr_pool_t *pool)
{
if (node_kind == svn_node_dir) /* It's a working copy dir */
{
static const char * names[] = {
SVN_WC__ADM_DIR_PROP_BASE, /* svn_wc__props_base */
SVN_WC__ADM_DIR_PROP_REVERT, /* svn_wc__props_revert */
SVN_WC__ADM_DIR_WCPROPS, /* svn_wc__props_wcprop */
SVN_WC__ADM_DIR_PROPS /* svn_wc__props_working */
};
*prop_path = extend_with_adm_name
(path,
NULL,
FALSE,
pool,
names[props_kind],
NULL);
}
else /* It's a file */
{
static const char * extensions[] = {
SVN_WC__BASE_EXT, /* svn_wc__props_base */
SVN_WC__REVERT_EXT, /* svn_wc__props_revert */
SVN_WC__WORK_EXT, /* svn_wc__props_wcprop */
SVN_WC__WORK_EXT /* svn_wc__props_working */
};
static const char * dirs[] = {
SVN_WC__ADM_PROP_BASE, /* svn_wc__props_base */
SVN_WC__ADM_PROP_BASE, /* svn_wc__props_revert */
SVN_WC__ADM_WCPROPS, /* svn_wc__props_wcprop */
SVN_WC__ADM_PROPS /* svn_wc__props_working */
};
const char *base_name;
svn_path_split(path, prop_path, &base_name, pool);
*prop_path = extend_with_adm_name
(*prop_path,
extensions[props_kind],
FALSE,
pool,
dirs[props_kind],
base_name,
NULL);
}
return SVN_NO_ERROR;
}
void
Path::split(std::string & dirpath, std::string & basename) const
{
Pool pool;
const char * cdirpath;
const char * cbasename;
svn_path_split(m_path.c_str(), &cdirpath, &cbasename, pool);
dirpath = cdirpath;
basename = cbasename;
}
const char *
svn_wc__text_revert_path(const char *path,
apr_pool_t *pool)
{
const char *newpath, *base_name;
svn_path_split(path, &newpath, &base_name, pool);
return extend_with_adm_name(newpath,
SVN_WC__REVERT_EXT,
FALSE,
pool,
SVN_WC__ADM_TEXT_BASE,
base_name,
NULL);
}
svn_error_t *
svn_wc__write_old_wcprops(const char *path,
apr_hash_t *prophash,
svn_node_kind_t kind,
apr_pool_t *scratch_pool)
{
apr_pool_t *pool = scratch_pool;
const char *parent_dir;
const char *base_name;
svn_stream_t *stream;
const char *temp_dir_path;
const char *temp_prop_path;
const char *prop_path;
int wc_format_version;
if (kind == svn_node_dir)
parent_dir = path;
else
svn_path_split(path, &parent_dir, &base_name, pool);
/* At this point, we know we need to open a file in the admin area
of parent_dir. First check that parent_dir is a working copy: */
SVN_ERR(svn_wc_check_wc(parent_dir, &wc_format_version, pool));
if (wc_format_version == 0)
return svn_error_createf(SVN_ERR_WC_OBSTRUCTED_UPDATE, NULL,
_("'%s' is not a working copy"),
svn_path_local_style(parent_dir, pool));
/* Write to a temp file, then rename into place. */
temp_dir_path = svn_wc__adm_child(parent_dir, SVN_WC__ADM_TMP, pool);
SVN_ERR(svn_stream_open_unique(&stream, &temp_prop_path,
temp_dir_path,
svn_io_file_del_none,
pool, pool));
SVN_ERR_W(svn_hash_write2(prophash, stream, SVN_HASH_TERMINATOR,
pool),
apr_psprintf(pool,
_("Cannot write property hash for '%s'"),
svn_path_local_style(path, pool)));
svn_stream_close(stream);
/* Close file, then do an atomic "move". */
SVN_ERR(svn_wc__prop_path(&prop_path, path, kind, svn_wc__props_wcprop,
pool));
SVN_ERR(svn_io_file_rename(temp_prop_path, prop_path, pool));
return svn_io_set_file_read_only(prop_path, FALSE, pool);
}
const char *
svn_wc__text_base_path(const char *path,
svn_boolean_t tmp,
apr_pool_t *pool)
{
const char *newpath, *base_name;
svn_path_split(path, &newpath, &base_name, pool);
return extend_with_adm_name(newpath,
SVN_WC__BASE_EXT,
tmp,
pool,
SVN_WC__ADM_TEXT_BASE,
base_name,
NULL);
}
/* Rename a tmp text-base file to its real text-base name.
The file had better already be closed. */
svn_error_t *
svn_wc__sync_text_base(const char *path, apr_pool_t *pool)
{
const char *parent_path;
const char *base_name;
const char *tmp_path;
const char *base_path;
svn_path_split(path, &parent_path, &base_name, pool);
/* Extend tmp name. */
tmp_path = extend_with_adm_name(parent_path, SVN_WC__BASE_EXT, TRUE, pool,
SVN_WC__ADM_TEXT_BASE, base_name, NULL);
/* Extend real name. */
base_path = extend_with_adm_name(parent_path, SVN_WC__BASE_EXT, FALSE, pool,
SVN_WC__ADM_TEXT_BASE, base_name, NULL);
/* Rename. */
SVN_ERR(svn_io_file_rename(tmp_path, base_path, pool));
return svn_io_set_file_read_only(base_path, FALSE, pool);
}
/* Reparents the session if the current root is a file */
char session_check_reparent(session_t *session, svn_revnum_t rev)
{
svn_error_t *err;
svn_node_kind_t kind;
apr_pool_t *pool = svn_pool_create(session->pool);
/* Check if the current root is a file */
err = svn_ra_check_path(session->ra, "", rev, &kind, pool);
if (err) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
svn_pool_destroy(pool);
return 1;
}
if (kind == svn_node_file) {
#ifdef USE_SINGLEFILE_DUMP
/* Determine the parent directory */
const char *new_parent;
svn_path_split(session->encoded_url, &new_parent, &session->file, session->pool);
/* Reparent the session to the parent repository */
err = svn_ra_reparent(session->ra, new_parent, pool);
if (err) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
svn_pool_destroy(pool);
return 1;
}
#else
/* Sorry, we're unable to dump single files for now */
fprintf(stderr, _("ERROR: '%s' refers to a file.\n"), session->encoded_url);
svn_pool_destroy(pool);
return 1;
#endif
}
svn_pool_destroy(pool);
return 0;
}
/* Append URL, and all it's non-existent parent directories, to TARGETS.
Use TEMPPOOL for temporary allocations and POOL for any additions to
TARGETS. */
static svn_error_t *
add_url_parents(svn_ra_session_t *ra_session,
const char *url,
apr_array_header_t *targets,
apr_pool_t *temppool,
apr_pool_t *pool)
{
svn_node_kind_t kind;
const char *parent_url;
svn_path_split(url, &parent_url, NULL, pool);
SVN_ERR(svn_ra_reparent(ra_session, parent_url, temppool));
SVN_ERR(svn_ra_check_path(ra_session, "", SVN_INVALID_REVNUM, &kind,
temppool));
if (kind == svn_node_none)
SVN_ERR(add_url_parents(ra_session, parent_url, targets, temppool, pool));
APR_ARRAY_PUSH(targets, const char *) = url;
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__open_writable_base(svn_stream_t **stream,
const char **temp_base_path,
const char *path,
svn_boolean_t need_revert_base,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *parent_path;
const char *base_name;
svn_path_split(path, &parent_path, &base_name, scratch_pool);
return open_adm_file(stream, temp_base_path,
parent_path,
need_revert_base
? SVN_WC__REVERT_EXT
: SVN_WC__BASE_EXT,
TRUE /* for_writing */,
result_pool, scratch_pool,
SVN_WC__ADM_TEXT_BASE,
base_name,
NULL);
}
svn_error_t *
svn_client_info2(const char *path_or_url,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
svn_info_receiver_t receiver,
void *receiver_baton,
svn_depth_t depth,
const apr_array_header_t *changelists,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_ra_session_t *ra_session, *parent_ra_session;
svn_revnum_t rev;
const char *url;
svn_node_kind_t url_kind;
const char *repos_root_URL, *repos_UUID;
svn_lock_t *lock;
svn_boolean_t related;
apr_hash_t *parent_ents;
const char *parent_url, *base_name;
svn_dirent_t *the_ent;
svn_info_t *info;
svn_error_t *err;
if ((revision == NULL
|| revision->kind == svn_opt_revision_unspecified)
&& (peg_revision == NULL
|| peg_revision->kind == svn_opt_revision_unspecified))
{
/* Do all digging in the working copy. */
apr_hash_t *changelist_hash = NULL;
if (changelists && changelists->nelts)
SVN_ERR(svn_hash_from_cstring_keys(&changelist_hash,
changelists, pool));
return crawl_entries(path_or_url, receiver, receiver_baton,
depth, changelist_hash, ctx, pool);
}
/* Go repository digging instead. */
/* Trace rename history (starting at path_or_url@peg_revision) and
return RA session to the possibly-renamed URL as it exists in REVISION.
The ra_session returned will be anchored on this "final" URL. */
SVN_ERR(svn_client__ra_session_from_path(&ra_session, &rev,
&url, path_or_url, NULL,
peg_revision,
revision, ctx, pool));
SVN_ERR(svn_ra_get_repos_root2(ra_session, &repos_root_URL, pool));
SVN_ERR(svn_ra_get_uuid2(ra_session, &repos_UUID, pool));
svn_path_split(url, &parent_url, &base_name, pool);
base_name = svn_path_uri_decode(base_name, pool);
/* Get the dirent for the URL itself. */
err = svn_ra_stat(ra_session, "", rev, &the_ent, pool);
/* svn_ra_stat() will work against old versions of mod_dav_svn, but
not old versions of svnserve. In the case of a pre-1.2 svnserve,
catch the specific error it throws:*/
if (err && err->apr_err == SVN_ERR_RA_NOT_IMPLEMENTED)
{
/* Fall back to pre-1.2 strategy for fetching dirent's URL. */
svn_error_clear(err);
if (strcmp(url, repos_root_URL) == 0)
{
/* In this universe, there's simply no way to fetch
information about the repository's root directory!
If we're recursing, degrade gracefully: rather than
throw an error, return no information about the
repos root. */
if (depth > svn_depth_empty)
goto pre_1_2_recurse;
/* Otherwise, we really are stuck. Better tell the user
what's going on. */
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Server does not support retrieving "
"information about the repository root"));
}
SVN_ERR(svn_ra_check_path(ra_session, "", rev, &url_kind, pool));
if (url_kind == svn_node_none)
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("URL '%s' non-existent in revision %ld"),
url, rev);
/* Open a new RA session to the item's parent. */
SVN_ERR(svn_client__open_ra_session_internal(&parent_ra_session,
parent_url, NULL,
NULL, NULL, FALSE, TRUE,
ctx, pool));
/* Get all parent's entries, and find the item's dirent in the hash. */
SVN_ERR(svn_ra_get_dir2(parent_ra_session, &parent_ents, NULL, NULL,
"", rev, DIRENT_FIELDS, pool));
the_ent = apr_hash_get(parent_ents, base_name, APR_HASH_KEY_STRING);
if (the_ent == NULL)
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("URL '%s' non-existent in revision %ld"),
url, rev);
}
else if (err)
{
return err;
}
if (! the_ent)
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("URL '%s' non-existent in revision %ld"),
url, rev);
/* Check if the URL exists in HEAD and refers to the same resource.
In this case, we check the repository for a lock on this URL.
### There is a possible race here, since HEAD might have changed since
### we checked it. A solution to this problem could be to do the below
### check in a loop which only terminates if the HEAD revision is the same
### before and after this check. That could, however, lead to a
### starvation situation instead. */
SVN_ERR(same_resource_in_head(&related, url, rev, ra_session, ctx, pool));
if (related)
{
err = svn_ra_get_lock(ra_session, &lock, "", pool);
/* An old mod_dav_svn will always work; there's nothing wrong with
doing a PROPFIND for a property named "DAV:supportedlock". But
an old svnserve will error. */
if (err && err->apr_err == SVN_ERR_RA_NOT_IMPLEMENTED)
{
svn_error_clear(err);
lock = NULL;
}
else if (err)
return err;
}
else
lock = NULL;
/* Push the URL's dirent (and lock) at the callback.*/
SVN_ERR(build_info_from_dirent(&info, the_ent, lock, url, rev,
repos_UUID, repos_root_URL, pool));
SVN_ERR(receiver(receiver_baton, base_name, info, pool));
/* Possibly recurse, using the original RA session. */
if (depth > svn_depth_empty && (the_ent->kind == svn_node_dir))
{
apr_hash_t *locks;
pre_1_2_recurse:
if (peg_revision->kind == svn_opt_revision_head)
{
err = svn_ra_get_locks(ra_session, &locks, "", pool);
/* Catch specific errors thrown by old mod_dav_svn or svnserve. */
if (err &&
(err->apr_err == SVN_ERR_RA_NOT_IMPLEMENTED
|| err->apr_err == SVN_ERR_UNSUPPORTED_FEATURE))
{
svn_error_clear(err);
locks = apr_hash_make(pool); /* use an empty hash */
}
else if (err)
return err;
}
else
locks = apr_hash_make(pool); /* use an empty hash */
SVN_ERR(push_dir_info(ra_session, url, "", rev,
repos_UUID, repos_root_URL,
receiver, receiver_baton,
depth, ctx, locks, pool));
}
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
int
main (int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err;
apr_hash_t *dirents;
const char *upload_file, *URL;
const char *parent_URL, *basename;
svn_ra_plugin_t *ra_lib;
void *session, *ra_baton;
svn_revnum_t rev;
const svn_delta_editor_t *editor;
void *edit_baton;
svn_dirent_t *dirent;
svn_ra_callbacks_t *cbtable;
apr_hash_t *cfg_hash;
svn_auth_baton_t *auth_baton;
if (argc <= 2)
{
printf ("Usage: %s PATH URL\n", argv[0]);
printf (" Uploads file at PATH to Subversion repository URL.\n");
return EXIT_FAILURE;
}
upload_file = argv[1];
URL = argv[2];
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init ("minimal_client", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create top-level memory pool. Be sure to read the HACKING file to
understand how to properly use/free subpools. */
pool = svn_pool_create (NULL);
/* Initialize the FS library. */
err = svn_fs_initialize (pool);
if (err) goto hit_error;
/* Make sure the ~/.subversion run-time config files exist, and load. */
err = svn_config_ensure (NULL, pool);
if (err) goto hit_error;
err = svn_config_get_config (&cfg_hash, NULL, pool);
if (err) goto hit_error;
/* Build an authentication baton. */
{
/* There are many different kinds of authentication back-end
"providers". See svn_auth.h for a full overview. */
svn_auth_provider_object_t *provider;
apr_array_header_t *providers
= apr_array_make (pool, 4, sizeof (svn_auth_provider_object_t *));
svn_client_get_simple_prompt_provider (&provider,
my_simple_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
svn_client_get_username_prompt_provider (&provider,
my_username_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
/* Register the auth-providers into the context's auth_baton. */
svn_auth_open (&auth_baton, providers, pool);
}
/* Create a table of callbacks for the RA session, mostly nonexistent. */
cbtable = apr_pcalloc (pool, sizeof(*cbtable));
cbtable->auth_baton = auth_baton;
cbtable->open_tmp_file = open_tmp_file;
/* Now do the real work. */
/* Open an RA session to the parent URL, fetch current HEAD rev and
"lock" onto that revnum for the remainder of the session. */
svn_path_split (URL, &parent_URL, &basename, pool);
err = svn_ra_init_ra_libs (&ra_baton, pool);
if (err) goto hit_error;
err = svn_ra_get_ra_library (&ra_lib, ra_baton, parent_URL, pool);
if (err) goto hit_error;
err = ra_lib->open (&session, parent_URL, cbtable, NULL, cfg_hash, pool);
if (err) goto hit_error;
err = ra_lib->get_latest_revnum (session, &rev, pool);
if (err) goto hit_error;
/* Examine contents of parent dir in the rev. */
err = ra_lib->get_dir (session, "", rev, &dirents, NULL, NULL, pool);
if (err) goto hit_error;
/* Sanity checks. Don't let the user shoot himself *too* much. */
dirent = apr_hash_get (dirents, basename, APR_HASH_KEY_STRING);
if (dirent && dirent->kind == svn_node_dir)
{
printf ("Sorry, a directory already exists at that URL.\n");
return EXIT_FAILURE;
}
if (dirent && dirent->kind == svn_node_file)
{
char answer[5];
printf ("\n*** WARNING ***\n\n");
printf ("You're about to overwrite r%ld of this file.\n", rev);
printf ("It was last changed by user '%s',\n",
dirent->last_author ? dirent->last_author : "?");
printf ("on %s.\n", svn_time_to_human_cstring (dirent->time, pool));
printf ("\nSomebody *might* have just changed the file seconds ago,\n"
"and your upload would be overwriting their changes!\n\n");
err = prompt_and_read_line("Are you SURE you want to upload? [y/n]",
answer, sizeof(answer));
if (err) goto hit_error;
if (apr_strnatcasecmp (answer, "y"))
{
printf ("Operation aborted.\n");
return EXIT_SUCCESS;
}
}
/* Fetch a commit editor (it's anchored on the parent URL, because
the session is too.) */
/* ### someday add an option for a user-written commit message? */
err = ra_lib->get_commit_editor (session, &editor, &edit_baton,
"File upload from 'svnput' program.",
my_commit_callback, NULL, pool);
if (err) goto hit_error;
/* Drive the editor */
{
void *root_baton, *file_baton, *handler_baton;
svn_txdelta_window_handler_t handler;
svn_stream_t *contents;
apr_file_t *f = NULL;
err = editor->open_root (edit_baton, rev, pool, &root_baton);
if (err) goto hit_error;
if (! dirent)
{
err = editor->add_file (basename, root_baton, NULL, SVN_INVALID_REVNUM,
pool, &file_baton);
}
else
{
err = editor->open_file (basename, root_baton, rev, pool,
&file_baton);
}
if (err) goto hit_error;
err = editor->apply_textdelta (file_baton, NULL, pool,
&handler, &handler_baton);
if (err) goto hit_error;
err = svn_io_file_open (&f, upload_file, APR_READ, APR_OS_DEFAULT, pool);
if (err) goto hit_error;
contents = svn_stream_from_aprfile (f, pool);
err = svn_txdelta_send_stream (contents, handler, handler_baton,
NULL, pool);
if (err) goto hit_error;
err = svn_io_file_close (f, pool);
if (err) goto hit_error;
err = editor->close_file (file_baton, NULL, pool);
if (err) goto hit_error;
err = editor->close_edit (edit_baton, pool);
if (err) goto hit_error;
}
return EXIT_SUCCESS;
hit_error:
svn_handle_error2 (err, stderr, FALSE, "svnput: ");
return EXIT_FAILURE;
}
/* Internal version of svn_wc_merge, also used to (loggily) merge updates
from the repository.
In the case of updating, the update can have sent new properties,
which could affect the way the wc target is detranslated and
compared with LEFT and RIGHT for merging.
Property changes sent by the update are provided in PROP_DIFF.
If COPYFROM_TEXT is non-null, the working text is taken from this
file instead of from the actual version in the working copy (and
the merge_target is allowed to not be under version control in this
case).
*/
svn_error_t *
svn_wc__merge_internal(svn_stringbuf_t **log_accum,
enum svn_wc_merge_outcome_t *merge_outcome,
const char *left,
const char *right,
const char *merge_target,
const char *copyfrom_text,
svn_wc_adm_access_t *adm_access,
const char *left_label,
const char *right_label,
const char *target_label,
svn_boolean_t dry_run,
const char *diff3_cmd,
const apr_array_header_t *merge_options,
const apr_array_header_t *prop_diff,
svn_wc_conflict_resolver_func_t conflict_func,
void *conflict_baton,
apr_pool_t *pool)
{
const char *tmp_target, *result_target, *working_text;
const char *adm_path = svn_wc_adm_access_path(adm_access);
apr_file_t *result_f;
svn_boolean_t is_binary = FALSE;
const svn_wc_entry_t *entry;
svn_boolean_t contains_conflicts;
const svn_prop_t *mimeprop;
/* Sanity check: the merge target must be under revision control (unless
this is an add-with-history). */
SVN_ERR(svn_wc_entry(&entry, merge_target, adm_access, FALSE, pool));
if (! entry && ! copyfrom_text)
{
*merge_outcome = svn_wc_merge_no_merge;
return SVN_NO_ERROR;
}
/* Decide if the merge target is a text or binary file. */
if ((mimeprop = get_prop(prop_diff, SVN_PROP_MIME_TYPE))
&& mimeprop->value)
is_binary = svn_mime_type_is_binary(mimeprop->value->data);
else if (! copyfrom_text)
SVN_ERR(svn_wc_has_binary_prop(&is_binary, merge_target, adm_access, pool));
working_text = copyfrom_text ? copyfrom_text : merge_target;
SVN_ERR(detranslate_wc_file(&tmp_target, working_text, adm_access,
(! is_binary) && diff3_cmd != NULL,
prop_diff, pool));
/* We cannot depend on the left file to contain the same eols as the
right file. If the merge target has mods, this will mark the entire
file as conflicted, so we need to compensate. */
SVN_ERR(maybe_update_target_eols(&left, left, adm_access, prop_diff, pool));
if (! is_binary) /* this is a text file */
{
/* Open a second temporary file for writing; this is where diff3
will write the merged results. */
SVN_ERR(svn_wc_create_tmp_file2(&result_f, &result_target,
adm_path, svn_io_file_del_none,
pool));
/* Run an external merge if requested. */
if (diff3_cmd)
{
int exit_code;
SVN_ERR(svn_io_run_diff3_2(&exit_code, ".",
tmp_target, left, right,
target_label, left_label, right_label,
result_f, diff3_cmd,
merge_options, pool));
contains_conflicts = exit_code == 1;
}
else
{
svn_diff_t *diff;
const char *target_marker;
const char *left_marker;
const char *right_marker;
svn_stream_t *ostream;
svn_diff_file_options_t *options;
ostream = svn_stream_from_aprfile(result_f, pool);
options = svn_diff_file_options_create(pool);
if (merge_options)
SVN_ERR(svn_diff_file_options_parse(options, merge_options, pool));
SVN_ERR(svn_diff_file_diff3_2(&diff,
left, tmp_target, right,
options, pool));
/* Labels fall back to sensible defaults if not specified. */
if (target_label)
target_marker = apr_psprintf(pool, "<<<<<<< %s", target_label);
else
target_marker = "<<<<<<< .working";
if (left_label)
left_marker = apr_psprintf(pool, "||||||| %s", left_label);
else
left_marker = "||||||| .old";
if (right_label)
right_marker = apr_psprintf(pool, ">>>>>>> %s", right_label);
else
right_marker = ">>>>>>> .new";
SVN_ERR(svn_diff_file_output_merge(ostream, diff,
left, tmp_target, right,
left_marker,
target_marker,
right_marker,
"=======", /* seperator */
FALSE, /* display original */
FALSE, /* resolve conflicts */
pool));
SVN_ERR(svn_stream_close(ostream));
contains_conflicts = svn_diff_contains_conflicts(diff);
}
/* Close the output file */
SVN_ERR(svn_io_file_close(result_f, pool));
if (contains_conflicts && ! dry_run) /* got a conflict */
{
const char *left_copy, *right_copy, *target_copy;
const char *tmp_left, *tmp_right, *tmp_target_copy;
const char *parentt, *target_base;
svn_wc_adm_access_t *parent_access;
svn_wc_entry_t tmp_entry;
/* Give the conflict resolution callback a chance to clean
up the conflict before we mark the file 'conflicted' */
if (conflict_func)
{
svn_wc_conflict_result_t *result = NULL;
svn_wc_conflict_description_t cdesc;
cdesc.path = merge_target;
cdesc.node_kind = svn_node_file;
cdesc.kind = svn_wc_conflict_kind_text;
cdesc.is_binary = FALSE;
cdesc.mime_type = (mimeprop && mimeprop->value)
? mimeprop->value->data : NULL;
cdesc.access = adm_access;
cdesc.action = svn_wc_conflict_action_edit;
cdesc.reason = svn_wc_conflict_reason_edited;
cdesc.base_file = left;
cdesc.their_file = right;
cdesc.my_file = tmp_target;
cdesc.merged_file = result_target;
cdesc.property_name = NULL;
SVN_ERR(conflict_func(&result, &cdesc, conflict_baton, pool));
if (result == NULL)
return svn_error_create(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
NULL, _("Conflict callback violated API:"
" returned no results"));
switch (result->choice)
{
/* If the callback wants to use one of the fulltexts
to resolve the conflict, so be it.*/
case svn_wc_conflict_choose_base:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
left, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_theirs_full:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
right, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_mine_full:
{
/* Do nothing to merge_target, let it live untouched! */
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
/* For the case of 3-way file merging, we don't
really distinguish between these return values;
if the callback claims to have "generally
resolved" the situation, we still interpret
that as "OK, we'll assume the merged version is
good to use". */
case svn_wc_conflict_choose_merged:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
/* Look for callback's own merged-file first: */
result->merged_file ?
result->merged_file : result_target,
merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_postpone:
default:
{
/* Assume conflict remains, fall through to code below. */
}
}
}
/* Preserve the three pre-merge files, and modify the
entry (mark as conflicted, track the preserved files). */
/* I miss Lisp. */
SVN_ERR(svn_io_open_unique_file2(NULL,
&left_copy,
merge_target,
left_label,
svn_io_file_del_none,
pool));
/* Have I mentioned how much I miss Lisp? */
SVN_ERR(svn_io_open_unique_file2(NULL,
&right_copy,
merge_target,
right_label,
svn_io_file_del_none,
pool));
/* Why, how much more pleasant to be forced to unroll my loops.
If I'd been writing in Lisp, I might have mapped an inline
lambda form over a list, or something equally disgusting.
Thank goodness C was here to protect me! */
SVN_ERR(svn_io_open_unique_file2(NULL,
&target_copy,
merge_target,
target_label,
svn_io_file_del_none,
pool));
/* We preserve all the files with keywords expanded and line
endings in local (working) form. */
svn_path_split(target_copy, &parentt, &target_base, pool);
SVN_ERR(svn_wc_adm_retrieve(&parent_access, adm_access, parentt,
pool));
/* Log files require their paths to be in the subtree
relative to the adm_access path they are executed in.
Make our LEFT and RIGHT files 'local' if they aren't... */
if (! svn_path_is_child(adm_path, left, pool))
{
SVN_ERR(svn_wc_create_tmp_file2
(NULL, &tmp_left,
adm_path, svn_io_file_del_none, pool));
SVN_ERR(svn_io_copy_file(left, tmp_left, TRUE, pool));
}
else
tmp_left = left;
if (! svn_path_is_child(adm_path, right, pool))
{
SVN_ERR(svn_wc_create_tmp_file2
(NULL, &tmp_right,
adm_path, svn_io_file_del_none, pool));
SVN_ERR(svn_io_copy_file(right, tmp_right, TRUE, pool));
}
else
tmp_right = right;
/* NOTE: Callers must ensure that the svn:eol-style and
svn:keywords property values are correct in the currently
installed props. With 'svn merge', it's no big deal. But
when 'svn up' calls this routine, it needs to make sure that
this routine is using the newest property values that may
have been received *during* the update. Since this routine
will be run from within a log-command, merge_file()
needs to make sure that a previous log-command to 'install
latest props' has already executed first. Ben and I just
checked, and that is indeed the order in which the log items
are written, so everything should be fine. Really. */
/* Create LEFT and RIGHT backup files, in expanded form.
We use merge_target's current properties to do the translation. */
/* Derive the basenames of the 3 backup files. */
SVN_ERR(svn_wc__loggy_translated_file(log_accum,
adm_access,
left_copy, tmp_left,
merge_target, pool));
SVN_ERR(svn_wc__loggy_translated_file(log_accum,
adm_access,
right_copy, tmp_right,
merge_target, pool));
/* Back up MERGE_TARGET through detranslation/retranslation:
the new translation properties may not match the current ones */
SVN_ERR(svn_wc_translated_file2(&tmp_target_copy,
merge_target,
merge_target,
adm_access,
SVN_WC_TRANSLATE_TO_NF
| SVN_WC_TRANSLATE_NO_OUTPUT_CLEANUP,
pool));
SVN_ERR(svn_wc__loggy_translated_file
(log_accum, adm_access,
target_copy, tmp_target_copy, merge_target, pool));
tmp_entry.conflict_old
= svn_path_is_child(adm_path, left_copy, pool);
tmp_entry.conflict_new
= svn_path_is_child(adm_path, right_copy, pool);
tmp_entry.conflict_wrk = target_base;
/* Mark merge_target's entry as "Conflicted", and start tracking
the backup files in the entry as well. */
SVN_ERR(svn_wc__loggy_entry_modify
(log_accum, adm_access,
merge_target, &tmp_entry,
SVN_WC__ENTRY_MODIFY_CONFLICT_OLD
| SVN_WC__ENTRY_MODIFY_CONFLICT_NEW
| SVN_WC__ENTRY_MODIFY_CONFLICT_WRK,
pool));
*merge_outcome = svn_wc_merge_conflict;
}
else if (contains_conflicts && dry_run)
{
*merge_outcome = svn_wc_merge_conflict;
} /* end of conflict handling */
else if (copyfrom_text)
{
*merge_outcome = svn_wc_merge_merged;
}
else
{
svn_boolean_t same, special;
/* If 'special', then use the detranslated form of the
target file. This is so we don't try to follow symlinks,
but the same treatment is probably also appropriate for
whatever special file types we may invent in the future. */
SVN_ERR(svn_wc__get_special(&special, merge_target,
adm_access, pool));
SVN_ERR(svn_io_files_contents_same_p(&same, result_target,
(special ?
tmp_target :
merge_target),
pool));
*merge_outcome = same ? svn_wc_merge_unchanged : svn_wc_merge_merged;
}
if (*merge_outcome != svn_wc_merge_unchanged && ! dry_run)
/* replace MERGE_TARGET with the new merged file, expanding. */
SVN_ERR(svn_wc__loggy_copy(log_accum, NULL,
adm_access,
svn_wc__copy_translate,
result_target, merge_target,
FALSE, pool));
} /* end of merging for text files */
else if (! dry_run) /* merging procedure for binary files */
{
/* ### when making the binary-file backups, should we be honoring
keywords and eol stuff? */
const char *left_copy, *right_copy;
const char *parentt, *left_base, *right_base;
svn_wc_entry_t tmp_entry;
/* Give the conflict resolution callback a chance to clean
up the conflict before we mark the file 'conflicted' */
if (conflict_func)
{
svn_wc_conflict_result_t *result = NULL;
svn_wc_conflict_description_t cdesc;
cdesc.path = merge_target;
cdesc.node_kind = svn_node_file;
cdesc.kind = svn_wc_conflict_kind_text;
cdesc.is_binary = TRUE;
cdesc.mime_type = (mimeprop && mimeprop->value)
? mimeprop->value->data : NULL;
cdesc.access = adm_access;
cdesc.action = svn_wc_conflict_action_edit;
cdesc.reason = svn_wc_conflict_reason_edited;
cdesc.base_file = left;
cdesc.their_file = right;
cdesc.my_file = tmp_target;
cdesc.merged_file = NULL; /* notice there is NO merged file! */
cdesc.property_name = NULL;
SVN_ERR(conflict_func(&result, &cdesc, conflict_baton, pool));
if (result == NULL)
return svn_error_create(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
NULL, _("Conflict callback violated API:"
" returned no results"));
switch (result->choice)
{
/* For a binary file, there's no merged file to look at,
unless the conflict-callback did the merging itself. */
case svn_wc_conflict_choose_base:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
left, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_theirs_full:
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
right, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
/* For a binary file, if the response is to use the
user's file, we do nothing. We also do nothing if
the response claims to have already resolved the
problem.*/
case svn_wc_conflict_choose_mine_full:
{
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
case svn_wc_conflict_choose_merged:
{
if (! result->merged_file)
{
/* Callback asked us to choose its own
merged file, but didn't provide one! */
return svn_error_create
(SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE,
NULL, _("Conflict callback violated API:"
" returned no merged file"));
}
else
{
SVN_ERR(svn_wc__loggy_copy
(log_accum, NULL, adm_access,
svn_wc__copy_translate,
result->merged_file, merge_target,
FALSE, pool));
*merge_outcome = svn_wc_merge_merged;
contains_conflicts = FALSE;
goto merge_complete;
}
}
case svn_wc_conflict_choose_postpone:
default:
{
/* Assume conflict remains, fall through to code below. */
}
}
}
/* reserve names for backups of left and right fulltexts */
SVN_ERR(svn_io_open_unique_file2(NULL,
&left_copy,
merge_target,
left_label,
svn_io_file_del_none,
pool));
SVN_ERR(svn_io_open_unique_file2(NULL,
&right_copy,
merge_target,
right_label,
svn_io_file_del_none,
pool));
/* create the backup files */
SVN_ERR(svn_io_copy_file(left,
left_copy, TRUE, pool));
SVN_ERR(svn_io_copy_file(right,
right_copy, TRUE, pool));
/* Was the merge target detranslated? */
if (merge_target != tmp_target)
{
/* Create a .mine file too */
const char *mine_copy;
SVN_ERR(svn_io_open_unique_file2(NULL,
&mine_copy,
merge_target,
target_label,
svn_io_file_del_none,
pool));
SVN_ERR(svn_wc__loggy_move(log_accum, NULL,
adm_access,
tmp_target,
mine_copy,
FALSE, pool));
mine_copy = svn_path_is_child(adm_path, mine_copy, pool);
tmp_entry.conflict_wrk = mine_copy;
}
else
tmp_entry.conflict_wrk = NULL;
/* Derive the basenames of the backup files. */
svn_path_split(left_copy, &parentt, &left_base, pool);
svn_path_split(right_copy, &parentt, &right_base, pool);
/* Mark merge_target's entry as "Conflicted", and start tracking
the backup files in the entry as well. */
tmp_entry.conflict_old = left_base;
tmp_entry.conflict_new = right_base;
SVN_ERR(svn_wc__loggy_entry_modify
(log_accum,
adm_access, merge_target,
&tmp_entry,
SVN_WC__ENTRY_MODIFY_CONFLICT_OLD
| SVN_WC__ENTRY_MODIFY_CONFLICT_NEW
| SVN_WC__ENTRY_MODIFY_CONFLICT_WRK,
pool));
*merge_outcome = svn_wc_merge_conflict; /* a conflict happened */
} /* end of binary conflict handling */
else
*merge_outcome = svn_wc_merge_conflict; /* dry_run for binary files. */
merge_complete:
/* Merging is complete. Regardless of text or binariness, we might
need to tweak the executable bit on the new working file. */
if (! dry_run)
{
SVN_ERR(svn_wc__loggy_maybe_set_executable(log_accum,
adm_access, merge_target,
pool));
SVN_ERR(svn_wc__loggy_maybe_set_readonly(log_accum,
adm_access, merge_target,
pool));
}
return SVN_NO_ERROR;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__propedit(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;
/* Validate the input and 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));
if (! svn_prop_name_is_valid(pname_utf8))
return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
_("'%s' is not a valid Subversion property name"),
pname_utf8);
if (opt_state->encoding && !svn_prop_needs_translation(pname_utf8))
return svn_error_create
(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("--encoding option applies only to textual"
" Subversion-controlled properties"));
/* Suck up all the remaining arguments into a targets array */
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, pool));
if (opt_state->revprop) /* operate on a revprop */
{
svn_revnum_t rev;
const char *URL;
svn_string_t *propval;
svn_string_t original_propval;
const char *temp_dir;
/* Implicit "." is okay for revision properties; it just helps
us find the right repository. */
svn_opt_push_implicit_dot_target(targets, pool);
SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets,
&URL, pool));
/* Fetch the current property. */
SVN_ERR(svn_client_revprop_get(pname_utf8, &propval,
URL, &(opt_state->start_revision),
&rev, ctx, pool));
if (! propval)
{
propval = svn_string_create("", pool);
/* This is how we signify to svn_client_revprop_set2() that
we want it to check that the original value hasn't
changed, but that that original value was non-existent: */
original_propval.data = NULL; /* and .len is ignored */
}
else
{
original_propval = *propval;
}
/* Run the editor on a temporary file which contains the
original property value... */
SVN_ERR(svn_io_temp_dir(&temp_dir, pool));
SVN_ERR(svn_cl__edit_string_externally
(&propval, NULL,
opt_state->editor_cmd, temp_dir,
propval, "svn-prop",
ctx->config,
svn_prop_needs_translation(pname_utf8),
opt_state->encoding, pool));
/* ...and re-set the property's value accordingly. */
if (propval)
{
SVN_ERR(svn_client_revprop_set2(pname_utf8,
propval, &original_propval,
URL, &(opt_state->start_revision),
&rev, opt_state->force, ctx, pool));
SVN_ERR
(svn_cmdline_printf
(pool,
_("Set new value for property '%s' on revision %ld\n"),
pname_utf8, rev));
}
else
{
SVN_ERR(svn_cmdline_printf
(pool, _("No changes to property '%s' on 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 editing versioned property '%s'"),
pname_utf8);
}
else /* operate on a normal, versioned property (not a revprop) */
{
apr_pool_t *subpool = svn_pool_create(pool);
/* The customary implicit dot rule has been prone to user error
* here. For example, Jon Trowbridge <*****@*****.**> did
*
* $ svn propedit HACKING
*
* and then when he closed his editor, he was surprised to see
*
* Set new value for property 'HACKING' on ''
*
* ...meaning that the property named 'HACKING' had been set on
* the current working directory, with the value taken from the
* editor. So we don't do the implicit dot thing anymore; an
* explicit target is always required when editing a versioned
* property.
*/
if (targets->nelts == 0)
{
return svn_error_create
(SVN_ERR_CL_INSUFFICIENT_ARGS, NULL,
_("Explicit target argument required"));
}
SVN_ERR(svn_opt__eat_peg_revisions(&targets, targets, pool));
/* For each target, edit the property PNAME. */
for (i = 0; i < targets->nelts; i++)
{
apr_hash_t *props;
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_string_t *propval, *edited_propval;
const char *base_dir = target;
const char *target_local;
svn_wc_adm_access_t *adm_access;
const svn_wc_entry_t *entry;
svn_opt_revision_t peg_revision;
svn_revnum_t base_rev = SVN_INVALID_REVNUM;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Propedits can only happen on HEAD or the working copy, so
the peg revision can be as unspecified. */
peg_revision.kind = svn_opt_revision_unspecified;
/* Fetch the current property. */
SVN_ERR(svn_client_propget3(&props, pname_utf8, target,
&peg_revision,
&(opt_state->start_revision),
&base_rev, svn_depth_empty,
NULL, ctx, subpool));
/* Get the property value. */
propval = apr_hash_get(props, target, APR_HASH_KEY_STRING);
if (! propval)
propval = svn_string_create("", subpool);
if (svn_path_is_url(target))
{
/* For URLs, put the temporary file in the current directory. */
base_dir = ".";
}
else
{
if (opt_state->message || opt_state->filedata ||
opt_state->revprop_table)
{
return svn_error_create
(SVN_ERR_CL_UNNECESSARY_LOG_MESSAGE, NULL,
_("Local, non-commit operations do not take a log message "
"or revision properties"));
}
/* Split the path if it is a file path. */
SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, target,
FALSE, 0, ctx->cancel_func,
ctx->cancel_baton, subpool));
SVN_ERR(svn_wc_entry(&entry, target, adm_access, FALSE, subpool));
if (! entry)
return svn_error_createf
(SVN_ERR_ENTRY_NOT_FOUND, NULL,
_("'%s' does not appear to be a working copy path"), target);
if (entry->kind == svn_node_file)
svn_path_split(target, &base_dir, NULL, subpool);
}
/* Run the editor on a temporary file which contains the
original property value... */
SVN_ERR(svn_cl__edit_string_externally(&edited_propval, NULL,
opt_state->editor_cmd,
base_dir,
propval,
"svn-prop",
ctx->config,
svn_prop_needs_translation
(pname_utf8),
opt_state->encoding,
subpool));
target_local = svn_path_is_url(target) ? target
: svn_path_local_style(target, subpool);
/* ...and re-set the property's value accordingly. */
if (edited_propval && !svn_string_compare(propval, edited_propval))
{
svn_commit_info_t *commit_info = NULL;
svn_error_t *err = SVN_NO_ERROR;
svn_cl__check_boolean_prop_val(pname_utf8, edited_propval->data,
subpool);
if (ctx->log_msg_func3)
SVN_ERR(svn_cl__make_log_msg_baton(&(ctx->log_msg_baton3),
opt_state, NULL, ctx->config,
subpool));
err = svn_client_propset3(&commit_info,
pname_utf8, edited_propval, target,
svn_depth_empty, opt_state->force,
base_rev, NULL, opt_state->revprop_table,
ctx, subpool);
if (ctx->log_msg_func3)
SVN_ERR(svn_cl__cleanup_log_msg(ctx->log_msg_baton3,
err, pool));
else if (err)
return err;
/* Print a message if we successfully committed or if it
was just a wc propset (but not if the user aborted an URL
propedit). */
if (commit_info || ! svn_path_is_url(target))
SVN_ERR
(svn_cmdline_printf
(subpool, _("Set new value for property '%s' on '%s'\n"),
pname_utf8, target_local));
if (commit_info && ! opt_state->quiet)
SVN_ERR(svn_cl__print_commit_info(commit_info, subpool));
}
else
{
SVN_ERR
(svn_cmdline_printf
(subpool, _("No changes to property '%s' on '%s'\n"),
pname_utf8, target_local));
}
}
svn_pool_destroy(subpool);
}
return SVN_NO_ERROR;
}
