static void dump_hash(apr_pool_t *p, apr_hash_t *h, char str[][MAX_LTH])
{
apr_hash_index_t *hi;
int i = 0;
for (hi = apr_hash_first(p, h); hi; hi = apr_hash_next(hi)) {
const char *key = apr_hash_this_key(hi);
apr_ssize_t len = apr_hash_this_key_len(hi);
char *val = apr_hash_this_val(hi);
str[i][0]='\0';
apr_snprintf(str[i], MAX_LTH, "%sKey %s (%" APR_SSIZE_T_FMT ") Value %s\n",
str[i], key, len, val);
i++;
}
str[i][0]='\0';
apr_snprintf(str[i], MAX_LTH, "%s#entries %d\n", str[i], i);
/* Sort the result strings so that they can be checked for expected results easily,
* without having to worry about platform quirks
*/
qsort(
str, /* Pointer to elements */
i, /* number of elements */
MAX_LTH, /* size of one element */
comp_string /* Pointer to comparison routine */
);
}
/* Apply each property in PROPS to the node at FSPATH in ROOT. */
static svn_error_t *
add_new_props(svn_fs_root_t *root,
const char *fspath,
apr_hash_t *props,
apr_pool_t *scratch_pool)
{
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
apr_hash_index_t *hi;
/* ### it would be nice to have svn_fs_set_node_props(). but since we
### don't... add each property to the node. this is a new node, so
### we don't need to worry about deleting props. just adding. */
for (hi = apr_hash_first(scratch_pool, props); hi;
hi = apr_hash_next(hi))
{
const char *name = apr_hash_this_key(hi);
const svn_string_t *value = apr_hash_this_val(hi);
svn_pool_clear(iterpool);
SVN_ERR(svn_fs_change_node_prop(root, fspath, name, value, iterpool));
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_close(svn_wc__db_t *db)
{
apr_pool_t *scratch_pool = db->state_pool;
apr_hash_t *roots = apr_hash_make(scratch_pool);
apr_hash_index_t *hi;
/* Collect all the unique WCROOT structures, and empty out DIR_DATA. */
for (hi = apr_hash_first(scratch_pool, db->dir_data);
hi;
hi = apr_hash_next(hi))
{
svn_wc__db_wcroot_t *wcroot = apr_hash_this_val(hi);
const char *local_abspath = apr_hash_this_key(hi);
if (wcroot->sdb)
svn_hash_sets(roots, wcroot->abspath, wcroot);
svn_hash_sets(db->dir_data, local_abspath, NULL);
}
/* Run the cleanup for each WCROOT. */
return svn_error_trace(svn_wc__db_close_many_wcroots(roots, db->state_pool,
scratch_pool));
}
svn_error_t *
svn_wc__db_drop_root(svn_wc__db_t *db,
const char *local_abspath,
apr_pool_t *scratch_pool)
{
svn_wc__db_wcroot_t *root_wcroot = svn_hash_gets(db->dir_data, local_abspath);
apr_hash_index_t *hi;
apr_status_t result;
if (!root_wcroot)
return SVN_NO_ERROR;
if (strcmp(root_wcroot->abspath, local_abspath) != 0)
return svn_error_createf(SVN_ERR_WC_NOT_WORKING_COPY, NULL,
_("'%s' is not a working copy root"),
svn_dirent_local_style(local_abspath,
scratch_pool));
for (hi = apr_hash_first(scratch_pool, db->dir_data);
hi;
hi = apr_hash_next(hi))
{
svn_wc__db_wcroot_t *wcroot = apr_hash_this_val(hi);
if (wcroot == root_wcroot)
svn_hash_sets(db->dir_data, apr_hash_this_key(hi), NULL);
}
result = apr_pool_cleanup_run(db->state_pool, root_wcroot, close_wcroot);
if (result != APR_SUCCESS)
return svn_error_wrap_apr(result, NULL);
return SVN_NO_ERROR;
}
/* Normalize the encoding and line ending style of the values of properties
* in REV_PROPS that "need translation" (according to
* svn_prop_needs_translation(), which is currently all svn:* props) so that
* they are encoded in UTF-8 and contain only LF (\n) line endings.
*
* The number of properties that needed line ending normalization is returned in
* *NORMALIZED_COUNT.
*
* No re-encoding is performed if SOURCE_PROP_ENCODING is NULL.
*/
svn_error_t *
svnsync_normalize_revprops(apr_hash_t *rev_props,
int *normalized_count,
const char *source_prop_encoding,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
*normalized_count = 0;
for (hi = apr_hash_first(pool, rev_props);
hi;
hi = apr_hash_next(hi))
{
const char *propname = apr_hash_this_key(hi);
const svn_string_t *propval = apr_hash_this_val(hi);
if (svn_prop_needs_translation(propname))
{
svn_boolean_t was_normalized;
SVN_ERR(normalize_string(&propval, &was_normalized,
source_prop_encoding, pool, pool));
/* Replace the existing prop value. */
svn_hash_sets(rev_props, propname, propval);
if (was_normalized)
(*normalized_count)++; /* Count it. */
}
}
return SVN_NO_ERROR;
}
static svn_error_t *
remove_node_props(void *baton)
{
struct node_baton *nb = baton;
struct revision_baton *rb = nb->rb;
apr_hash_t *proplist;
apr_hash_index_t *hi;
/* If we're skipping this revision, we're done here. */
if (rb->skipped)
return SVN_NO_ERROR;
SVN_ERR(svn_fs_node_proplist(&proplist,
rb->txn_root, nb->path, nb->pool));
for (hi = apr_hash_first(nb->pool, proplist); hi; hi = apr_hash_next(hi))
{
const char *key = apr_hash_this_key(hi);
SVN_ERR(change_node_prop(rb->txn_root, nb->path, key, NULL,
rb->pb->validate_props, nb->pool));
}
return SVN_NO_ERROR;
}
/* Prepend the mergeinfo source paths in MERGEINFO_ORIG with PARENT_DIR, and
return it in *MERGEINFO_VAL. */
static svn_error_t *
prefix_mergeinfo_paths(svn_string_t **mergeinfo_val,
const svn_string_t *mergeinfo_orig,
const char *parent_dir,
apr_pool_t *pool)
{
apr_hash_t *prefixed_mergeinfo, *mergeinfo;
apr_hash_index_t *hi;
SVN_ERR(svn_mergeinfo_parse(&mergeinfo, mergeinfo_orig->data, pool));
prefixed_mergeinfo = apr_hash_make(pool);
for (hi = apr_hash_first(pool, mergeinfo); hi; hi = apr_hash_next(hi))
{
const char *merge_source = apr_hash_this_key(hi);
svn_rangelist_t *rangelist = apr_hash_this_val(hi);
const char *path;
merge_source = svn_relpath_canonicalize(merge_source, pool);
/* The svn:mergeinfo property syntax demands a repos abspath */
path = svn_fspath__canonicalize(svn_relpath_join(parent_dir,
merge_source, pool),
pool);
svn_hash_sets(prefixed_mergeinfo, path, rangelist);
}
return svn_mergeinfo_to_string(mergeinfo_val, prefixed_mergeinfo, pool);
}
/* Removes all non regular properties from PROPS */
void
svn_ra_serf__keep_only_regular_props(apr_hash_t *props,
apr_pool_t *scratch_pool)
{
apr_hash_index_t *hi;
for (hi = apr_hash_first(scratch_pool, props); hi; hi = apr_hash_next(hi))
{
const char *propname = apr_hash_this_key(hi);
if (svn_property_kind2(propname) != svn_prop_regular_kind)
svn_hash_sets(props, propname, NULL);
}
}
/* Are there any changes to relevant (normal) props in PROPS? */
static svn_boolean_t
props_changed_hash(apr_hash_t *props,
apr_pool_t *scratch_pool)
{
apr_hash_index_t *hi;
if (!props)
return FALSE;
for (hi = apr_hash_first(scratch_pool, props); hi; hi = apr_hash_next(hi))
{
const char *name = apr_hash_this_key(hi);
if (svn_property_kind2(name) == svn_prop_regular_kind)
{
return TRUE;
}
}
return FALSE;
}
svn_error_t *
svn_fs__append_to_merged_froms(svn_mergeinfo_t *output,
svn_mergeinfo_t input,
const char *rel_path,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
*output = apr_hash_make(pool);
for (hi = apr_hash_first(pool, input); hi; hi = apr_hash_next(hi))
{
const char *path = apr_hash_this_key(hi);
svn_rangelist_t *rangelist = apr_hash_this_val(hi);
svn_hash_sets(*output,
svn_fspath__join(path, rel_path, pool),
svn_rangelist_dup(rangelist, pool));
}
return SVN_NO_ERROR;
}
static void get_name(dav_db *db, dav_prop_name *pname)
{
if (db->hi == NULL)
{
pname->ns = pname->name = NULL;
}
else
{
const char *name = apr_hash_this_key(db->hi);
#define PREFIX_LEN (sizeof(SVN_PROP_PREFIX) - 1)
if (strncmp(name, SVN_PROP_PREFIX, PREFIX_LEN) == 0)
#undef PREFIX_LEN
{
pname->ns = SVN_DAV_PROP_NS_SVN;
pname->name = name + 4;
}
else
{
pname->ns = SVN_DAV_PROP_NS_CUSTOM;
pname->name = name;
}
}
}
/* For all lock tokens in ALL_TOKENS for URLs under BASE_URL, add them
to a new hashtable allocated in POOL. *RESULT is set to point to this
new hash table. *RESULT will be keyed on const char * URI-decoded paths
relative to BASE_URL. The lock tokens will not be duplicated. */
static svn_error_t *
collect_lock_tokens(apr_hash_t **result,
apr_hash_t *all_tokens,
const char *base_url,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
*result = apr_hash_make(pool);
for (hi = apr_hash_first(pool, all_tokens); hi; hi = apr_hash_next(hi))
{
const char *url = apr_hash_this_key(hi);
const char *token = apr_hash_this_val(hi);
const char *relpath = svn_uri_skip_ancestor(base_url, url, pool);
if (relpath)
{
svn_hash_sets(*result, relpath, token);
}
}
return SVN_NO_ERROR;
}
/* Conforms to svn_ra_serf__xml_closed_t */
static svn_error_t *
propfind_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)
{
propfind_context_t *ctx = baton;
if (leaving_state == MULTISTATUS)
{
/* We've gathered all the data from the reponse. Add this item
onto the "done list". External callers will then know this
request has been completed (tho stray response bytes may still
arrive). */
}
else if (leaving_state == HREF)
{
const char *path;
if (strcmp(ctx->depth, "1") == 0)
path = svn_urlpath__canonicalize(cdata->data, scratch_pool);
else
path = ctx->path;
svn_ra_serf__xml_note(xes, RESPONSE, "path", path);
SVN_ERR(ctx->prop_func(ctx->prop_func_baton,
path,
D_, "href",
cdata, scratch_pool));
}
else if (leaving_state == COLLECTION)
{
svn_ra_serf__xml_note(xes, PROPVAL, "altvalue", "collection");
}
else if (leaving_state == HREF_VALUE)
{
svn_ra_serf__xml_note(xes, PROPVAL, "altvalue", cdata->data);
}
else if (leaving_state == STATUS)
{
/* Parse the status field, and remember if this is a property
that we wish to ignore. (Typically, if it's not a 200, the
status will be 404 to indicate that a property we
specifically requested from the server doesn't exist.) */
apr_int64_t status = parse_status_code(cdata->data);
if (status != 200)
svn_ra_serf__xml_note(xes, PROPSTAT, "ignore-prop", "*");
}
else if (leaving_state == PROPVAL)
{
const char *encoding;
const svn_string_t *val_str;
const char *ns;
const char *name;
const char *altvalue;
if ((altvalue = svn_hash_gets(attrs, "altvalue")) != NULL)
{
val_str = svn_string_create(altvalue, scratch_pool);
}
else if ((encoding = svn_hash_gets(attrs, "V:encoding")) != NULL)
{
if (strcmp(encoding, "base64") != 0)
return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA,
NULL,
_("Got unrecognized encoding '%s'"),
encoding);
/* Decode into the right pool. */
val_str = svn_base64_decode_string(cdata, scratch_pool);
}
else
{
/* Copy into the right pool. */
val_str = cdata;
}
/* The current path sits on the RESPONSE state.
Now, it would be nice if we could, at this point, know that
the status code for this property indicated a problem -- then
we could simply bail out here and ignore the property.
Sadly, though, we might get the status code *after* we get
the property value. So we'll carry on with our processing
here, setting the property and value as expected. Once we
know for sure the status code associate with the property,
we'll decide its fate. */
ns = svn_hash_gets(attrs, "ns");
name = svn_hash_gets(attrs, "name");
set_ns_prop(ctx->ps_props, ns, name, val_str,
apr_hash_pool_get(ctx->ps_props));
}
else
{
apr_hash_t *gathered;
SVN_ERR_ASSERT(leaving_state == PROPSTAT);
gathered = svn_ra_serf__xml_gather_since(xes, RESPONSE);
/* If we've squirreled away a note that says we want to ignore
these properties, we'll do so. Otherwise, we need to copy
them from the temporary hash into the ctx->ret_props hash. */
if (! svn_hash_gets(gathered, "ignore-prop"))
{
apr_hash_index_t *hi_ns;
const char *path;
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
path = svn_hash_gets(gathered, "path");
if (!path)
path = ctx->path;
for (hi_ns = apr_hash_first(scratch_pool, ctx->ps_props);
hi_ns;
hi_ns = apr_hash_next(hi_ns))
{
const char *ns = apr_hash_this_key(hi_ns);
apr_hash_t *props = apr_hash_this_val(hi_ns);
apr_hash_index_t *hi_prop;
svn_pool_clear(iterpool);
for (hi_prop = apr_hash_first(iterpool, props);
hi_prop;
hi_prop = apr_hash_next(hi_prop))
{
const char *name = apr_hash_this_key(hi_prop);
const svn_string_t *value = apr_hash_this_val(hi_prop);
SVN_ERR(ctx->prop_func(ctx->prop_func_baton, path,
ns, name, value, iterpool));
}
}
svn_pool_destroy(iterpool);
}
ctx->ps_props = NULL; /* Allocated in PROPSTAT state pool */
}
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;
}
dav_error *
dav_svn__get_inherited_props_report(const dav_resource *resource,
const apr_xml_doc *doc,
ap_filter_t *output)
{
svn_error_t *serr;
dav_error *derr = NULL;
apr_xml_elem *child;
apr_array_header_t *inherited_props;
dav_svn__authz_read_baton arb;
int ns;
apr_bucket_brigade *bb;
const char *path = "/";
svn_fs_root_t *root;
int i;
svn_revnum_t rev = SVN_INVALID_REVNUM;
apr_pool_t *iterpool;
/* Sanity check. */
if (!resource->info->repos_path)
return dav_svn__new_error(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not specify a repository path");
ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE);
if (ns == -1)
{
return dav_svn__new_error_svn(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not contain the 'svn:' "
"namespace, so it is not going to have "
"certain required elements");
}
iterpool = svn_pool_create(resource->pool);
for (child = doc->root->first_child;
child != NULL;
child = child->next)
{
/* if this element isn't one of ours, then skip it */
if (child->ns != ns)
continue;
if (strcmp(child->name, SVN_DAV__REVISION) == 0)
{
rev = SVN_STR_TO_REV(dav_xml_get_cdata(child, iterpool, 1));
}
else if (strcmp(child->name, SVN_DAV__PATH) == 0)
{
path = dav_xml_get_cdata(child, resource->pool, 0);
if ((derr = dav_svn__test_canonical(path, iterpool)))
return derr;
path = svn_fspath__join(resource->info->repos_path, path,
resource->pool);
}
/* else unknown element; skip it */
}
/* Build authz read baton */
arb.r = resource->info->r;
arb.repos = resource->info->repos;
/* Build inherited property brigade */
bb = apr_brigade_create(resource->pool, output->c->bucket_alloc);
serr = svn_fs_revision_root(&root, resource->info->repos->fs,
rev, resource->pool);
if (serr != NULL)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"couldn't retrieve revision root",
resource->pool);
serr = svn_repos_fs_get_inherited_props(&inherited_props, root, path, NULL,
dav_svn__authz_read_func(&arb),
&arb, resource->pool, iterpool);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, NULL,
resource->pool);
goto cleanup;
}
serr = dav_svn__brigade_puts(bb, output,
DAV_XML_HEADER DEBUG_CR
"<S:" SVN_DAV__INHERITED_PROPS_REPORT " "
"xmlns:S=\"" SVN_XML_NAMESPACE "\" "
"xmlns:D=\"DAV:\">" DEBUG_CR);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, NULL,
resource->pool);
goto cleanup;
}
for (i = 0; i < inherited_props->nelts; i++)
{
svn_prop_inherited_item_t *elt =
APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *);
svn_pool_clear(iterpool);
serr = dav_svn__brigade_printf(
bb, output,
"<S:" SVN_DAV__IPROP_ITEM ">"
DEBUG_CR
"<S:" SVN_DAV__IPROP_PATH ">%s</S:" SVN_DAV__IPROP_PATH ">"
DEBUG_CR,
apr_xml_quote_string(resource->pool, elt->path_or_url, 0));
if (!serr)
{
apr_hash_index_t *hi;
for (hi = apr_hash_first(resource->pool, elt->prop_hash);
hi;
hi = apr_hash_next(hi))
{
const char *propname = apr_hash_this_key(hi);
svn_string_t *propval = apr_hash_this_val(hi);
const char *xml_safe;
serr = dav_svn__brigade_printf(
bb, output,
"<S:" SVN_DAV__IPROP_PROPNAME ">%s</S:"
SVN_DAV__IPROP_PROPNAME ">" DEBUG_CR,
apr_xml_quote_string(iterpool, propname, 0));
if (!serr)
{
if (svn_xml_is_xml_safe(propval->data, propval->len))
{
svn_stringbuf_t *tmp = NULL;
svn_xml_escape_cdata_string(&tmp, propval,
iterpool);
xml_safe = tmp->data;
serr = dav_svn__brigade_printf(
bb, output,
"<S:" SVN_DAV__IPROP_PROPVAL ">%s</S:"
SVN_DAV__IPROP_PROPVAL ">" DEBUG_CR, xml_safe);
}
else
{
xml_safe = svn_base64_encode_string2(
propval, TRUE, iterpool)->data;
serr = dav_svn__brigade_printf(
bb, output,
"<S:" SVN_DAV__IPROP_PROPVAL
" encoding=\"base64\"" ">%s</S:"
SVN_DAV__IPROP_PROPVAL ">" DEBUG_CR, xml_safe);
}
}
if (serr)
break;
}
if (!serr)
serr = dav_svn__brigade_printf(bb, output,
"</S:" SVN_DAV__IPROP_ITEM ">"
DEBUG_CR);
}
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
}
if ((serr = dav_svn__brigade_puts(bb, output,
"</S:" SVN_DAV__INHERITED_PROPS_REPORT ">"
DEBUG_CR)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
cleanup:
/* Log this 'high level' svn action. */
dav_svn__operational_log(resource->info,
svn_log__get_inherited_props(path, rev,
resource->pool));
svn_pool_destroy(iterpool);
return dav_svn__final_flush_or_error(resource->info->r, bb, output,
derr, resource->pool);
}
static svn_error_t *
entries_dump(const char *dir_path, svn_wc_adm_access_t *related, apr_pool_t *pool)
{
svn_wc_adm_access_t *adm_access = NULL;
apr_hash_t *entries;
apr_hash_index_t *hi;
svn_boolean_t locked;
svn_error_t *err;
svn_wc_context_t *wc_ctx = NULL;
const char *dir_abspath;
err = svn_wc_adm_open3(&adm_access, related, dir_path, FALSE, 0,
NULL, NULL, pool);
if (!err)
{
SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
svn_wc__adm_get_db(adm_access),
pool));
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc_locked2(NULL, &locked, wc_ctx, dir_abspath, pool));
SVN_ERR(svn_wc_entries_read(&entries, adm_access, TRUE, pool));
}
else if (err && err->apr_err == SVN_ERR_WC_LOCKED
&& related
&& ! strcmp(dir_path, svn_wc_adm_access_path(related)))
{
/* Common caller error: Can't open a baton when there is one. */
svn_error_clear(err);
SVN_ERR(svn_wc__context_create_with_db(&wc_ctx, NULL,
svn_wc__adm_get_db(related),
pool));
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc_locked2(NULL, &locked, wc_ctx, dir_abspath, pool));
SVN_ERR(svn_wc_entries_read(&entries, related, TRUE, pool));
}
else
{
const char *lockfile_path;
svn_node_kind_t kind;
/* ### Should svn_wc_adm_open3 be returning UPGRADE_REQUIRED? */
if (err->apr_err != SVN_ERR_WC_NOT_DIRECTORY)
return err;
svn_error_clear(err);
adm_access = NULL;
SVN_ERR(svn_dirent_get_absolute(&dir_abspath, dir_path, pool));
SVN_ERR(svn_wc__read_entries_old(&entries, dir_abspath, pool, pool));
lockfile_path = svn_dirent_join_many(pool, dir_path,
svn_wc_get_adm_dir(pool),
"lock", SVN_VA_NULL);
SVN_ERR(svn_io_check_path(lockfile_path, &kind, pool));
locked = (kind == svn_node_file);
}
for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi))
{
const char *key = apr_hash_this_key(hi);
const svn_wc_entry_t *entry = apr_hash_this_val(hi);
SVN_ERR_ASSERT(strcmp(key, entry->name) == 0);
printf("e = Entry()\n");
str_value("name", entry->name);
int_value("revision", entry->revision);
str_value("url", entry->url);
str_value("repos", entry->repos);
str_value("uuid", entry->uuid);
int_value("kind", entry->kind);
int_value("schedule", entry->schedule);
bool_value("copied", entry->copied);
bool_value("deleted", entry->deleted);
bool_value("absent", entry->absent);
bool_value("incomplete", entry->incomplete);
str_value("copyfrom_url", entry->copyfrom_url);
int_value("copyfrom_rev", entry->copyfrom_rev);
str_value("conflict_old", entry->conflict_old);
str_value("conflict_new", entry->conflict_new);
str_value("conflict_wrk", entry->conflict_wrk);
str_value("prejfile", entry->prejfile);
/* skip: text_time */
/* skip: prop_time */
/* skip: checksum */
int_value("cmt_rev", entry->cmt_rev);
/* skip: cmt_date */
str_value("cmt_author", entry->cmt_author);
str_value("lock_token", entry->lock_token);
str_value("lock_owner", entry->lock_owner);
str_value("lock_comment", entry->lock_comment);
/* skip: lock_creation_date */
/* skip: has_props */
/* skip: has_prop_mods */
/* skip: cachable_props */
/* skip: present_props */
str_value("changelist", entry->changelist);
/* skip: working_size */
/* skip: keep_local */
int_value("depth", entry->depth);
/* skip: tree_conflict_data */
bool_value("file_external", entry->file_external_path != NULL);
/* skip: file_external_peg_rev */
/* skip: file_external_rev */
bool_value("locked", locked && *entry->name == '\0');
printf("entries['%s'] = e\n", (const char *)key);
}
if (wc_ctx)
SVN_ERR(svn_wc_context_destroy(wc_ctx));
if (adm_access)
SVN_ERR(svn_wc_adm_close2(adm_access, pool));
return SVN_NO_ERROR;
}
/* Write to DIGEST_PATH a representation of CHILDREN (which may be
empty, if the versioned path in FS represented by DIGEST_PATH has
no children) and LOCK (which may be NULL if that versioned path is
lock itself locked). Set the permissions of DIGEST_PATH to those of
PERMS_REFERENCE. Use POOL for all allocations.
*/
static svn_error_t *
write_digest_file(apr_hash_t *children,
svn_lock_t *lock,
const char *fs_path,
const char *digest_path,
const char *perms_reference,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
svn_stream_t *stream;
apr_hash_index_t *hi;
apr_hash_t *hash = apr_hash_make(pool);
const char *tmp_path;
SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_join(fs_path, PATH_LOCKS_DIR,
pool), fs_path, pool));
SVN_ERR(svn_fs_fs__ensure_dir_exists(svn_dirent_dirname(digest_path, pool),
fs_path, pool));
if (lock)
{
const char *creation_date = NULL, *expiration_date = NULL;
if (lock->creation_date)
creation_date = svn_time_to_cstring(lock->creation_date, pool);
if (lock->expiration_date)
expiration_date = svn_time_to_cstring(lock->expiration_date, pool);
hash_store(hash, PATH_KEY, sizeof(PATH_KEY)-1,
lock->path, APR_HASH_KEY_STRING, pool);
hash_store(hash, TOKEN_KEY, sizeof(TOKEN_KEY)-1,
lock->token, APR_HASH_KEY_STRING, pool);
hash_store(hash, OWNER_KEY, sizeof(OWNER_KEY)-1,
lock->owner, APR_HASH_KEY_STRING, pool);
hash_store(hash, COMMENT_KEY, sizeof(COMMENT_KEY)-1,
lock->comment, APR_HASH_KEY_STRING, pool);
hash_store(hash, IS_DAV_COMMENT_KEY, sizeof(IS_DAV_COMMENT_KEY)-1,
lock->is_dav_comment ? "1" : "0", 1, pool);
hash_store(hash, CREATION_DATE_KEY, sizeof(CREATION_DATE_KEY)-1,
creation_date, APR_HASH_KEY_STRING, pool);
hash_store(hash, EXPIRATION_DATE_KEY, sizeof(EXPIRATION_DATE_KEY)-1,
expiration_date, APR_HASH_KEY_STRING, pool);
}
if (apr_hash_count(children))
{
svn_stringbuf_t *children_list = svn_stringbuf_create_empty(pool);
for (hi = apr_hash_first(pool, children); hi; hi = apr_hash_next(hi))
{
svn_stringbuf_appendbytes(children_list,
apr_hash_this_key(hi),
apr_hash_this_key_len(hi));
svn_stringbuf_appendbyte(children_list, '\n');
}
hash_store(hash, CHILDREN_KEY, sizeof(CHILDREN_KEY)-1,
children_list->data, children_list->len, pool);
}
SVN_ERR(svn_stream_open_unique(&stream, &tmp_path,
svn_dirent_dirname(digest_path, pool),
svn_io_file_del_none, pool, pool));
if ((err = svn_hash_write2(hash, stream, SVN_HASH_TERMINATOR, pool)))
{
svn_error_clear(svn_stream_close(stream));
return svn_error_createf(err->apr_err,
err,
_("Cannot write lock/entries hashfile '%s'"),
svn_dirent_local_style(tmp_path, pool));
}
SVN_ERR(svn_stream_close(stream));
SVN_ERR(svn_io_file_rename(tmp_path, digest_path, pool));
SVN_ERR(svn_io_copy_perms(perms_reference, digest_path, pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_client__copy_foreign(const char *url,
const char *dst_abspath,
svn_opt_revision_t *peg_revision,
svn_opt_revision_t *revision,
svn_depth_t depth,
svn_boolean_t make_parents,
svn_boolean_t already_locked,
svn_client_ctx_t *ctx,
apr_pool_t *scratch_pool)
{
svn_ra_session_t *ra_session;
svn_client__pathrev_t *loc;
svn_node_kind_t kind;
svn_node_kind_t wc_kind;
const char *dir_abspath;
SVN_ERR_ASSERT(svn_path_is_url(url));
SVN_ERR_ASSERT(svn_dirent_is_absolute(dst_abspath));
/* Do we need to validate/update revisions? */
SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &loc,
url, NULL,
peg_revision,
revision, ctx,
scratch_pool));
SVN_ERR(svn_ra_check_path(ra_session, "", loc->rev, &kind, scratch_pool));
if (kind != svn_node_file && kind != svn_node_dir)
return svn_error_createf(
SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' is not a valid location inside a repository"),
url);
SVN_ERR(svn_wc_read_kind2(&wc_kind, ctx->wc_ctx, dst_abspath, FALSE, TRUE,
scratch_pool));
if (wc_kind != svn_node_none)
{
return svn_error_createf(
SVN_ERR_ENTRY_EXISTS, NULL,
_("'%s' is already under version control"),
svn_dirent_local_style(dst_abspath, scratch_pool));
}
dir_abspath = svn_dirent_dirname(dst_abspath, scratch_pool);
SVN_ERR(svn_wc_read_kind2(&wc_kind, ctx->wc_ctx, dir_abspath,
FALSE, FALSE, scratch_pool));
if (wc_kind == svn_node_none)
{
if (make_parents)
SVN_ERR(svn_client__make_local_parents(dir_abspath, make_parents, ctx,
scratch_pool));
SVN_ERR(svn_wc_read_kind2(&wc_kind, ctx->wc_ctx, dir_abspath,
FALSE, FALSE, scratch_pool));
}
if (wc_kind != svn_node_dir)
return svn_error_createf(
SVN_ERR_ENTRY_NOT_FOUND, NULL,
_("Can't add '%s', because no parent directory is found"),
svn_dirent_local_style(dst_abspath, scratch_pool));
if (kind == svn_node_file)
{
svn_stream_t *target;
apr_hash_t *props;
apr_hash_index_t *hi;
SVN_ERR(svn_stream_open_writable(&target, dst_abspath, scratch_pool,
scratch_pool));
SVN_ERR(svn_ra_get_file(ra_session, "", loc->rev, target, NULL, &props,
scratch_pool));
if (props != NULL)
for (hi = apr_hash_first(scratch_pool, props); hi;
hi = apr_hash_next(hi))
{
const char *name = apr_hash_this_key(hi);
if (svn_property_kind2(name) != svn_prop_regular_kind
|| ! strcmp(name, SVN_PROP_MERGEINFO))
{
/* We can't handle DAV, ENTRY and merge specific props here */
svn_hash_sets(props, name, NULL);
}
}
if (!already_locked)
SVN_WC__CALL_WITH_WRITE_LOCK(
svn_wc_add_from_disk3(ctx->wc_ctx, dst_abspath, props,
TRUE /* skip checks */,
ctx->notify_func2, ctx->notify_baton2,
scratch_pool),
ctx->wc_ctx, dir_abspath, FALSE, scratch_pool);
else
SVN_ERR(svn_wc_add_from_disk3(ctx->wc_ctx, dst_abspath, props,
TRUE /* skip checks */,
ctx->notify_func2, ctx->notify_baton2,
scratch_pool));
}
else
{
if (!already_locked)
SVN_WC__CALL_WITH_WRITE_LOCK(
copy_foreign_dir(ra_session, loc,
ctx->wc_ctx, dst_abspath,
depth,
ctx->notify_func2, ctx->notify_baton2,
ctx->cancel_func, ctx->cancel_baton,
scratch_pool),
ctx->wc_ctx, dir_abspath, FALSE, scratch_pool);
else
SVN_ERR(copy_foreign_dir(ra_session, loc,
ctx->wc_ctx, dst_abspath,
depth,
ctx->notify_func2, ctx->notify_baton2,
ctx->cancel_func, ctx->cancel_baton,
scratch_pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_config_walk_auth_data(const char *config_dir,
svn_config_auth_walk_func_t walk_func,
void *walk_baton,
apr_pool_t *scratch_pool)
{
int i;
apr_pool_t *iterpool;
svn_boolean_t finished = FALSE;
const char *cred_kinds[] =
{
SVN_AUTH_CRED_SIMPLE,
SVN_AUTH_CRED_USERNAME,
SVN_AUTH_CRED_SSL_CLIENT_CERT,
SVN_AUTH_CRED_SSL_CLIENT_CERT_PW,
SVN_AUTH_CRED_SSL_SERVER_TRUST,
NULL
};
iterpool = svn_pool_create(scratch_pool);
for (i = 0; cred_kinds[i]; i++)
{
const char *item_path;
const char *dir_path;
apr_hash_t *nodes;
svn_error_t *err;
apr_pool_t *itempool;
apr_hash_index_t *hi;
svn_pool_clear(iterpool);
if (finished)
break;
SVN_ERR(svn_auth__file_path(&item_path, cred_kinds[i], "!", config_dir,
iterpool));
dir_path = svn_dirent_dirname(item_path, iterpool);
err = svn_io_get_dirents3(&nodes, dir_path, TRUE, iterpool, iterpool);
if (err)
{
if (!APR_STATUS_IS_ENOENT(err->apr_err)
&& !SVN__APR_STATUS_IS_ENOTDIR(err->apr_err))
return svn_error_trace(err);
svn_error_clear(err);
continue;
}
itempool = svn_pool_create(iterpool);
for (hi = apr_hash_first(iterpool, nodes); hi; hi = apr_hash_next(hi))
{
svn_io_dirent2_t *dirent = apr_hash_this_val(hi);
svn_stream_t *stream;
apr_hash_t *creds_hash;
const svn_string_t *realm;
svn_boolean_t delete_file = FALSE;
if (finished)
break;
if (dirent->kind != svn_node_file)
continue;
svn_pool_clear(itempool);
item_path = svn_dirent_join(dir_path, apr_hash_this_key(hi),
itempool);
err = svn_stream_open_readonly(&stream, item_path,
itempool, itempool);
if (err)
{
/* Ignore this file. There are no credentials in it anyway */
svn_error_clear(err);
continue;
}
creds_hash = apr_hash_make(itempool);
err = svn_hash_read2(creds_hash, stream,
SVN_HASH_TERMINATOR, itempool);
err = svn_error_compose_create(err, svn_stream_close(stream));
if (err)
{
/* Ignore this file. There are no credentials in it anyway */
svn_error_clear(err);
continue;
}
realm = svn_hash_gets(creds_hash, SVN_CONFIG_REALMSTRING_KEY);
if (! realm)
continue; /* Not an auth file */
err = walk_func(&delete_file, walk_baton, cred_kinds[i],
realm->data, creds_hash, itempool);
if (err && err->apr_err == SVN_ERR_CEASE_INVOCATION)
{
svn_error_clear(err);
err = SVN_NO_ERROR;
finished = TRUE;
}
SVN_ERR(err);
if (delete_file)
{
/* Delete the file on disk */
SVN_ERR(svn_io_remove_file2(item_path, TRUE, itempool));
}
}
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* Given a list of committables described by their common base abspath
BASE_ABSPATH and a list of relative dirents TARGET_RELPATHS determine
which absolute paths must be locked to commit all these targets and
return this as a const char * array in LOCK_TARGETS
Allocate the result in RESULT_POOL and use SCRATCH_POOL for temporary
storage */
static svn_error_t *
determine_lock_targets(apr_array_header_t **lock_targets,
svn_wc_context_t *wc_ctx,
const char *base_abspath,
const apr_array_header_t *target_relpaths,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
apr_hash_t *wc_items; /* const char *wcroot -> apr_array_header_t */
apr_hash_index_t *hi;
int i;
wc_items = apr_hash_make(scratch_pool);
/* Create an array of targets for each working copy used */
for (i = 0; i < target_relpaths->nelts; i++)
{
const char *target_abspath;
const char *wcroot_abspath;
apr_array_header_t *wc_targets;
svn_error_t *err;
const char *target_relpath = APR_ARRAY_IDX(target_relpaths, i,
const char *);
svn_pool_clear(iterpool);
target_abspath = svn_dirent_join(base_abspath, target_relpath,
scratch_pool);
err = svn_wc__get_wcroot(&wcroot_abspath, wc_ctx, target_abspath,
iterpool, iterpool);
if (err)
{
if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
svn_error_clear(err);
continue;
}
return svn_error_trace(err);
}
wc_targets = svn_hash_gets(wc_items, wcroot_abspath);
if (! wc_targets)
{
wc_targets = apr_array_make(scratch_pool, 4, sizeof(const char *));
svn_hash_sets(wc_items, apr_pstrdup(scratch_pool, wcroot_abspath),
wc_targets);
}
APR_ARRAY_PUSH(wc_targets, const char *) = target_abspath;
}
*lock_targets = apr_array_make(result_pool, apr_hash_count(wc_items),
sizeof(const char *));
/* For each working copy determine where to lock */
for (hi = apr_hash_first(scratch_pool, wc_items);
hi;
hi = apr_hash_next(hi))
{
const char *common;
const char *wcroot_abspath = apr_hash_this_key(hi);
apr_array_header_t *wc_targets = apr_hash_this_val(hi);
svn_pool_clear(iterpool);
if (wc_targets->nelts == 1)
{
const char *target_abspath;
target_abspath = APR_ARRAY_IDX(wc_targets, 0, const char *);
if (! strcmp(wcroot_abspath, target_abspath))
{
APR_ARRAY_PUSH(*lock_targets, const char *)
= apr_pstrdup(result_pool, target_abspath);
}
else
{
/* Lock the parent to allow deleting the target */
APR_ARRAY_PUSH(*lock_targets, const char *)
= svn_dirent_dirname(target_abspath, result_pool);
}
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__status(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;
apr_array_header_t *targets;
apr_pool_t *iterpool;
apr_hash_t *master_cl_hash = apr_hash_make(scratch_pool);
int i;
svn_opt_revision_t rev;
struct status_baton sb;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE,
scratch_pool));
/* Add "." if user passed 0 arguments */
svn_opt_push_implicit_dot_target(targets, scratch_pool);
SVN_ERR(svn_cl__check_targets_are_local_paths(targets));
/* We want our -u statuses to be against HEAD by default. */
if (opt_state->start_revision.kind == svn_opt_revision_unspecified)
rev.kind = svn_opt_revision_head;
else if (! opt_state->update)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--revision (-r) option valid only with "
"--show-updates (-u) option"));
else
rev = opt_state->start_revision;
sb.had_print_error = FALSE;
if (opt_state->xml)
{
/* 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("status", scratch_pool));
}
else
{
if (opt_state->incremental)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'incremental' option only valid in XML "
"mode"));
}
sb.suppress_externals_placeholders = (opt_state->quiet
&& (! opt_state->verbose));
sb.detailed = (opt_state->verbose || opt_state->update);
sb.show_last_committed = opt_state->verbose;
sb.skip_unrecognized = opt_state->quiet;
sb.repos_locks = opt_state->update;
sb.xml_mode = opt_state->xml;
sb.cached_changelists = master_cl_hash;
sb.cl_pool = scratch_pool;
sb.text_conflicts = 0;
sb.prop_conflicts = 0;
sb.tree_conflicts = 0;
sb.ctx = ctx;
SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool));
iterpool = svn_pool_create(scratch_pool);
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_revnum_t repos_rev = SVN_INVALID_REVNUM;
svn_pool_clear(iterpool);
SVN_ERR(svn_dirent_get_absolute(&(sb.target_abspath), target,
scratch_pool));
sb.target_path = target;
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
if (opt_state->xml)
SVN_ERR(print_start_target_xml(svn_dirent_local_style(target, iterpool),
iterpool));
/* Retrieve a hash of status structures with the information
requested by the user. */
SVN_ERR(svn_cl__try(svn_client_status6(&repos_rev, ctx, target, &rev,
opt_state->depth,
opt_state->verbose,
opt_state->update,
TRUE /* check_working_copy */,
opt_state->no_ignore,
opt_state->ignore_externals,
FALSE /* depth_as_sticky */,
opt_state->changelists,
print_status, &sb,
iterpool),
NULL, opt_state->quiet,
/* not versioned: */
SVN_ERR_WC_NOT_WORKING_COPY,
SVN_ERR_WC_PATH_NOT_FOUND,
0));
if (opt_state->xml)
SVN_ERR(print_finish_target_xml(repos_rev, iterpool));
}
/* If any paths were cached because they were associated with
changelists, we can now display them as grouped changelists. */
if (apr_hash_count(master_cl_hash) > 0)
{
apr_hash_index_t *hi;
svn_stringbuf_t *buf;
if (opt_state->xml)
buf = svn_stringbuf_create_empty(scratch_pool);
for (hi = apr_hash_first(scratch_pool, master_cl_hash); hi;
hi = apr_hash_next(hi))
{
const char *changelist_name = apr_hash_this_key(hi);
apr_array_header_t *path_array = apr_hash_this_val(hi);
int j;
/* ### TODO: For non-XML output, we shouldn't print the
### leading \n on the first changelist if there were no
### non-changelist entries. */
if (opt_state->xml)
{
svn_stringbuf_setempty(buf);
svn_xml_make_open_tag(&buf, scratch_pool, svn_xml_normal,
"changelist", "name", changelist_name,
SVN_VA_NULL);
SVN_ERR(svn_cl__error_checked_fputs(buf->data, stdout));
}
else
SVN_ERR(svn_cmdline_printf(scratch_pool,
_("\n--- Changelist '%s':\n"),
changelist_name));
for (j = 0; j < path_array->nelts; j++)
{
struct status_cache *scache =
APR_ARRAY_IDX(path_array, j, struct status_cache *);
sb.target_abspath = scache->target_abspath;
sb.target_path = scache->target_path;
SVN_ERR(print_status_normal_or_xml(&sb, scache->path,
scache->status, scratch_pool));
}
if (opt_state->xml)
{
svn_stringbuf_setempty(buf);
svn_xml_make_close_tag(&buf, scratch_pool, "changelist");
SVN_ERR(svn_cl__error_checked_fputs(buf->data, stdout));
}
}
}
/* Examine the mergeinfo in INITIAL_VAL, renumber revisions in rangelists
as appropriate, and return the (possibly new) mergeinfo in *FINAL_VAL
(allocated from POOL).
Adjust any mergeinfo revisions not older than OLDEST_DUMPSTREAM_REV by
using REV_MAP which maps (svn_revnum_t) old rev to (svn_revnum_t) new rev.
Adjust any mergeinfo revisions older than OLDEST_DUMPSTREAM_REV by
(-OLDER_REVS_OFFSET), dropping any that become <= 0.
*/
static svn_error_t *
renumber_mergeinfo_revs(svn_string_t **final_val,
const svn_string_t *initial_val,
apr_hash_t *rev_map,
svn_revnum_t oldest_dumpstream_rev,
apr_int32_t older_revs_offset,
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 (oldest_dumpstream_rev > 1)
{
/* predates_stream_mergeinfo := mergeinfo that refers to revs before
oldest_dumpstream_rev */
SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
&predates_stream_mergeinfo, mergeinfo,
oldest_dumpstream_rev - 1, 0,
TRUE, subpool, subpool));
/* mergeinfo := mergeinfo that refers to revs >= oldest_dumpstream_rev */
SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
&mergeinfo, mergeinfo,
oldest_dumpstream_rev - 1, 0,
FALSE, subpool, subpool));
SVN_ERR(svn_mergeinfo__adjust_mergeinfo_rangelists(
&predates_stream_mergeinfo, predates_stream_mergeinfo,
-older_revs_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 = apr_hash_this_key(hi);
svn_rangelist_t *rangelist = apr_hash_this_val(hi);
int i;
/* 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(rev_map, range->start);
if (SVN_IS_VALID_REVNUM(rev_from_map))
{
range->start = rev_from_map;
}
else if (range->start == oldest_dumpstream_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 REV_MAP mapping of load stream
revsions to loaded revisions: The revision immediately
preceding the oldest revision from the load stream.
This is a valid revision for mergeinfo, but not a valid
copy from revision (which 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(rev_map,
oldest_dumpstream_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(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;
}