static svn_error_t *
dir_change_prop(void *dir_baton,
const char *name,
const svn_string_t *value,
apr_pool_t *scratch_pool)
{
struct dir_baton_t *db = dir_baton;
struct edit_baton_t *eb = db->eb;
svn_prop_kind_t prop_kind;
prop_kind = svn_property_kind2(name);
if (prop_kind != svn_prop_regular_kind
|| ! strcmp(name, SVN_PROP_MERGEINFO))
{
/* We can't handle DAV, ENTRY and merge specific props here */
return SVN_NO_ERROR;
}
if (! db->created)
{
/* We can still store them in the hash for immediate addition
with the svn_wc_add_from_disk3() call */
if (! db->properties)
db->properties = apr_hash_make(db->pool);
if (value != NULL)
svn_hash_sets(db->properties, apr_pstrdup(db->pool, name),
svn_string_dup(value, db->pool));
}
else
{
/* We have already notified for this directory, so don't do that again */
SVN_ERR(svn_wc_prop_set4(eb->wc_ctx, db->local_abspath, name, value,
svn_depth_empty, FALSE, NULL,
NULL, NULL, /* Cancellation */
NULL, NULL, /* Notification */
scratch_pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_serf__deliver_svn_props(void *baton,
const char *path,
const char *ns,
const char *name,
const svn_string_t *value,
apr_pool_t *scratch_pool)
{
apr_hash_t *props = baton;
apr_pool_t *result_pool = apr_hash_pool_get(props);
const char *prop_name;
prop_name = svn_ra_serf__svnname_from_wirename(ns, name, result_pool);
if (prop_name == NULL)
return SVN_NO_ERROR;
svn_hash_sets(props, prop_name, svn_string_dup(value, result_pool));
return SVN_NO_ERROR;
}
apr_hash_t *
svn_prop_hash_dup(const apr_hash_t *hash,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
apr_hash_t *new_hash = apr_hash_make(pool);
for (hi = apr_hash_first(pool, (apr_hash_t *)hash); hi;
hi = apr_hash_next(hi))
{
const void *key;
apr_ssize_t klen;
void *prop;
apr_hash_this(hi, &key, &klen, &prop);
apr_hash_set(new_hash, apr_pstrmemdup(pool, key, klen), klen,
svn_string_dup(prop, pool));
}
return new_hash;
}
/* Subversion delta editor callback */
static svn_error_t *de_change_dir_prop(void *dir_baton, const char *name, const svn_string_t *value, apr_pool_t *pool)
{
de_node_baton_t *node = (de_node_baton_t *)dir_baton;
/* We're only interested in regular properties */
if (svn_property_kind(NULL, name) != svn_prop_regular_kind) {
return SVN_NO_ERROR;
}
DEBUG_MSG("de_change_dir_prop(%s) %s = %s\n", ((de_node_baton_t *)dir_baton)->path, name, value ? value->data : NULL);
if (value != NULL) {
apr_hash_set(node->properties, apr_pstrdup(node->pool, name), APR_HASH_KEY_STRING, svn_string_dup(value, node->pool));
} else {
apr_hash_set(node->del_properties, apr_pstrdup(node->pool, name), APR_HASH_KEY_STRING, (void *)0x1);
}
node->props_changed = 1;
node->dump_needed = 1;
return SVN_NO_ERROR;
}
static svn_error_t *
file_change_prop(void *file_baton,
const char *name,
const svn_string_t *value,
apr_pool_t *scratch_pool)
{
struct file_baton_t *fb = file_baton;
struct edit_baton_t *eb = fb->eb;
svn_prop_kind_t prop_kind;
prop_kind = svn_property_kind2(name);
if (prop_kind != svn_prop_regular_kind
|| (eb->ignore_mergeinfo_changes && ! strcmp(name, SVN_PROP_MERGEINFO)))
{
/* We can't handle DAV, ENTRY and merge specific props here */
return SVN_NO_ERROR;
}
if (! fb->created)
{
/* Store properties to be added later in svn_wc_add_from_disk3() */
if (! fb->properties)
fb->properties = apr_hash_make(fb->pool);
if (value != NULL)
svn_hash_sets(fb->properties, apr_pstrdup(fb->pool, name),
svn_string_dup(value, fb->pool));
}
else
{
SVN_ERR(svn_wc_prop_set4(eb->wc_ctx, fb->local_abspath, name, value,
svn_depth_empty, FALSE, NULL,
NULL, NULL, /* Cancellation */
NULL, NULL, /* Notification */
scratch_pool));
}
return SVN_NO_ERROR;
}
/* Set PROPS for NS:NAME VAL. Helper for propfind_closed */
static void
set_ns_prop(apr_hash_t *ns_props,
const char *ns, const char *name,
const svn_string_t *val, apr_pool_t *result_pool)
{
apr_hash_t *props = svn_hash_gets(ns_props, ns);
if (!props)
{
props = apr_hash_make(result_pool);
ns = apr_pstrdup(result_pool, ns);
svn_hash_sets(ns_props, ns, props);
}
if (val)
{
name = apr_pstrdup(result_pool, name);
val = svn_string_dup(val, result_pool);
}
svn_hash_sets(props, name, val);
}
static svn_error_t *
set_revision_property(void *baton,
const char *name,
const svn_string_t *value)
{
struct revision_baton *rb = baton;
/* If we're skipping this revision, we're done here. */
if (rb->skipped)
return SVN_NO_ERROR;
if (rb->rev > 0)
{
if (rb->pb->validate_props)
SVN_ERR(svn_repos_fs_change_txn_prop(rb->txn, name, value, rb->pool));
else
SVN_ERR(svn_fs_change_txn_prop(rb->txn, name, value, rb->pool));
/* Remember any datestamp that passes through! (See comment in
close_revision() below.) */
if (! strcmp(name, SVN_PROP_REVISION_DATE))
rb->datestamp = svn_string_dup(value, rb->pool);
}
else if (rb->rev == 0)
{
/* Special case: set revision 0 properties when loading into an
'empty' filesystem. */
struct parse_baton *pb = rb->pb;
svn_revnum_t youngest_rev;
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, pb->fs, rb->pool));
if (youngest_rev == 0)
SVN_ERR(change_rev_prop(pb->repos, 0, name, value,
pb->validate_props, rb->pool));
}
return SVN_NO_ERROR;
}
/* Conforms to svn_ra_serf__xml_closed_t */
static svn_error_t *
blame_closed(svn_ra_serf__xml_estate_t *xes,
void *baton,
int leaving_state,
const svn_string_t *cdata,
apr_hash_t *attrs,
apr_pool_t *scratch_pool)
{
blame_context_t *blame_ctx = baton;
if (leaving_state == FILE_REV)
{
/* Note that we test STREAM, but any pointer is currently invalid.
It was closed when left the TXDELTA state. */
if (blame_ctx->stream == NULL)
{
const char *path;
const char *rev;
path = svn_hash_gets(attrs, "path");
rev = svn_hash_gets(attrs, "rev");
/* Send a "no content" notification. */
SVN_ERR(blame_ctx->file_rev(blame_ctx->file_rev_baton,
path, SVN_STR_TO_REV(rev),
blame_ctx->rev_props,
FALSE /* result_of_merge */,
NULL, NULL, /* txdelta / baton */
blame_ctx->prop_diffs,
scratch_pool));
}
}
else if (leaving_state == MERGED_REVISION)
{
svn_ra_serf__xml_note(xes, FILE_REV, "merged-revision", "*");
}
else if (leaving_state == TXDELTA)
{
SVN_ERR(svn_stream_close(blame_ctx->stream));
}
else
{
const char *name;
const svn_string_t *value;
SVN_ERR_ASSERT(leaving_state == REV_PROP
|| leaving_state == SET_PROP
|| leaving_state == REMOVE_PROP);
name = apr_pstrdup(blame_ctx->state_pool,
svn_hash_gets(attrs, "name"));
if (leaving_state == REMOVE_PROP)
{
value = NULL;
}
else
{
const char *encoding = svn_hash_gets(attrs, "encoding");
if (encoding && strcmp(encoding, "base64") == 0)
value = svn_base64_decode_string(cdata, blame_ctx->state_pool);
else
value = svn_string_dup(cdata, blame_ctx->state_pool);
}
if (leaving_state == REV_PROP)
{
svn_hash_sets(blame_ctx->rev_props, name, value);
}
else
{
svn_prop_t *prop = apr_array_push(blame_ctx->prop_diffs);
prop->name = name;
prop->value = value;
}
}
return SVN_NO_ERROR;
}
/* Helper for the remote case of svn_client_proplist.
*
* Push a new 'svn_client_proplist_item_t *' item onto PROPLIST,
* containing the properties for "TARGET_PREFIX/TARGET_RELATIVE" in
* REVNUM, obtained using RA_LIB and SESSION. The item->node_name
* will be "TARGET_PREFIX/TARGET_RELATIVE", and the value will be a
* hash mapping 'const char *' property names onto 'svn_string_t *'
* property values.
*
* Allocate the new item and its contents in POOL.
* Do all looping, recursion, and temporary work in SCRATCHPOOL.
*
* KIND is the kind of the node at "TARGET_PREFIX/TARGET_RELATIVE".
*
* If the target is a directory, only fetch properties for the files
* and directories at depth DEPTH.
*/
static svn_error_t *
remote_proplist(const char *target_prefix,
const char *target_relative,
svn_node_kind_t kind,
svn_revnum_t revnum,
svn_ra_session_t *ra_session,
svn_depth_t depth,
svn_proplist_receiver_t receiver,
void *receiver_baton,
apr_pool_t *pool,
apr_pool_t *scratchpool)
{
apr_hash_t *dirents;
apr_hash_t *prop_hash, *final_hash;
apr_hash_index_t *hi;
const char *target_full_url =
svn_path_url_add_component2(target_prefix, target_relative, scratchpool);
if (kind == svn_node_dir)
{
SVN_ERR(svn_ra_get_dir2(ra_session,
(depth > svn_depth_empty) ? &dirents : NULL,
NULL, &prop_hash, target_relative, revnum,
SVN_DIRENT_KIND, scratchpool));
}
else if (kind == svn_node_file)
{
SVN_ERR(svn_ra_get_file(ra_session, target_relative, revnum,
NULL, NULL, &prop_hash, scratchpool));
}
else
{
return svn_error_createf(SVN_ERR_NODE_UNKNOWN_KIND, NULL,
_("Unknown node kind for '%s'"),
target_full_url);
}
/* Filter out non-regular properties, since the RA layer returns all
kinds. Copy regular properties keys/vals from the prop_hash
allocated in SCRATCHPOOL to the "final" hash allocated in POOL. */
final_hash = apr_hash_make(pool);
for (hi = apr_hash_first(scratchpool, prop_hash);
hi;
hi = apr_hash_next(hi))
{
const char *name = svn__apr_hash_index_key(hi);
apr_ssize_t klen = svn__apr_hash_index_klen(hi);
svn_string_t *value = svn__apr_hash_index_val(hi);
svn_prop_kind_t prop_kind;
prop_kind = svn_property_kind(NULL, name);
if (prop_kind == svn_prop_regular_kind)
{
name = apr_pstrdup(pool, name);
value = svn_string_dup(value, pool);
apr_hash_set(final_hash, name, klen, value);
}
}
SVN_ERR(call_receiver(target_full_url, final_hash, receiver, receiver_baton,
pool));
if (depth > svn_depth_empty
&& (kind == svn_node_dir) && (apr_hash_count(dirents) > 0))
{
apr_pool_t *subpool = svn_pool_create(scratchpool);
for (hi = apr_hash_first(scratchpool, dirents);
hi;
hi = apr_hash_next(hi))
{
const char *this_name = svn__apr_hash_index_key(hi);
svn_dirent_t *this_ent = svn__apr_hash_index_val(hi);
const char *new_target_relative;
svn_pool_clear(subpool);
new_target_relative = svn_relpath_join(target_relative,
this_name, subpool);
if (this_ent->kind == svn_node_file
|| depth > svn_depth_files)
{
svn_depth_t depth_below_here = depth;
if (depth == svn_depth_immediates)
depth_below_here = svn_depth_empty;
SVN_ERR(remote_proplist(target_prefix,
new_target_relative,
this_ent->kind,
revnum,
ra_session,
depth_below_here,
receiver,
receiver_baton,
pool,
subpool));
}
}
svn_pool_destroy(subpool);
}
return SVN_NO_ERROR;
}
/* Helper for the remote case of svn_client_propget.
*
* Get the value of property PROPNAME in REVNUM, using RA_LIB and
* SESSION. Store the value ('svn_string_t *') in PROPS, under the
* path key "TARGET_PREFIX/TARGET_RELATIVE" ('const char *').
*
* Recurse according to DEPTH, similarly to svn_client_propget3().
*
* KIND is the kind of the node at "TARGET_PREFIX/TARGET_RELATIVE".
* Yes, caller passes this; it makes the recursion more efficient :-).
*
* Allocate the keys and values in PERM_POOL, but do all temporary
* work in WORK_POOL. The two pools can be the same; recursive
* calls may use a different WORK_POOL, however.
*/
static svn_error_t *
remote_propget(apr_hash_t *props,
const char *propname,
const char *target_prefix,
const char *target_relative,
svn_node_kind_t kind,
svn_revnum_t revnum,
svn_ra_session_t *ra_session,
svn_depth_t depth,
apr_pool_t *perm_pool,
apr_pool_t *work_pool)
{
apr_hash_t *dirents;
apr_hash_t *prop_hash;
const svn_string_t *val;
const char *target_full_url =
svn_path_url_add_component2(target_prefix, target_relative, work_pool);
if (kind == svn_node_dir)
{
SVN_ERR(svn_ra_get_dir2(ra_session,
(depth >= svn_depth_files ? &dirents : NULL),
NULL, &prop_hash, target_relative, revnum,
SVN_DIRENT_KIND, work_pool));
}
else if (kind == svn_node_file)
{
SVN_ERR(svn_ra_get_file(ra_session, target_relative, revnum,
NULL, NULL, &prop_hash, work_pool));
}
else if (kind == svn_node_none)
{
return svn_error_createf(SVN_ERR_ENTRY_NOT_FOUND, NULL,
_("'%s' does not exist in revision %ld"),
target_full_url, revnum);
}
else
{
return svn_error_createf(SVN_ERR_NODE_UNKNOWN_KIND, NULL,
_("Unknown node kind for '%s'"),
target_full_url);
}
if ((val = apr_hash_get(prop_hash, propname, APR_HASH_KEY_STRING)))
{
apr_hash_set(props, apr_pstrdup(perm_pool, target_full_url),
APR_HASH_KEY_STRING, svn_string_dup(val, perm_pool));
}
if (depth >= svn_depth_files
&& kind == svn_node_dir
&& apr_hash_count(dirents) > 0)
{
apr_hash_index_t *hi;
apr_pool_t *iterpool = svn_pool_create(work_pool);
for (hi = apr_hash_first(work_pool, dirents);
hi;
hi = apr_hash_next(hi))
{
const char *this_name = svn__apr_hash_index_key(hi);
svn_dirent_t *this_ent = svn__apr_hash_index_val(hi);
const char *new_target_relative;
svn_depth_t depth_below_here = depth;
svn_pool_clear(iterpool);
if (depth == svn_depth_files && this_ent->kind == svn_node_dir)
continue;
if (depth == svn_depth_files || depth == svn_depth_immediates)
depth_below_here = svn_depth_empty;
new_target_relative = svn_relpath_join(target_relative, this_name,
iterpool);
SVN_ERR(remote_propget(props,
propname,
target_prefix,
new_target_relative,
this_ent->kind,
revnum,
ra_session,
depth_below_here,
perm_pool, iterpool));
}
svn_pool_destroy(iterpool);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_cl__edit_string_externally(svn_string_t **edited_contents /* UTF-8! */,
const char **tmpfile_left /* UTF-8! */,
const char *editor_cmd,
const char *base_dir /* UTF-8! */,
const svn_string_t *contents /* UTF-8! */,
const char *filename,
apr_hash_t *config,
svn_boolean_t as_text,
const char *encoding,
apr_pool_t *pool)
{
const char *editor;
const char *cmd;
apr_file_t *tmp_file;
const char *tmpfile_name;
const char *tmpfile_native;
const char *tmpfile_apr, *base_dir_apr;
svn_string_t *translated_contents;
apr_status_t apr_err, apr_err2;
apr_size_t written;
apr_finfo_t finfo_before, finfo_after;
svn_error_t *err = SVN_NO_ERROR, *err2;
char *old_cwd;
int sys_err;
svn_boolean_t remove_file = TRUE;
SVN_ERR(find_editor_binary(&editor, editor_cmd, config));
/* Convert file contents from UTF-8/LF if desired. */
if (as_text)
{
const char *translated;
SVN_ERR(svn_subst_translate_cstring2(contents->data, &translated,
APR_EOL_STR, FALSE,
NULL, FALSE, pool));
translated_contents = svn_string_create("", pool);
if (encoding)
SVN_ERR(svn_utf_cstring_from_utf8_ex2(&translated_contents->data,
translated, encoding, pool));
else
SVN_ERR(svn_utf_cstring_from_utf8(&translated_contents->data,
translated, pool));
translated_contents->len = strlen(translated_contents->data);
}
else
translated_contents = svn_string_dup(contents, pool);
/* Move to BASE_DIR to avoid getting characters that need quoting
into tmpfile_name */
apr_err = apr_filepath_get(&old_cwd, APR_FILEPATH_NATIVE, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, _("Can't get working directory"));
/* APR doesn't like "" directories */
if (base_dir[0] == '\0')
base_dir_apr = ".";
else
SVN_ERR(svn_path_cstring_from_utf8(&base_dir_apr, base_dir, pool));
apr_err = apr_filepath_set(base_dir_apr, pool);
if (apr_err)
{
return svn_error_wrap_apr
(apr_err, _("Can't change working directory to '%s'"), base_dir);
}
/*** From here on, any problems that occur require us to cd back!! ***/
/* Ask the working copy for a temporary file named FILENAME-something. */
err = svn_io_open_uniquely_named(&tmp_file, &tmpfile_name,
"" /* dirpath */,
filename,
".tmp",
svn_io_file_del_none, pool, pool);
if (err && (APR_STATUS_IS_EACCES(err->apr_err) || err->apr_err == EROFS))
{
const char *temp_dir_apr;
svn_error_clear(err);
SVN_ERR(svn_io_temp_dir(&base_dir, pool));
SVN_ERR(svn_path_cstring_from_utf8(&temp_dir_apr, base_dir, pool));
apr_err = apr_filepath_set(temp_dir_apr, pool);
if (apr_err)
{
return svn_error_wrap_apr
(apr_err, _("Can't change working directory to '%s'"), base_dir);
}
err = svn_io_open_uniquely_named(&tmp_file, &tmpfile_name,
"" /* dirpath */,
filename,
".tmp",
svn_io_file_del_none, pool, pool);
}
if (err)
goto cleanup2;
/*** From here on, any problems that occur require us to cleanup
the file we just created!! ***/
/* Dump initial CONTENTS to TMP_FILE. */
apr_err = apr_file_write_full(tmp_file, translated_contents->data,
translated_contents->len, &written);
apr_err2 = apr_file_close(tmp_file);
if (! apr_err)
apr_err = apr_err2;
/* Make sure the whole CONTENTS were written, else return an error. */
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't write to '%s'"),
tmpfile_name);
goto cleanup;
}
err = svn_path_cstring_from_utf8(&tmpfile_apr, tmpfile_name, pool);
if (err)
goto cleanup;
/* Get information about the temporary file before the user has
been allowed to edit its contents. */
apr_err = apr_stat(&finfo_before, tmpfile_apr,
APR_FINFO_MTIME, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* Backdate the file a little bit in case the editor is very fast
and doesn't change the size. (Use two seconds, since some
filesystems have coarse granularity.) It's OK if this call
fails, so we don't check its return value.*/
apr_file_mtime_set(tmpfile_apr, finfo_before.mtime - 2000, pool);
/* Stat it again to get the mtime we actually set. */
apr_err = apr_stat(&finfo_before, tmpfile_apr,
APR_FINFO_MTIME | APR_FINFO_SIZE, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* Prepare the editor command line. */
err = svn_utf_cstring_from_utf8(&tmpfile_native, tmpfile_name, pool);
if (err)
goto cleanup;
cmd = apr_psprintf(pool, "%s %s", editor, tmpfile_native);
/* If the caller wants us to leave the file around, return the path
of the file we'll use, and make a note not to destroy it. */
if (tmpfile_left)
{
*tmpfile_left = svn_dirent_join(base_dir, tmpfile_name, pool);
remove_file = FALSE;
}
/* Now, run the editor command line. */
sys_err = system(cmd);
if (sys_err != 0)
{
/* Extracting any meaning from sys_err is platform specific, so just
use the raw value. */
err = svn_error_createf(SVN_ERR_EXTERNAL_PROGRAM, NULL,
_("system('%s') returned %d"), cmd, sys_err);
goto cleanup;
}
/* Get information about the temporary file after the assumed editing. */
apr_err = apr_stat(&finfo_after, tmpfile_apr,
APR_FINFO_MTIME | APR_FINFO_SIZE, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* If the file looks changed... */
if ((finfo_before.mtime != finfo_after.mtime) ||
(finfo_before.size != finfo_after.size))
{
svn_stringbuf_t *edited_contents_s;
err = svn_stringbuf_from_file2(&edited_contents_s, tmpfile_name, pool);
if (err)
goto cleanup;
*edited_contents = svn_stringbuf__morph_into_string(edited_contents_s);
/* Translate back to UTF8/LF if desired. */
if (as_text)
{
err = svn_subst_translate_string2(edited_contents, FALSE, FALSE,
*edited_contents, encoding, FALSE,
pool, pool);
if (err)
{
err = svn_error_quick_wrap
(err,
_("Error normalizing edited contents to internal format"));
goto cleanup;
}
}
}
else
{
/* No edits seem to have been made */
*edited_contents = NULL;
}
cleanup:
if (remove_file)
{
/* Remove the file from disk. */
err2 = svn_io_remove_file2(tmpfile_name, FALSE, pool);
/* Only report remove error if there was no previous error. */
if (! err && err2)
err = err2;
else
svn_error_clear(err2);
}
cleanup2:
/* If we against all probability can't cd back, all further relative
file references would be screwed up, so we have to abort. */
apr_err = apr_filepath_set(old_cwd, pool);
if (apr_err)
{
svn_handle_error2(svn_error_wrap_apr
(apr_err, _("Can't restore working directory")),
stderr, TRUE /* fatal */, "svn: ");
}
return svn_error_trace(err);
}
svn_error_t *
svn_prop_diffs(apr_array_header_t **propdiffs,
const apr_hash_t *target_props,
const apr_hash_t *source_props,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
apr_array_header_t *ary = apr_array_make(pool, 1, sizeof(svn_prop_t));
/* Note: we will be storing the pointers to the keys (from the hashes)
into the propdiffs array. It is acceptable for us to
reference the same memory as the base/target_props hash. */
/* Loop over SOURCE_PROPS and examine each key. This will allow us to
detect any `deletion' events or `set-modification' events. */
for (hi = apr_hash_first(pool, (apr_hash_t *)source_props); hi;
hi = apr_hash_next(hi))
{
const void *key;
apr_ssize_t klen;
void *val;
const svn_string_t *propval1, *propval2;
/* Get next property */
apr_hash_this(hi, &key, &klen, &val);
propval1 = val;
/* Does property name exist in TARGET_PROPS? */
propval2 = apr_hash_get((apr_hash_t *)target_props, key, klen);
if (propval2 == NULL)
{
/* Add a delete event to the array */
svn_prop_t *p = apr_array_push(ary);
p->name = key;
p->value = NULL;
}
else if (! svn_string_compare(propval1, propval2))
{
/* Add a set (modification) event to the array */
svn_prop_t *p = apr_array_push(ary);
p->name = key;
p->value = svn_string_dup(propval2, pool);
}
}
/* Loop over TARGET_PROPS and examine each key. This allows us to
detect `set-creation' events */
for (hi = apr_hash_first(pool, (apr_hash_t *)target_props); hi;
hi = apr_hash_next(hi))
{
const void *key;
apr_ssize_t klen;
void *val;
const svn_string_t *propval;
/* Get next property */
apr_hash_this(hi, &key, &klen, &val);
propval = val;
/* Does property name exist in SOURCE_PROPS? */
if (NULL == apr_hash_get((apr_hash_t *)source_props, key, klen))
{
/* Add a set (creation) event to the array */
svn_prop_t *p = apr_array_push(ary);
p->name = key;
p->value = svn_string_dup(propval, pool);
}
}
/* Done building our array of user events. */
*propdiffs = ary;
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra__get_inherited_props_walk(svn_ra_session_t *session,
const char *path,
svn_revnum_t revision,
apr_array_header_t **inherited_props,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *repos_root_url;
const char *session_url;
const char *parent_url;
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
*inherited_props =
apr_array_make(result_pool, 1, sizeof(svn_prop_inherited_item_t *));
/* Walk to the root of the repository getting inherited
props for PATH. */
SVN_ERR(svn_ra_get_repos_root2(session, &repos_root_url, scratch_pool));
SVN_ERR(svn_ra_get_session_url(session, &session_url, scratch_pool));
parent_url = session_url;
while (strcmp(repos_root_url, parent_url))
{
apr_hash_index_t *hi;
apr_hash_t *parent_props;
apr_hash_t *final_hash = apr_hash_make(result_pool);
svn_error_t *err;
svn_pool_clear(iterpool);
parent_url = svn_uri_dirname(parent_url, scratch_pool);
SVN_ERR(svn_ra_reparent(session, parent_url, iterpool));
err = session->vtable->get_dir(session, NULL, NULL,
&parent_props, "",
revision, SVN_DIRENT_ALL,
iterpool);
/* If the user doesn't have read access to a parent path then
skip, but allow them to inherit from further up. */
if (err)
{
if ((err->apr_err == SVN_ERR_RA_NOT_AUTHORIZED)
|| (err->apr_err == SVN_ERR_RA_DAV_FORBIDDEN))
{
svn_error_clear(err);
continue;
}
else
{
return svn_error_trace(err);
}
}
for (hi = apr_hash_first(scratch_pool, parent_props);
hi;
hi = apr_hash_next(hi))
{
const char *name = apr_hash_this_key(hi);
apr_ssize_t klen = apr_hash_this_key_len(hi);
svn_string_t *value = apr_hash_this_val(hi);
if (svn_property_kind2(name) == svn_prop_regular_kind)
{
name = apr_pstrdup(result_pool, name);
value = svn_string_dup(value, result_pool);
apr_hash_set(final_hash, name, klen, value);
}
}
if (apr_hash_count(final_hash))
{
svn_prop_inherited_item_t *new_iprop =
apr_palloc(result_pool, sizeof(*new_iprop));
new_iprop->path_or_url = svn_uri_skip_ancestor(repos_root_url,
parent_url,
result_pool);
new_iprop->prop_hash = final_hash;
svn_sort__array_insert(*inherited_props, &new_iprop, 0);
}
}
/* Reparent session back to original URL. */
SVN_ERR(svn_ra_reparent(session, session_url, scratch_pool));
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_neon__search_for_starting_props(svn_ra_neon__resource_t **rsrc,
const char **missing_path,
svn_ra_neon__session_t *sess,
const char *url,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
apr_size_t len;
svn_stringbuf_t *path_s;
ne_uri parsed_url;
svn_stringbuf_t *lopped_path =
svn_stringbuf_create(url, pool); /* initialize to make sure it'll fit
without reallocating */
apr_pool_t *iterpool = svn_pool_create(pool);
/* Split the url into its component pieces (scheme, host, path,
etc). We want the path part. */
ne_uri_parse(url, &parsed_url);
if (parsed_url.path == NULL)
{
ne_uri_free(&parsed_url);
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("Neon was unable to parse URL '%s'"), url);
}
svn_stringbuf_setempty(lopped_path);
path_s = svn_stringbuf_create(parsed_url.path, pool);
ne_uri_free(&parsed_url);
/* Try to get the starting_props from the public url. If the
resource no longer exists in HEAD, we'll get a failure. That's
fine: just keep removing components and trying to get the
starting_props from parent directories. */
while (! svn_path_is_empty(path_s->data))
{
svn_pool_clear(iterpool);
err = svn_ra_neon__get_starting_props(rsrc, sess, path_s->data,
NULL, iterpool);
if (! err)
break; /* found an existing parent! */
if (err->apr_err != SVN_ERR_FS_NOT_FOUND)
return err; /* found a _real_ error */
/* else... lop off the basename and try again. */
svn_stringbuf_set(lopped_path,
svn_path_join(svn_path_basename(path_s->data, iterpool),
lopped_path->data, iterpool));
len = path_s->len;
svn_path_remove_component(path_s);
/* if we detect an infinite loop, get out. */
if (path_s->len == len)
return svn_error_quick_wrap
(err, _("The path was not part of a repository"));
svn_error_clear(err);
}
/* error out if entire URL was bogus (not a single part of it exists
in the repository!) */
if (svn_path_is_empty(path_s->data))
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("No part of path '%s' was found in "
"repository HEAD"), parsed_url.path);
/* Duplicate rsrc out of iterpool into pool */
{
apr_hash_index_t *hi;
svn_ra_neon__resource_t *tmp = apr_pcalloc(pool, sizeof(*tmp));
tmp->url = apr_pstrdup(pool, (*rsrc)->url);
tmp->is_collection = (*rsrc)->is_collection;
tmp->pool = pool;
tmp->propset = apr_hash_make(pool);
for (hi = apr_hash_first(iterpool, (*rsrc)->propset);
hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_this(hi, &key, NULL, &val);
apr_hash_set(tmp->propset, apr_pstrdup(pool, key), APR_HASH_KEY_STRING,
svn_string_dup(val, pool));
}
*rsrc = tmp;
}
*missing_path = lopped_path->data;
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}