/* Helper func for recursively fetching svn_dirent_t's from a remote
directory and pushing them at an info-receiver callback.
DEPTH is the depth starting at DIR, even though RECEIVER is never
invoked on DIR: if DEPTH is svn_depth_immediates, then invoke
RECEIVER on all children of DIR, but none of their children; if
svn_depth_files, then invoke RECEIVER on file children of DIR but
not on subdirectories; if svn_depth_infinity, recurse fully.
DIR is a relpath, relative to the root of RA_SESSION.
*/
static svn_error_t *
push_dir_info(svn_ra_session_t *ra_session,
const svn_client__pathrev_t *pathrev,
const char *dir,
svn_client_info_receiver2_t receiver,
void *receiver_baton,
svn_depth_t depth,
svn_client_ctx_t *ctx,
apr_hash_t *locks,
apr_pool_t *pool)
{
apr_hash_t *tmpdirents;
apr_hash_index_t *hi;
apr_pool_t *subpool = svn_pool_create(pool);
SVN_ERR(svn_ra_get_dir2(ra_session, &tmpdirents, NULL, NULL,
dir, pathrev->rev, DIRENT_FIELDS, pool));
for (hi = apr_hash_first(pool, tmpdirents); hi; hi = apr_hash_next(hi))
{
const char *path, *fs_path;
svn_lock_t *lock;
svn_client_info2_t *info;
const char *name = svn__apr_hash_index_key(hi);
svn_dirent_t *the_ent = svn__apr_hash_index_val(hi);
svn_client__pathrev_t *child_pathrev;
svn_pool_clear(subpool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
path = svn_relpath_join(dir, name, subpool);
child_pathrev = svn_client__pathrev_join_relpath(pathrev, name, subpool);
fs_path = svn_client__pathrev_fspath(child_pathrev, subpool);
lock = apr_hash_get(locks, fs_path, APR_HASH_KEY_STRING);
SVN_ERR(build_info_from_dirent(&info, the_ent, lock, child_pathrev,
subpool));
if (depth >= svn_depth_immediates
|| (depth == svn_depth_files && the_ent->kind == svn_node_file))
{
SVN_ERR(receiver(receiver_baton, path, info, subpool));
}
if (depth == svn_depth_infinity && the_ent->kind == svn_node_dir)
{
SVN_ERR(push_dir_info(ra_session, child_pathrev, path,
receiver, receiver_baton,
depth, ctx, locks, subpool));
}
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* Get the props attached to a directory in the repository at BASE_REVISION. */
static svn_error_t *
get_dirprops_from_ra(struct dir_baton *b, svn_revnum_t base_revision)
{
return svn_ra_get_dir2(b->edit_baton->ra_session,
NULL, NULL, &(b->pristine_props),
b->path,
base_revision,
0,
b->pool);
}
svn_error_t*
CommitEditor::provide_props_cb(apr_hash_t **props,
svn_revnum_t *revision,
void *baton,
const char *repos_relpath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
CommitEditor* editor = static_cast<CommitEditor*>(baton);
if (editor->m_get_props_cb.get())
{
const Java::Env env;
SVN_JAVAHL_CATCH(env, SVN_ERR_BASE,
invoke_get_props_cb(props, revision, env,
editor->m_get_props_cb.get(),
repos_relpath,
result_pool));
}
else
{
SVN_ERR(open_callback_session(editor->m_callback_session,
editor->m_callback_session_url,
editor->m_callback_session_uuid,
editor->m_session->m_context,
editor->pool));
svn_node_kind_t kind = svn_node_unknown;
SVN_ERR(svn_ra_check_path(editor->m_callback_session,
repos_relpath, SVN_INVALID_REVNUM, &kind,
scratch_pool));
// FIXME: Getting properties from the youngest revision is in
// fact not such a bright idea, as the path may have been moved
// or deleted in the repository. On the other hand, if that
// happens, the commit would fail due to a conflict anyway.
if (kind == svn_node_file)
return svn_ra_get_file(editor->m_callback_session,
repos_relpath, SVN_INVALID_REVNUM,
NULL, revision, props, scratch_pool);
else if (kind == svn_node_dir)
return svn_ra_get_dir2(editor->m_callback_session, NULL, revision,
props, repos_relpath, SVN_INVALID_REVNUM, 0,
scratch_pool);
else
return svn_error_createf(
SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("Expected node kind '%s' or '%s' but got '%s'"),
svn_node_kind_to_word(svn_node_file),
svn_node_kind_to_word(svn_node_dir),
svn_node_kind_to_word(kind));
}
return SVN_NO_ERROR;
}
/* Implements svn_wc_dirents_func_t for update and switch handling. Assumes
a struct svn_client__dirent_fetcher_baton_t * baton */
svn_error_t *
svn_client__dirent_fetcher(void *baton,
apr_hash_t **dirents,
const char *repos_root_url,
const char *repos_relpath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
struct svn_client__dirent_fetcher_baton_t *dfb = baton;
const char *old_url = NULL;
const char *session_relpath;
svn_node_kind_t kind;
const char *url;
url = svn_path_url_add_component2(repos_root_url, repos_relpath,
scratch_pool);
if (!svn_uri__is_ancestor(dfb->anchor_url, url))
{
SVN_ERR(svn_client__ensure_ra_session_url(&old_url, dfb->ra_session,
url, scratch_pool));
session_relpath = "";
}
else
SVN_ERR(svn_ra_get_path_relative_to_session(dfb->ra_session,
&session_relpath, url,
scratch_pool));
/* Is session_relpath still a directory? */
SVN_ERR(svn_ra_check_path(dfb->ra_session, session_relpath,
dfb->target_revision, &kind, scratch_pool));
if (kind == svn_node_dir)
SVN_ERR(svn_ra_get_dir2(dfb->ra_session, dirents, NULL, NULL,
session_relpath, dfb->target_revision,
SVN_DIRENT_KIND, result_pool));
else
*dirents = NULL;
if (old_url)
SVN_ERR(svn_ra_reparent(dfb->ra_session, old_url, scratch_pool));
return SVN_NO_ERROR;
}
static svn_error_t *
fetch_props_func(apr_hash_t **props,
void *baton,
const char *path,
svn_revnum_t base_revision,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
struct revision_baton *rb = baton;
svn_node_kind_t node_kind;
if (! SVN_IS_VALID_REVNUM(base_revision))
base_revision = rb->rev - 1;
SVN_ERR(svn_ra_check_path(rb->pb->aux_session, path, base_revision,
&node_kind, scratch_pool));
if (node_kind == svn_node_file)
{
SVN_ERR(svn_ra_get_file(rb->pb->aux_session, path, base_revision,
NULL, NULL, props, result_pool));
}
else if (node_kind == svn_node_dir)
{
apr_array_header_t *tmp_props;
SVN_ERR(svn_ra_get_dir2(rb->pb->aux_session, NULL, NULL, props, path,
base_revision, 0 /* Dirent fields */,
result_pool));
tmp_props = svn_prop_hash_to_array(*props, result_pool);
SVN_ERR(svn_categorize_props(tmp_props, NULL, NULL, &tmp_props,
result_pool));
*props = svn_prop_array_to_hash(tmp_props, result_pool);
}
else
{
*props = apr_hash_make(result_pool);
}
return SVN_NO_ERROR;
}
/* Like svn_ra_stat() but with a compatibility hack for pre-1.2 svnserve. */
static svn_error_t *
ra_stat_compatible(svn_ra_session_t *ra_session,
svn_revnum_t rev,
svn_dirent_t **dirent_p,
apr_uint32_t dirent_fields,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
const char *repos_root_URL, *url;
svn_error_t *err;
svn_dirent_t *the_ent;
SVN_ERR(svn_ra_get_repos_root2(ra_session, &repos_root_URL, pool));
SVN_ERR(svn_ra_get_session_url(ra_session, &url, pool));
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_node_kind_t url_kind;
svn_ra_session_t *parent_ra_session;
apr_hash_t *parent_ents;
const char *parent_url, *base_name;
if (strcmp(url, repos_root_URL) == 0)
{
/* In this universe, there's simply no way to fetch
information about the repository's root directory! */
return err;
}
svn_error_clear(err);
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_uri_split(&parent_url, &base_name, url, pool);
SVN_ERR(svn_client__open_ra_session_internal(&parent_ra_session, NULL,
parent_url, 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 svn_error_trace(err);
}
*dirent_p = the_ent;
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_info3(const char *abspath_or_url,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
svn_depth_t depth,
svn_boolean_t fetch_excluded,
svn_boolean_t fetch_actual_only,
const apr_array_header_t *changelists,
svn_client_info_receiver2_t receiver,
void *receiver_baton,
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_client_info2_t *info;
svn_error_t *err;
if (depth == svn_depth_unknown)
depth = svn_depth_empty;
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. */
wc_info_receiver_baton_t b = { receiver, receiver_baton };
return svn_error_trace(
svn_wc__get_info(ctx->wc_ctx, abspath_or_url, depth,
fetch_excluded, fetch_actual_only, changelists,
wc_info_receiver, &b,
ctx->cancel_func, ctx->cancel_baton, 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, abspath_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_uri_split(&parent_url, &base_name, url, 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, NULL,
parent_url, 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 svn_error_trace(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 svn_error_trace(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_locks2(ra_session, &locks, "", depth,
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 svn_error_trace(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;
}
/* 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;
}
/* Helper func for recursively fetching svn_dirent_t's from a remote
directory and pushing them at an info-receiver callback.
DEPTH is the depth starting at DIR, even though RECEIVER is never
invoked on DIR: if DEPTH is svn_depth_immediates, then invoke
RECEIVER on all children of DIR, but none of their children; if
svn_depth_files, then invoke RECEIVER on file children of DIR but
not on subdirectories; if svn_depth_infinity, recurse fully.
*/
static svn_error_t *
push_dir_info(svn_ra_session_t *ra_session,
const char *session_URL,
const char *dir,
svn_revnum_t rev,
const char *repos_UUID,
const char *repos_root,
svn_info_receiver_t receiver,
void *receiver_baton,
svn_depth_t depth,
svn_client_ctx_t *ctx,
apr_hash_t *locks,
apr_pool_t *pool)
{
apr_hash_t *tmpdirents;
svn_dirent_t *the_ent;
svn_info_t *info;
apr_hash_index_t *hi;
apr_pool_t *subpool = svn_pool_create(pool);
SVN_ERR(svn_ra_get_dir2(ra_session, &tmpdirents, NULL, NULL,
dir, rev, DIRENT_FIELDS, pool));
for (hi = apr_hash_first(pool, tmpdirents); hi; hi = apr_hash_next(hi))
{
const char *path, *URL, *fs_path;
const void *key;
svn_lock_t *lock;
void *val;
svn_pool_clear(subpool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
apr_hash_this(hi, &key, NULL, &val);
the_ent = val;
path = svn_path_join(dir, key, subpool);
URL = svn_path_url_add_component(session_URL, key, subpool);
fs_path = svn_path_is_child(repos_root, URL, subpool);
fs_path = apr_pstrcat(subpool, "/", fs_path, NULL);
fs_path = svn_path_uri_decode(fs_path, subpool);
lock = apr_hash_get(locks, fs_path, APR_HASH_KEY_STRING);
SVN_ERR(build_info_from_dirent(&info, the_ent, lock, URL, rev,
repos_UUID, repos_root, subpool));
if (depth >= svn_depth_immediates
|| (depth == svn_depth_files && the_ent->kind == svn_node_file))
{
SVN_ERR(receiver(receiver_baton, path, info, subpool));
}
if (depth == svn_depth_infinity && the_ent->kind == svn_node_dir)
{
SVN_ERR(push_dir_info(ra_session, URL, path,
rev, repos_UUID, repos_root,
receiver, receiver_baton,
depth, ctx, locks, subpool));
}
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* ### TODO: Handle depth. */
static svn_error_t *
diff_deleted_dir(const char *dir,
svn_revnum_t revision,
svn_ra_session_t *ra_session,
void *edit_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
struct edit_baton *eb = edit_baton;
apr_hash_t *dirents;
apr_pool_t *iterpool = svn_pool_create(pool);
apr_hash_index_t *hi;
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
SVN_ERR(svn_ra_get_dir2(ra_session,
&dirents,
NULL, NULL,
dir,
revision,
SVN_DIRENT_KIND,
pool));
for (hi = apr_hash_first(pool, dirents); hi;
hi = apr_hash_next(hi))
{
const char *path;
const char *name = svn__apr_hash_index_key(hi);
svn_dirent_t *dirent = svn__apr_hash_index_val(hi);
svn_node_kind_t kind;
svn_client_diff_summarize_t *sum;
svn_pool_clear(iterpool);
path = svn_relpath_join(dir, name, iterpool);
SVN_ERR(svn_ra_check_path(eb->ra_session,
path,
eb->revision,
&kind,
iterpool));
sum = apr_pcalloc(iterpool, sizeof(*sum));
sum->summarize_kind = svn_client_diff_summarize_kind_deleted;
sum->path = path;
sum->node_kind = kind;
SVN_ERR(eb->summarize_func(sum,
eb->summarize_func_baton,
iterpool));
if (dirent->kind == svn_node_dir)
SVN_ERR(diff_deleted_dir(path,
revision,
ra_session,
eb,
cancel_func,
cancel_baton,
iterpool));
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* ### TODO: Handle depth. */
static svn_error_t *
diff_deleted_dir(svn_wc_notify_state_t *state_p,
svn_boolean_t *tree_conflicted_p,
const char *dir,
struct edit_baton *eb,
apr_pool_t *pool)
{
apr_hash_t *dirents;
apr_pool_t *iterpool = svn_pool_create(pool);
apr_hash_index_t *hi;
SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(eb->revision));
if (eb->cancel_func)
SVN_ERR(eb->cancel_func(eb->cancel_baton));
SVN_ERR(eb->diff_callbacks->dir_deleted(
state_p, tree_conflicted_p, dir,
eb->diff_cmd_baton, pool));
/* The "old" dir will be skipped by the repository report. If required,
* crawl it recursively, diffing each file against the empty file. This
* is a workaround for issue 2333 "'svn diff URL1 URL2' not reverse of
* 'svn diff URL2 URL1'". */
if (! eb->walk_deleted_repos_dirs)
{
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
SVN_ERR(svn_ra_get_dir2(eb->ra_session,
&dirents,
NULL, NULL,
dir,
eb->revision,
SVN_DIRENT_KIND,
pool));
for (hi = apr_hash_first(pool, dirents); hi;
hi = apr_hash_next(hi))
{
const char *path;
const char *name = svn__apr_hash_index_key(hi);
svn_dirent_t *dirent = svn__apr_hash_index_val(hi);
svn_pool_clear(iterpool);
path = svn_relpath_join(dir, name, iterpool);
if (dirent->kind == svn_node_file)
{
SVN_ERR(diff_deleted_file(NULL, NULL, path, eb, iterpool));
}
if (dirent->kind == svn_node_dir)
{
SVN_ERR(diff_deleted_dir(NULL, NULL, path, eb, iterpool));
}
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
