svn_error_t *
svn_fs_commit_txn(const char **conflict_p, svn_revnum_t *new_rev,
svn_fs_txn_t *txn, apr_pool_t *pool)
{
#ifdef PACK_AFTER_EVERY_COMMIT
svn_fs_root_t *txn_root;
svn_fs_t *fs;
const char *fs_path;
*new_rev = SVN_INVALID_REVNUM;
SVN_ERR(svn_fs_txn_root(&txn_root, txn, pool));
fs = svn_fs_root_fs(txn_root);
fs_path = svn_fs_path(fs, pool);
#endif
SVN_ERR(txn->vtable->commit(conflict_p, new_rev, txn, pool));
#ifdef PACK_AFTER_EVERY_COMMIT
{
svn_error_t *err = svn_fs_pack(fs_path, NULL, NULL, NULL, NULL, pool);
if (err && err->apr_err == SVN_ERR_UNSUPPORTED_FEATURE)
/* Pre-1.6 filesystem. */
svn_error_clear(err);
else if (err)
/* Real error. */
return svn_error_trace(err);
}
#endif
return SVN_NO_ERROR;
}
/* This implements svn_editor_cb_copy_t */
static svn_error_t *
copy_cb(void *baton,
const char *src_relpath,
svn_revnum_t src_revision,
const char *dst_relpath,
svn_revnum_t replaces_rev,
apr_pool_t *scratch_pool)
{
struct edit_baton *eb = baton;
const char *src_fspath = FSPATH(src_relpath, scratch_pool);
const char *dst_fspath = FSPATH(dst_relpath, scratch_pool);
svn_fs_root_t *root;
svn_fs_root_t *src_root;
SVN_ERR(get_root(&root, eb));
/* Check if we can we replace the maybe-specified destination (revision). */
if (SVN_IS_VALID_REVNUM(replaces_rev))
{
SVN_ERR(can_modify(root, dst_fspath, replaces_rev, scratch_pool));
SVN_ERR(svn_fs_delete(root, dst_fspath, scratch_pool));
}
else
{
SVN_ERR(can_create(root, dst_fspath, scratch_pool));
}
SVN_ERR(svn_fs_revision_root(&src_root, svn_fs_root_fs(root), src_revision,
scratch_pool));
SVN_ERR(svn_fs_copy(src_root, src_fspath, root, dst_fspath, scratch_pool));
svn_fs_close_root(src_root);
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_commit_txn(const char **conflict_p, svn_revnum_t *new_rev,
svn_fs_txn_t *txn, apr_pool_t *pool)
{
svn_error_t *err;
#ifdef PACK_AFTER_EVERY_COMMIT
svn_fs_root_t *txn_root;
svn_fs_t *fs;
const char *fs_path;
*new_rev = SVN_INVALID_REVNUM;
SVN_ERR(svn_fs_txn_root(&txn_root, txn, pool));
fs = svn_fs_root_fs(txn_root);
fs_path = svn_fs_path(fs, pool);
#endif
err = txn->vtable->commit(conflict_p, new_rev, txn, pool);
#ifdef SVN_DEBUG
/* Check postconditions. */
if (conflict_p)
{
SVN_ERR_ASSERT_E(! (SVN_IS_VALID_REVNUM(*new_rev) && *conflict_p != NULL),
err);
SVN_ERR_ASSERT_E((*conflict_p != NULL)
== (err && err->apr_err == SVN_ERR_FS_CONFLICT),
err);
}
#endif
SVN_ERR(err);
#ifdef PACK_AFTER_EVERY_COMMIT
{
err = svn_fs_pack(fs_path, NULL, NULL, NULL, NULL, pool);
if (err && err->apr_err == SVN_ERR_UNSUPPORTED_FEATURE)
/* Pre-1.6 filesystem. */
svn_error_clear(err);
else if (err)
/* Real error. */
return svn_error_trace(err);
}
#endif
return SVN_NO_ERROR;
}
/* This implements svn_editor_cb_move_t */
static svn_error_t *
move_cb(void *baton,
const char *src_relpath,
svn_revnum_t src_revision,
const char *dst_relpath,
svn_revnum_t replaces_rev,
apr_pool_t *scratch_pool)
{
struct edit_baton *eb = baton;
const char *src_fspath = FSPATH(src_relpath, scratch_pool);
const char *dst_fspath = FSPATH(dst_relpath, scratch_pool);
svn_fs_root_t *root;
svn_fs_root_t *src_root;
SVN_ERR(get_root(&root, eb));
/* Check if we delete the specified source (revision), and can we replace
the maybe-specified destination (revision). */
SVN_ERR(can_modify(root, src_fspath, src_revision, scratch_pool));
if (SVN_IS_VALID_REVNUM(replaces_rev))
{
SVN_ERR(can_modify(root, dst_fspath, replaces_rev, scratch_pool));
SVN_ERR(svn_fs_delete(root, dst_fspath, scratch_pool));
}
else
{
SVN_ERR(can_create(root, dst_fspath, scratch_pool));
}
/* ### would be nice to have svn_fs_move() */
/* Copy the src to the dst. */
SVN_ERR(svn_fs_revision_root(&src_root, svn_fs_root_fs(root), src_revision,
scratch_pool));
SVN_ERR(svn_fs_copy(src_root, src_fspath, root, dst_fspath, scratch_pool));
svn_fs_close_root(src_root);
/* Notice: we're deleting the src repos path from the dst root. */
SVN_ERR(svn_fs_delete(root, src_fspath, scratch_pool));
return SVN_NO_ERROR;
}
/* The caller wants to modify REVISION of FSPATH. Is that allowed? */
static svn_error_t *
can_modify(svn_fs_root_t *txn_root,
const char *fspath,
svn_revnum_t revision,
apr_pool_t *scratch_pool)
{
svn_revnum_t created_rev;
/* Out-of-dateness check: compare the created-rev of the node
in the txn against the created-rev of FSPATH. */
SVN_ERR(svn_fs_node_created_rev(&created_rev, txn_root, fspath,
scratch_pool));
/* Uncommitted nodes (eg. a descendent of a copy/move/rotate destination)
have no (committed) revision number. Let the caller go ahead and
modify these nodes.
Note: strictly speaking, they might be performing an "illegal" edit
in certain cases, but let's just assume they're Good Little Boys.
If CREATED_REV is invalid, that means it's already mutable in the
txn, which means it has already passed this out-of-dateness check.
(Usually, this happens when looking at a parent directory of an
already-modified node) */
if (!SVN_IS_VALID_REVNUM(created_rev))
return SVN_NO_ERROR;
/* If the node is immutable (has a revision), then the caller should
have supplied a valid revision number [that they expect to change].
The checks further below will determine the out-of-dateness of the
specified revision. */
/* ### ugh. descendents of copy/move/rotate destinations carry along
### their original immutable state and (thus) a valid CREATED_REV.
### but they are logically uncommitted, so the caller will pass
### SVN_INVALID_REVNUM. (technically, the caller could provide
### ORIGINAL_REV, but that is semantically incorrect for the Ev2
### API).
###
### for now, we will assume the caller knows what they are doing
### and an invalid revision implies such a descendent. in the
### future, we could examine the ancestor chain looking for a
### copy/move/rotate-here node and allow the modification (and the
### converse: if no such ancestor, the caller must specify the
### correct/intended revision to modify).
*/
#if 1
if (!SVN_IS_VALID_REVNUM(revision))
return SVN_NO_ERROR;
#else
if (!SVN_IS_VALID_REVNUM(revision))
/* ### use a custom error code? */
return svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
_("Revision for modifying '%s' is required"),
fspath);
#endif
if (revision < created_rev)
{
/* We asked to change a node that is *older* than what we found
in the transaction. The client is out of date. */
return svn_error_createf(SVN_ERR_FS_OUT_OF_DATE, NULL,
_("'%s' is out of date; try updating"),
fspath);
}
if (revision > created_rev)
{
/* We asked to change a node that is *newer* than what we found
in the transaction. Given that the transaction was based off
of 'youngest', then either:
- the caller asked to modify a future node
- the caller has committed more revisions since this txn
was constructed, and is asking to modify a node in one
of those new revisions.
In either case, the node may not have changed in those new
revisions; use the node's ID to determine this case. */
const svn_fs_id_t *txn_noderev_id;
svn_fs_root_t *rev_root;
const svn_fs_id_t *new_noderev_id;
/* The ID of the node that we would be modifying in the txn */
SVN_ERR(svn_fs_node_id(&txn_noderev_id, txn_root, fspath,
scratch_pool));
/* Get the ID from the future/new revision. */
SVN_ERR(svn_fs_revision_root(&rev_root, svn_fs_root_fs(txn_root),
revision, scratch_pool));
SVN_ERR(svn_fs_node_id(&new_noderev_id, rev_root, fspath,
scratch_pool));
svn_fs_close_root(rev_root);
/* Has the target node changed in the future? */
if (svn_fs_compare_ids(txn_noderev_id, new_noderev_id) != 0)
{
/* Restarting the commit will base the txn on the future/new
revision, allowing the modification at REVISION. */
/* ### use a custom error code */
return svn_error_createf(SVN_ERR_FS_CONFLICT, NULL,
_("'%s' has been modified since the "
"commit began (restart the commit)"),
fspath);
}
}
return SVN_NO_ERROR;
}
/* This helper is the main "meat" of the editor -- it does all the
work of writing a node record.
Write out a node record for PATH of type KIND under EB->FS_ROOT.
ACTION describes what is happening to the node (see enum svn_node_action).
Write record to writable EB->STREAM, using EB->BUFFER to write in chunks.
If the node was itself copied, IS_COPY is TRUE and the
path/revision of the copy source are in CMP_PATH/CMP_REV. If
IS_COPY is FALSE, yet CMP_PATH/CMP_REV are valid, this node is part
of a copied subtree.
*/
static svn_error_t *
dump_node(struct edit_baton *eb,
const char *path,
svn_node_kind_t kind,
enum svn_node_action action,
svn_boolean_t is_copy,
const char *cmp_path,
svn_revnum_t cmp_rev,
apr_pool_t *pool)
{
svn_stringbuf_t *propstring;
svn_filesize_t content_length = 0;
apr_size_t len;
svn_boolean_t must_dump_text = FALSE, must_dump_props = FALSE;
const char *compare_path = path;
svn_revnum_t compare_rev = eb->current_rev - 1;
svn_fs_root_t *compare_root = NULL;
apr_file_t *delta_file = NULL;
/* Maybe validate the path. */
if (eb->verify || eb->notify_func)
{
svn_error_t *err = svn_fs__path_valid(path, pool);
if (err)
{
if (eb->notify_func)
{
char errbuf[512]; /* ### svn_strerror() magic number */
svn_repos_notify_t *notify;
notify = svn_repos_notify_create(svn_repos_notify_warning, pool);
notify->warning = svn_repos_notify_warning_invalid_fspath;
notify->warning_str = apr_psprintf(
pool,
_("E%06d: While validating fspath '%s': %s"),
err->apr_err, path,
svn_err_best_message(err, errbuf, sizeof(errbuf)));
eb->notify_func(eb->notify_baton, notify, pool);
}
/* Return the error in addition to notifying about it. */
if (eb->verify)
return svn_error_trace(err);
else
svn_error_clear(err);
}
}
/* Write out metadata headers for this file node. */
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_PATH ": %s\n",
path));
if (kind == svn_node_file)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_KIND ": file\n"));
else if (kind == svn_node_dir)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_KIND ": dir\n"));
/* Remove leading slashes from copyfrom paths. */
if (cmp_path)
cmp_path = svn_relpath_canonicalize(cmp_path, pool);
/* Validate the comparison path/rev. */
if (ARE_VALID_COPY_ARGS(cmp_path, cmp_rev))
{
compare_path = cmp_path;
compare_rev = cmp_rev;
}
if (action == svn_node_action_change)
{
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION
": change\n"));
/* either the text or props changed, or possibly both. */
SVN_ERR(svn_fs_revision_root(&compare_root,
svn_fs_root_fs(eb->fs_root),
compare_rev, pool));
SVN_ERR(svn_fs_props_changed(&must_dump_props,
compare_root, compare_path,
eb->fs_root, path, pool));
if (kind == svn_node_file)
SVN_ERR(svn_fs_contents_changed(&must_dump_text,
compare_root, compare_path,
eb->fs_root, path, pool));
}
else if (action == svn_node_action_replace)
{
if (! is_copy)
{
/* a simple delete+add, implied by a single 'replace' action. */
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION
": replace\n"));
/* definitely need to dump all content for a replace. */
if (kind == svn_node_file)
must_dump_text = TRUE;
must_dump_props = TRUE;
}
else
{
/* more complex: delete original, then add-with-history. */
/* the path & kind headers have already been printed; just
add a delete action, and end the current record.*/
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION
": delete\n\n"));
/* recurse: print an additional add-with-history record. */
SVN_ERR(dump_node(eb, path, kind, svn_node_action_add,
is_copy, compare_path, compare_rev, pool));
/* we can leave this routine quietly now, don't need to dump
any content; that was already done in the second record. */
must_dump_text = FALSE;
must_dump_props = FALSE;
}
}
else if (action == svn_node_action_delete)
{
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION
": delete\n"));
/* we can leave this routine quietly now, don't need to dump
any content. */
must_dump_text = FALSE;
must_dump_props = FALSE;
}
else if (action == svn_node_action_add)
{
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION ": add\n"));
if (! is_copy)
{
/* Dump all contents for a simple 'add'. */
if (kind == svn_node_file)
must_dump_text = TRUE;
must_dump_props = TRUE;
}
else
{
if (!eb->verify && cmp_rev < eb->oldest_dumped_rev
&& eb->notify_func)
{
svn_repos_notify_t *notify =
svn_repos_notify_create(svn_repos_notify_warning, pool);
notify->warning = svn_repos_notify_warning_found_old_reference;
notify->warning_str = apr_psprintf(
pool,
_("Referencing data in revision %ld,"
" which is older than the oldest"
" dumped revision (r%ld). Loading this dump"
" into an empty repository"
" will fail."),
cmp_rev, eb->oldest_dumped_rev);
eb->found_old_reference = TRUE;
eb->notify_func(eb->notify_baton, notify, pool);
}
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_COPYFROM_REV
": %ld\n"
SVN_REPOS_DUMPFILE_NODE_COPYFROM_PATH
": %s\n",
cmp_rev, cmp_path));
SVN_ERR(svn_fs_revision_root(&compare_root,
svn_fs_root_fs(eb->fs_root),
compare_rev, pool));
/* Need to decide if the copied node had any extra textual or
property mods as well. */
SVN_ERR(svn_fs_props_changed(&must_dump_props,
compare_root, compare_path,
eb->fs_root, path, pool));
if (kind == svn_node_file)
{
svn_checksum_t *checksum;
const char *hex_digest;
SVN_ERR(svn_fs_contents_changed(&must_dump_text,
compare_root, compare_path,
eb->fs_root, path, pool));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
compare_root, compare_path,
FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_MD5
": %s\n", hex_digest));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
compare_root, compare_path,
FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_SHA1
": %s\n", hex_digest));
}
}
}
if ((! must_dump_text) && (! must_dump_props))
{
/* If we're not supposed to dump text or props, so be it, we can
just go home. However, if either one needs to be dumped,
then our dumpstream format demands that at a *minimum*, we
see a lone "PROPS-END" as a divider between text and props
content within the content-block. */
len = 2;
return svn_stream_write(eb->stream, "\n\n", &len); /* ### needed? */
}
/*** Start prepping content to dump... ***/
/* If we are supposed to dump properties, write out a property
length header and generate a stringbuf that contains those
property values here. */
if (must_dump_props)
{
apr_hash_t *prophash, *oldhash = NULL;
apr_size_t proplen;
svn_stream_t *propstream;
SVN_ERR(svn_fs_node_proplist(&prophash, eb->fs_root, path, pool));
/* If this is a partial dump, then issue a warning if we dump mergeinfo
properties that refer to revisions older than the first revision
dumped. */
if (!eb->verify && eb->notify_func && eb->oldest_dumped_rev > 1)
{
svn_string_t *mergeinfo_str = apr_hash_get(prophash,
SVN_PROP_MERGEINFO,
APR_HASH_KEY_STRING);
if (mergeinfo_str)
{
svn_mergeinfo_t mergeinfo, old_mergeinfo;
SVN_ERR(svn_mergeinfo_parse(&mergeinfo, mergeinfo_str->data,
pool));
SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
&old_mergeinfo, mergeinfo,
eb->oldest_dumped_rev - 1, 0,
TRUE, pool, pool));
if (apr_hash_count(old_mergeinfo))
{
svn_repos_notify_t *notify =
svn_repos_notify_create(svn_repos_notify_warning, pool);
notify->warning = svn_repos_notify_warning_found_old_mergeinfo;
notify->warning_str = apr_psprintf(
pool,
_("Mergeinfo referencing revision(s) prior "
"to the oldest dumped revision (r%ld). "
"Loading this dump may result in invalid "
"mergeinfo."),
eb->oldest_dumped_rev);
eb->found_old_mergeinfo = TRUE;
eb->notify_func(eb->notify_baton, notify, pool);
}
}
}
if (eb->use_deltas && compare_root)
{
/* Fetch the old property hash to diff against and output a header
saying that our property contents are a delta. */
SVN_ERR(svn_fs_node_proplist(&oldhash, compare_root, compare_path,
pool));
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_PROP_DELTA
": true\n"));
}
else
oldhash = apr_hash_make(pool);
propstring = svn_stringbuf_create_ensure(0, pool);
propstream = svn_stream_from_stringbuf(propstring, pool);
SVN_ERR(svn_hash_write_incremental(prophash, oldhash, propstream,
"PROPS-END", pool));
SVN_ERR(svn_stream_close(propstream));
proplen = propstring->len;
content_length += proplen;
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n", proplen));
}
/* If we are supposed to dump text, write out a text length header
here, and an MD5 checksum (if available). */
if (must_dump_text && (kind == svn_node_file))
{
svn_checksum_t *checksum;
const char *hex_digest;
svn_filesize_t textlen;
if (eb->use_deltas)
{
/* Compute the text delta now and write it into a temporary
file, so that we can find its length. Output a header
saying our text contents are a delta. */
SVN_ERR(store_delta(&delta_file, &textlen, compare_root,
compare_path, eb->fs_root, path, pool));
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_DELTA
": true\n"));
if (compare_root)
{
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
compare_root, compare_path,
FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_MD5
": %s\n", hex_digest));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
compare_root, compare_path,
FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_SHA1
": %s\n", hex_digest));
}
}
else
{
/* Just fetch the length of the file. */
SVN_ERR(svn_fs_file_length(&textlen, eb->fs_root, path, pool));
}
content_length += textlen;
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_CONTENT_LENGTH
": %" SVN_FILESIZE_T_FMT "\n", textlen));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
eb->fs_root, path, FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_CONTENT_MD5
": %s\n", hex_digest));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
eb->fs_root, path, FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_CONTENT_SHA1
": %s\n", hex_digest));
}
/* 'Content-length:' is the last header before we dump the content,
and is the sum of the text and prop contents lengths. We write
this only for the benefit of non-Subversion RFC-822 parsers. */
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_CONTENT_LENGTH
": %" SVN_FILESIZE_T_FMT "\n\n",
content_length));
/* Dump property content if we're supposed to do so. */
if (must_dump_props)
{
len = propstring->len;
SVN_ERR(svn_stream_write(eb->stream, propstring->data, &len));
}
/* Dump text content */
if (must_dump_text && (kind == svn_node_file))
{
svn_stream_t *contents;
if (delta_file)
{
/* Make sure to close the underlying file when the stream is
closed. */
contents = svn_stream_from_aprfile2(delta_file, FALSE, pool);
}
else
SVN_ERR(svn_fs_file_contents(&contents, eb->fs_root, path, pool));
SVN_ERR(svn_stream_copy3(contents, svn_stream_disown(eb->stream, pool),
NULL, NULL, pool));
}
len = 2;
return svn_stream_write(eb->stream, "\n\n", &len); /* ### needed? */
}
static svn_error_t *
path_driver_cb_func(void **dir_baton,
void *parent_baton,
void *callback_baton,
const char *edit_path,
apr_pool_t *pool)
{
struct path_driver_cb_baton *cb = callback_baton;
const svn_delta_editor_t *editor = cb->editor;
void *edit_baton = cb->edit_baton;
svn_fs_root_t *root = cb->root;
svn_fs_path_change2_t *change;
svn_boolean_t do_add = FALSE, do_delete = FALSE;
void *file_baton = NULL;
svn_revnum_t copyfrom_rev;
const char *copyfrom_path;
svn_boolean_t src_readable = TRUE;
svn_fs_root_t *source_root = cb->compare_root;
const char *source_fspath = NULL;
const char *base_path = cb->base_path;
size_t base_path_len = cb->base_path_len;
*dir_baton = NULL;
/* Initialize SOURCE_FSPATH. */
if (source_root)
source_fspath = svn_fspath__canonicalize(edit_path, pool);
/* First, flush the copies stack so it only contains ancestors of path. */
while (cb->copies->nelts > 0
&& ! svn_dirent_is_ancestor(APR_ARRAY_IDX(cb->copies,
cb->copies->nelts - 1,
struct copy_info).path,
edit_path))
cb->copies->nelts--;
change = apr_hash_get(cb->changed_paths, edit_path, APR_HASH_KEY_STRING);
if (! change)
{
/* This can only happen if the path was removed from cb->changed_paths
by an earlier call to add_subdir, which means the path was already
handled and we should simply ignore it. */
return SVN_NO_ERROR;
}
switch (change->change_kind)
{
case svn_fs_path_change_add:
do_add = TRUE;
break;
case svn_fs_path_change_delete:
do_delete = TRUE;
break;
case svn_fs_path_change_replace:
do_add = TRUE;
do_delete = TRUE;
break;
case svn_fs_path_change_modify:
default:
/* do nothing */
break;
}
/* Handle any deletions. */
if (do_delete)
SVN_ERR(editor->delete_entry(edit_path, SVN_INVALID_REVNUM,
parent_baton, pool));
/* Fetch the node kind if it makes sense to do so. */
if (! do_delete || do_add)
{
if (change->node_kind == svn_node_unknown)
SVN_ERR(svn_fs_check_path(&(change->node_kind), root, edit_path, pool));
if ((change->node_kind != svn_node_dir) &&
(change->node_kind != svn_node_file))
return svn_error_createf(SVN_ERR_FS_NOT_FOUND, NULL,
_("Filesystem path '%s' is neither a file "
"nor a directory"), edit_path);
}
/* Handle any adds/opens. */
if (do_add)
{
svn_fs_root_t *copyfrom_root = NULL;
/* Was this node copied? */
if (! change->copyfrom_known)
{
SVN_ERR(svn_fs_copied_from(&(change->copyfrom_rev),
&(change->copyfrom_path),
root, edit_path, pool));
change->copyfrom_known = TRUE;
}
copyfrom_rev = change->copyfrom_rev;
copyfrom_path = change->copyfrom_path;
if (copyfrom_path && SVN_IS_VALID_REVNUM(copyfrom_rev))
{
SVN_ERR(svn_fs_revision_root(©from_root,
svn_fs_root_fs(root),
copyfrom_rev, pool));
if (cb->authz_read_func)
{
SVN_ERR(cb->authz_read_func(&src_readable, copyfrom_root,
copyfrom_path,
cb->authz_read_baton, pool));
}
}
/* If we have a copyfrom path, and we can't read it or we're just
ignoring it, or the copyfrom rev is prior to the low water mark
then we just null them out and do a raw add with no history at
all. */
if (copyfrom_path
&& ((! src_readable)
|| (! is_within_base_path(copyfrom_path + 1, base_path,
base_path_len))
|| (cb->low_water_mark > copyfrom_rev)))
{
copyfrom_path = NULL;
copyfrom_rev = SVN_INVALID_REVNUM;
}
/* Do the right thing based on the path KIND. */
if (change->node_kind == svn_node_dir)
{
/* If this is a copy, but we can't represent it as such,
then we just do a recursive add of the source path
contents. */
if (change->copyfrom_path && ! copyfrom_path)
{
SVN_ERR(add_subdir(copyfrom_root, root, editor, edit_baton,
edit_path, parent_baton, change->copyfrom_path,
cb->authz_read_func, cb->authz_read_baton,
cb->changed_paths, pool, dir_baton));
}
else
{
SVN_ERR(editor->add_directory(edit_path, parent_baton,
copyfrom_path, copyfrom_rev,
pool, dir_baton));
}
}
else
{
SVN_ERR(editor->add_file(edit_path, parent_baton, copyfrom_path,
copyfrom_rev, pool, &file_baton));
}
/* If we represent this as a copy... */
if (copyfrom_path)
{
/* If it is a directory, make sure descendants get the correct
delta source by remembering that we are operating inside a
(possibly nested) copy operation. */
if (change->node_kind == svn_node_dir)
{
struct copy_info *info = &APR_ARRAY_PUSH(cb->copies,
struct copy_info);
info->path = apr_pstrdup(cb->pool, edit_path);
info->copyfrom_path = apr_pstrdup(cb->pool, copyfrom_path);
info->copyfrom_rev = copyfrom_rev;
}
/* Save the source so that we can use it later, when we
need to generate text and prop deltas. */
source_root = copyfrom_root;
source_fspath = copyfrom_path;
}
else
/* Else, we are an add without history... */
{
/* If an ancestor is added with history, we need to forget about
that here, go on with life and repeat all the mistakes of our
past... */
if (change->node_kind == svn_node_dir && cb->copies->nelts > 0)
{
struct copy_info *info = &APR_ARRAY_PUSH(cb->copies,
struct copy_info);
info->path = apr_pstrdup(cb->pool, edit_path);
info->copyfrom_path = NULL;
info->copyfrom_rev = SVN_INVALID_REVNUM;
}
source_root = NULL;
source_fspath = NULL;
}
}
/* Recursively traverse EDIT_PATH (as it exists under SOURCE_ROOT) emitting
the appropriate editor calls to add it and its children without any
history. This is meant to be used when either a subset of the tree
has been ignored and we need to copy something from that subset to
the part of the tree we do care about, or if a subset of the tree is
unavailable because of authz and we need to use it as the source of
a copy. */
static svn_error_t *
add_subdir(svn_fs_root_t *source_root,
svn_fs_root_t *target_root,
const svn_delta_editor_t *editor,
void *edit_baton,
const char *edit_path,
void *parent_baton,
const char *source_fspath,
svn_repos_authz_func_t authz_read_func,
void *authz_read_baton,
apr_hash_t *changed_paths,
apr_pool_t *pool,
void **dir_baton)
{
apr_pool_t *subpool = svn_pool_create(pool);
apr_hash_index_t *hi, *phi;
apr_hash_t *dirents;
apr_hash_t *props;
SVN_ERR(editor->add_directory(edit_path, parent_baton, NULL,
SVN_INVALID_REVNUM, pool, dir_baton));
SVN_ERR(svn_fs_node_proplist(&props, target_root, edit_path, pool));
for (phi = apr_hash_first(pool, props); phi; phi = apr_hash_next(phi))
{
const void *key;
void *val;
svn_pool_clear(subpool);
apr_hash_this(phi, &key, NULL, &val);
SVN_ERR(editor->change_dir_prop(*dir_baton, key, val, subpool));
}
/* We have to get the dirents from the source path, not the target,
because we want nested copies from *readable* paths to be handled by
path_driver_cb_func, not add_subdir (in order to preserve history). */
SVN_ERR(svn_fs_dir_entries(&dirents, source_root, source_fspath, pool));
for (hi = apr_hash_first(pool, dirents); hi; hi = apr_hash_next(hi))
{
svn_fs_path_change2_t *change;
svn_boolean_t readable = TRUE;
svn_fs_dirent_t *dent;
const char *copyfrom_path = NULL;
svn_revnum_t copyfrom_rev = SVN_INVALID_REVNUM;
const char *new_edit_path;
void *val;
svn_pool_clear(subpool);
apr_hash_this(hi, NULL, NULL, &val);
dent = val;
new_edit_path = svn_relpath_join(edit_path, dent->name, subpool);
/* If a file or subdirectory of the copied directory is listed as a
changed path (because it was modified after the copy but before the
commit), we remove it from the changed_paths hash so that future
calls to path_driver_cb_func will ignore it. */
change = apr_hash_get(changed_paths, new_edit_path, APR_HASH_KEY_STRING);
if (change)
{
apr_hash_set(changed_paths, new_edit_path, APR_HASH_KEY_STRING, NULL);
/* If it's a delete, skip this entry. */
if (change->change_kind == svn_fs_path_change_delete)
continue;
/* If it's a replacement, check for copyfrom info (if we
don't have it already. */
if (change->change_kind == svn_fs_path_change_replace)
{
if (! change->copyfrom_known)
{
SVN_ERR(svn_fs_copied_from(&change->copyfrom_rev,
&change->copyfrom_path,
target_root, new_edit_path, pool));
change->copyfrom_known = TRUE;
}
copyfrom_path = change->copyfrom_path;
copyfrom_rev = change->copyfrom_rev;
}
}
if (authz_read_func)
SVN_ERR(authz_read_func(&readable, target_root, new_edit_path,
authz_read_baton, pool));
if (! readable)
continue;
if (dent->kind == svn_node_dir)
{
svn_fs_root_t *new_source_root;
const char *new_source_fspath;
void *new_dir_baton;
if (copyfrom_path)
{
svn_fs_t *fs = svn_fs_root_fs(source_root);
SVN_ERR(svn_fs_revision_root(&new_source_root, fs,
copyfrom_rev, pool));
new_source_fspath = copyfrom_path;
}
else
{
new_source_root = source_root;
new_source_fspath = svn_fspath__join(source_fspath, dent->name,
subpool);
}
/* ### authz considerations?
*
* I think not; when path_driver_cb_func() calls add_subdir(), it
* passes SOURCE_ROOT and SOURCE_FSPATH that are unreadable.
*/
if (change && change->change_kind == svn_fs_path_change_replace
&& copyfrom_path == NULL)
{
SVN_ERR(editor->add_directory(new_edit_path, *dir_baton,
NULL, SVN_INVALID_REVNUM,
subpool, &new_dir_baton));
}
else
{
SVN_ERR(add_subdir(new_source_root, target_root,
editor, edit_baton, new_edit_path,
*dir_baton, new_source_fspath,
authz_read_func, authz_read_baton,
changed_paths, subpool, &new_dir_baton));
}
SVN_ERR(editor->close_directory(new_dir_baton, subpool));
}
else if (dent->kind == svn_node_file)
{
svn_txdelta_window_handler_t delta_handler;
void *delta_handler_baton, *file_baton;
svn_txdelta_stream_t *delta_stream;
svn_checksum_t *checksum;
SVN_ERR(editor->add_file(new_edit_path, *dir_baton, NULL,
SVN_INVALID_REVNUM, pool, &file_baton));
SVN_ERR(svn_fs_node_proplist(&props, target_root,
new_edit_path, subpool));
for (phi = apr_hash_first(pool, props); phi; phi = apr_hash_next(phi))
{
const void *key;
apr_hash_this(phi, &key, NULL, &val);
SVN_ERR(editor->change_file_prop(file_baton, key, val, subpool));
}
SVN_ERR(editor->apply_textdelta(file_baton, NULL, pool,
&delta_handler,
&delta_handler_baton));
SVN_ERR(svn_fs_get_file_delta_stream(&delta_stream, NULL, NULL,
target_root, new_edit_path,
pool));
SVN_ERR(svn_txdelta_send_txstream(delta_stream,
delta_handler,
delta_handler_baton,
pool));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5, target_root,
new_edit_path, TRUE, pool));
SVN_ERR(editor->close_file(file_baton,
svn_checksum_to_cstring(checksum, pool),
pool));
}
else
SVN_ERR_MALFUNCTION();
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
