/*
* delta.c: an editor driver for expressing differences between two trees
*
* ====================================================================
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
* ====================================================================
*/
#include <apr_hash.h>
#include "svn_hash.h"
#include "svn_types.h"
#include "svn_delta.h"
#include "svn_fs.h"
#include "svn_checksum.h"
#include "svn_path.h"
#include "svn_repos.h"
#include "svn_pools.h"
#include "svn_props.h"
#include "svn_private_config.h"
#include "repos.h"
/* THINGS TODO: Currently the code herein gives only a slight nod to
fully supporting directory deltas that involve renames, copies, and
such. */
/* Some datatypes and declarations used throughout the file. */
/* Parameters which remain constant throughout a delta traversal.
At the top of the recursion, we initialize one of these structures.
Then we pass it down to every call. This way, functions invoked
deep in the recursion can get access to this traversal's global
parameters, without using global variables. */
struct context {
const svn_delta_editor_t *editor;
const char *edit_base_path;
svn_fs_root_t *source_root;
svn_fs_root_t *target_root;
svn_repos_authz_func_t authz_read_func;
void *authz_read_baton;
svn_boolean_t text_deltas;
svn_boolean_t entry_props;
svn_boolean_t ignore_ancestry;
};
/* The type of a function that accepts changes to an object's property
list. OBJECT is the object whose properties are being changed.
NAME is the name of the property to change. VALUE is the new value
for the property, or zero if the property should be deleted. */
typedef svn_error_t *proplist_change_fn_t(struct context *c,
void *object,
const char *name,
const svn_string_t *value,
apr_pool_t *pool);
/* Some prototypes for functions used throughout. See each individual
function for information about what it does. */
/* Retrieving the base revision from the path/revision hash. */
static svn_revnum_t get_path_revision(svn_fs_root_t *root,
const char *path,
apr_pool_t *pool);
/* proplist_change_fn_t property changing functions. */
static svn_error_t *change_dir_prop(struct context *c,
void *object,
const char *path,
const svn_string_t *value,
apr_pool_t *pool);
static svn_error_t *change_file_prop(struct context *c,
void *object,
const char *path,
const svn_string_t *value,
apr_pool_t *pool);
/* Constructing deltas for properties of files and directories. */
static svn_error_t *delta_proplists(struct context *c,
const char *source_path,
const char *target_path,
proplist_change_fn_t *change_fn,
void *object,
apr_pool_t *pool);
/* Constructing deltas for file constents. */
static svn_error_t *send_text_delta(struct context *c,
void *file_baton,
const char *base_checksum,
svn_txdelta_stream_t *delta_stream,
apr_pool_t *pool);
static svn_error_t *delta_files(struct context *c,
void *file_baton,
const char *source_path,
const char *target_path,
apr_pool_t *pool);
/* Generic directory deltafication routines. */
static svn_error_t *delete(struct context *c,
void *dir_baton,
const char *edit_path,
apr_pool_t *pool);
static svn_error_t *add_file_or_dir(struct context *c,
void *dir_baton,
svn_depth_t depth,
const char *target_path,
const char *edit_path,
svn_node_kind_t tgt_kind,
apr_pool_t *pool);
static svn_error_t *replace_file_or_dir(struct context *c,
void *dir_baton,
svn_depth_t depth,
const char *source_path,
const char *target_path,
const char *edit_path,
svn_node_kind_t tgt_kind,
apr_pool_t *pool);
static svn_error_t *absent_file_or_dir(struct context *c,
void *dir_baton,
const char *edit_path,
svn_node_kind_t tgt_kind,
apr_pool_t *pool);
static svn_error_t *delta_dirs(struct context *c,
void *dir_baton,
svn_depth_t depth,
const char *source_path,
const char *target_path,
const char *edit_path,
apr_pool_t *pool);
#define MAYBE_DEMOTE_DEPTH(depth) \
(((depth) == svn_depth_immediates || (depth) == svn_depth_files) \
? svn_depth_empty \
: (depth))
/* Return the error 'SVN_ERR_AUTHZ_ROOT_UNREADABLE' if PATH in ROOT is
* unreadable according to AUTHZ_READ_FUNC with AUTHZ_READ_BATON.
*
* PATH should be the implicit root path of an editor drive, that is,
* the path used by editor->open_root().
*/
static svn_error_t *
authz_root_check(svn_fs_root_t *root,
const char *path,
svn_repos_authz_func_t authz_read_func,
void *authz_read_baton,
apr_pool_t *pool)
{
svn_boolean_t allowed;
if (authz_read_func)
{
SVN_ERR(authz_read_func(&allowed, root, path, authz_read_baton, pool));
if (! allowed)
return svn_error_create(SVN_ERR_AUTHZ_ROOT_UNREADABLE, 0,
_("Unable to open root of edit"));
}
return SVN_NO_ERROR;
}
static svn_error_t *
not_a_dir_error(const char *role,
const char *path)
{
return svn_error_createf
(SVN_ERR_FS_NOT_DIRECTORY, 0,
"Invalid %s directory '%s'",
role, path ? path : "(null)");
}
/* Public interface to computing directory deltas. */
svn_error_t *
svn_repos_dir_delta2(svn_fs_root_t *src_root,
const char *src_parent_dir,
const char *src_entry,
svn_fs_root_t *tgt_root,
const char *tgt_fullpath,
const svn_delta_editor_t *editor,
void *edit_baton,
svn_repos_authz_func_t authz_read_func,
void *authz_read_baton,
svn_boolean_t text_deltas,
svn_depth_t depth,
svn_boolean_t entry_props,
svn_boolean_t ignore_ancestry,
apr_pool_t *pool)
{
void *root_baton = NULL;
struct context c;
const char *src_fullpath;
const svn_fs_id_t *src_id, *tgt_id;
svn_node_kind_t src_kind, tgt_kind;
svn_revnum_t rootrev;
int distance;
const char *authz_root_path;
/* SRC_PARENT_DIR must be valid. */
if (src_parent_dir)
src_parent_dir = svn_relpath_canonicalize(src_parent_dir, pool);
else
return not_a_dir_error("source parent", src_parent_dir);
/* TGT_FULLPATH must be valid. */
if (tgt_fullpath)
tgt_fullpath = svn_relpath_canonicalize(tgt_fullpath, pool);
else
return svn_error_create(SVN_ERR_FS_PATH_SYNTAX, 0,
_("Invalid target path"));
if (depth == svn_depth_exclude)
return svn_error_create(SVN_ERR_REPOS_BAD_ARGS, NULL,
_("Delta depth 'exclude' not supported"));
/* Calculate the fs path implicitly used for editor->open_root, so
we can do an authz check on that path first. */
if (*src_entry)
authz_root_path = svn_relpath_dirname(tgt_fullpath, pool);
else
authz_root_path = tgt_fullpath;
/* Construct the full path of the source item. */
src_fullpath = svn_relpath_join(src_parent_dir, src_entry, pool);
/* Get the node kinds for the source and target paths. */
SVN_ERR(svn_fs_check_path(&tgt_kind, tgt_root, tgt_fullpath, pool));
SVN_ERR(svn_fs_check_path(&src_kind, src_root, src_fullpath, pool));
/* If neither of our paths exists, we don't really have anything to do. */
if ((tgt_kind == svn_node_none) && (src_kind == svn_node_none))
goto cleanup;
/* If either the source or the target is a non-directory, we
require that a SRC_ENTRY be supplied. */
if ((! *src_entry) && ((src_kind != svn_node_dir)
|| tgt_kind != svn_node_dir))
return svn_error_create
(SVN_ERR_FS_PATH_SYNTAX, 0,
_("Invalid editor anchoring; at least one of the "
"input paths is not a directory and there was no source entry"));
/* Set the global target revision if one can be determined. */
if (svn_fs_is_revision_root(tgt_root))
{
SVN_ERR(editor->set_target_revision
(edit_baton, svn_fs_revision_root_revision(tgt_root), pool));
}
else if (svn_fs_is_txn_root(tgt_root))
{
SVN_ERR(editor->set_target_revision
(edit_baton, svn_fs_txn_root_base_revision(tgt_root), pool));
}
/* Setup our pseudo-global structure here. We need these variables
throughout the deltafication process, so pass them around by
reference to all the helper functions. */
c.editor = editor;
c.source_root = src_root;
c.target_root = tgt_root;
c.authz_read_func = authz_read_func;
c.authz_read_baton = authz_read_baton;
c.text_deltas = text_deltas;
c.entry_props = entry_props;
c.ignore_ancestry = ignore_ancestry;
/* Get our editor root's revision. */
rootrev = get_path_revision(src_root, src_parent_dir, pool);
/* If one or the other of our paths doesn't exist, we have to handle
those cases specially. */
if (tgt_kind == svn_node_none)
{
/* Caller thinks that target still exists, but it doesn't.
So transform their source path to "nothing" by deleting it. */
SVN_ERR(authz_root_check(tgt_root, authz_root_path,
authz_read_func, authz_read_baton, pool));
SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
SVN_ERR(delete(&c, root_baton, src_entry, pool));
goto cleanup;
}
if (src_kind == svn_node_none)
{
/* The source path no longer exists, but the target does.
So transform "nothing" into "something" by adding. */
SVN_ERR(authz_root_check(tgt_root, authz_root_path,
authz_read_func, authz_read_baton, pool));
SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
SVN_ERR(add_file_or_dir(&c, root_baton, depth, tgt_fullpath,
src_entry, tgt_kind, pool));
goto cleanup;
}
/* Get and compare the node IDs for the source and target. */
SVN_ERR(svn_fs_node_id(&tgt_id, tgt_root, tgt_fullpath, pool));
SVN_ERR(svn_fs_node_id(&src_id, src_root, src_fullpath, pool));
distance = svn_fs_compare_ids(src_id, tgt_id);
if (distance == 0)
{
/* They are the same node! No-op (you gotta love those). */
goto cleanup;
}
else if (*src_entry)
{
/* If the nodes have different kinds, we must delete the one and
add the other. Also, if they are completely unrelated and
our caller is interested in relatedness, we do the same thing. */
if ((src_kind != tgt_kind)
|| ((distance == -1) && (! ignore_ancestry)))
{
SVN_ERR(authz_root_check(tgt_root, authz_root_path,
authz_read_func, authz_read_baton, pool));
SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
SVN_ERR(delete(&c, root_baton, src_entry, pool));
SVN_ERR(add_file_or_dir(&c, root_baton, depth, tgt_fullpath,
src_entry, tgt_kind, pool));
}
/* Otherwise, we just replace the one with the other. */
else
{
SVN_ERR(authz_root_check(tgt_root, authz_root_path,
authz_read_func, authz_read_baton, pool));
SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
SVN_ERR(replace_file_or_dir(&c, root_baton, depth, src_fullpath,
tgt_fullpath, src_entry,
tgt_kind, pool));
}
}
else
{
/* There is no entry given, so delta the whole parent directory. */
SVN_ERR(authz_root_check(tgt_root, authz_root_path,
authz_read_func, authz_read_baton, pool));
SVN_ERR(editor->open_root(edit_baton, rootrev, pool, &root_baton));
SVN_ERR(delta_dirs(&c, root_baton, depth, src_fullpath,
tgt_fullpath, "", pool));
}
cleanup:
/* Make sure we close the root directory if we opened one above. */
if (root_baton)
SVN_ERR(editor->close_directory(root_baton, pool));
/* Close the edit. */
return editor->close_edit(edit_baton, pool);
}
/* Retrieving the base revision from the path/revision hash. */
static svn_revnum_t
get_path_revision(svn_fs_root_t *root,
const char *path,
apr_pool_t *pool)
{
svn_revnum_t revision;
svn_error_t *err;
/* Easy out -- if ROOT is a revision root, we can use the revision
that it's a root of. */
if (svn_fs_is_revision_root(root))
return svn_fs_revision_root_revision(root);
/* Else, this must be a transaction root, so ask the filesystem in
what revision this path was created. */
if ((err = svn_fs_node_created_rev(&revision, root, path, pool)))
{
revision = SVN_INVALID_REVNUM;
svn_error_clear(err);
}
/* If we don't get back a valid revision, this path is mutable in
the transaction. We should probably examine the node on which it
is based, doable by querying for the node-id of the path, and
then examining that node-id's predecessor. ### This predecessor
determination isn't exposed via the FS public API right now, so
for now, we'll just return the SVN_INVALID_REVNUM. */
return revision;
}
/* proplist_change_fn_t property changing functions. */
/* Call the directory property-setting function of C->editor to set
the property NAME to given VALUE on the OBJECT passed to this
function. */
static svn_error_t *
change_dir_prop(struct context *c,
void *object,
const char *name,
const svn_string_t *value,
apr_pool_t *pool)
{
return c->editor->change_dir_prop(object, name, value, pool);
}
/* Call the file property-setting function of C->editor to set the
property NAME to given VALUE on the OBJECT passed to this
function. */
static svn_error_t *
change_file_prop(struct context *c,
void *object,
const char *name,
const svn_string_t *value,
apr_pool_t *pool)
{
return c->editor->change_file_prop(object, name, value, pool);
}
/* Constructing deltas for properties of files and directories. */
/* Generate the appropriate property editing calls to turn the
properties of SOURCE_PATH into those of TARGET_PATH. If
SOURCE_PATH is NULL, this is an add, so assume the target starts
with no properties. Pass OBJECT on to the editor function wrapper
CHANGE_FN. */
static svn_error_t *
delta_proplists(struct context *c,
const char *source_path,
const char *target_path,
proplist_change_fn_t *change_fn,
void *object,
apr_pool_t *pool)
{
apr_hash_t *s_props = 0;
apr_hash_t *t_props = 0;
apr_pool_t *subpool;
apr_array_header_t *prop_diffs;
int i;
SVN_ERR_ASSERT(target_path);
/* Make a subpool for local allocations. */
subpool = svn_pool_create(pool);
/* If we're supposed to send entry props for all non-deleted items,
here we go! */
if (c->entry_props)
{
svn_revnum_t committed_rev = SVN_INVALID_REVNUM;
svn_string_t *cr_str = NULL;
svn_string_t *committed_date = NULL;
svn_string_t *last_author = NULL;
/* Get the CR and two derivative props. ### check for error returns. */
SVN_ERR(svn_fs_node_created_rev(&committed_rev, c->target_root,
target_path, subpool));
if (SVN_IS_VALID_REVNUM(committed_rev))
{
svn_fs_t *fs = svn_fs_root_fs(c->target_root);
apr_hash_t *r_props;
const char *uuid;
/* Transmit the committed-rev. */
cr_str = svn_string_createf(subpool, "%ld",
committed_rev);
SVN_ERR(change_fn(c, object, SVN_PROP_ENTRY_COMMITTED_REV,
cr_str, subpool));
SVN_ERR(svn_fs_revision_proplist(&r_props, fs, committed_rev,
pool));
/* Transmit the committed-date. */
committed_date = svn_hash_gets(r_props, SVN_PROP_REVISION_DATE);
if (committed_date || source_path)
{
SVN_ERR(change_fn(c, object, SVN_PROP_ENTRY_COMMITTED_DATE,
committed_date, subpool));
}
/* Transmit the last-author. */
last_author = svn_hash_gets(r_props, SVN_PROP_REVISION_AUTHOR);
if (last_author || source_path)
{
SVN_ERR(change_fn(c, object, SVN_PROP_ENTRY_LAST_AUTHOR,
last_author, subpool));
}
/* Transmit the UUID. */
SVN_ERR(svn_fs_get_uuid(fs, &uuid, subpool));
SVN_ERR(change_fn(c, object, SVN_PROP_ENTRY_UUID,
svn_string_create(uuid, subpool),
subpool));
}
}
if (source_path)
{
svn_boolean_t changed;
/* Is this deltification worth our time? */
SVN_ERR(svn_fs_props_changed(&changed, c->target_root, target_path,
c->source_root, source_path, subpool));
if (! changed)
goto cleanup;
/* If so, go ahead and get the source path's properties. */
SVN_ERR(svn_fs_node_proplist(&s_props, c->source_root,
source_path, subpool));
}
else
{
s_props = apr_hash_make(subpool);
}
/* Get the target path's properties */
SVN_ERR(svn_fs_node_proplist(&t_props, c->target_root,
target_path, subpool));
/* Now transmit the differences. */
SVN_ERR(svn_prop_diffs(&prop_diffs, t_props, s_props, subpool));
for (i = 0; i < prop_diffs->nelts; i++)
{
const svn_prop_t *pc = &APR_ARRAY_IDX(prop_diffs, i, svn_prop_t);
SVN_ERR(change_fn(c, object, pc->name, pc->value, subpool));
}
cleanup:
/* Destroy local subpool. */
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* Constructing deltas for file contents. */
/* Change the contents of FILE_BATON in C->editor, according to the
text delta from DELTA_STREAM. Pass BASE_CHECKSUM along to
C->editor->apply_textdelta. */
static svn_error_t *
send_text_delta(struct context *c,
void *file_baton,
const char *base_checksum,
svn_txdelta_stream_t *delta_stream,
apr_pool_t *pool)
{
svn_txdelta_window_handler_t delta_handler;
void *delta_handler_baton;
/* Get a handler that will apply the delta to the file. */
SVN_ERR(c->editor->apply_textdelta
(file_baton, base_checksum, pool,
&delta_handler, &delta_handler_baton));
if (c->text_deltas && delta_stream)
{
/* Deliver the delta stream to the file. */
return svn_txdelta_send_txstream(delta_stream,
delta_handler,
delta_handler_baton,
pool);
}
else
{
/* The caller doesn't want text delta data. Just send a single
NULL window. */
return delta_handler(NULL, delta_handler_baton);
}
}
svn_error_t *
svn_repos__compare_files(svn_boolean_t *changed_p,
svn_fs_root_t *root1,
const char *path1,
svn_fs_root_t *root2,
const char *path2,
apr_pool_t *pool)
{
svn_filesize_t size1, size2;
svn_checksum_t *checksum1, *checksum2;
svn_stream_t *stream1, *stream2;
svn_boolean_t same;
/* If the filesystem claims the things haven't changed, then they
haven't changed. */
SVN_ERR(svn_fs_contents_changed(changed_p, root1, path1,
root2, path2, pool));
if (!*changed_p)
return SVN_NO_ERROR;
/* If the SHA1 checksums match for these things, we'll claim they
have the same contents. (We don't give quite as much weight to
MD5 checksums.) */
SVN_ERR(svn_fs_file_checksum(&checksum1, svn_checksum_sha1,
root1, path1, FALSE, pool));
SVN_ERR(svn_fs_file_checksum(&checksum2, svn_checksum_sha1,
root2, path2, FALSE, pool));
if (checksum1 && checksum2)
{
*changed_p = !svn_checksum_match(checksum1, checksum2);
return SVN_NO_ERROR;
}
/* From this point on, our default answer is "Nothing's changed". */
*changed_p = FALSE;
/* Different filesizes means the contents are different. */
SVN_ERR(svn_fs_file_length(&size1, root1, path1, pool));
SVN_ERR(svn_fs_file_length(&size2, root2, path2, pool));
if (size1 != size2)
{
*changed_p = TRUE;
return SVN_NO_ERROR;
}
/* Different MD5 checksums means the contents are different. */
SVN_ERR(svn_fs_file_checksum(&checksum1, svn_checksum_md5, root1, path1,
FALSE, pool));
SVN_ERR(svn_fs_file_checksum(&checksum2, svn_checksum_md5, root2, path2,
FALSE, pool));
if (! svn_checksum_match(checksum1, checksum2))
{
*changed_p = TRUE;
return SVN_NO_ERROR;
}
/* And finally, different contents means the ... uh ... contents are
different. */
SVN_ERR(svn_fs_file_contents(&stream1, root1, path1, pool));
SVN_ERR(svn_fs_file_contents(&stream2, root2, path2, pool));
SVN_ERR(svn_stream_contents_same2(&same, stream1, stream2, pool));
*changed_p = !same;
return SVN_NO_ERROR;
}
/* Make the appropriate edits on FILE_BATON to change its contents and
properties from those in SOURCE_PATH to those in TARGET_PATH. */
static svn_error_t *
delta_files(struct context *c,
void *file_baton,
const char *source_path,
const char *target_path,
apr_pool_t *pool)
{
apr_pool_t *subpool;
svn_boolean_t changed = TRUE;
SVN_ERR_ASSERT(target_path);
/* Make a subpool for local allocations. */
subpool = svn_pool_create(pool);
/* Compare the files' property lists. */
SVN_ERR(delta_proplists(c, source_path, target_path,
change_file_prop, file_baton, subpool));
if (source_path)
{
/* Is this delta calculation worth our time? If we are ignoring
ancestry, then our editor implementor isn't concerned by the
theoretical differences between "has contents which have not
changed with respect to" and "has the same actual contents
as". We'll do everything we can to avoid transmitting even
an empty text-delta in that case. */
if (c->ignore_ancestry)
SVN_ERR(svn_repos__compare_files(&changed,
c->target_root, target_path,
c->source_root, source_path,
subpool));
else
SVN_ERR(svn_fs_contents_changed(&changed,
c->target_root, target_path,
c->source_root, source_path,
subpool));
}
else
{
/* If there isn't a source path, this is an add, which
necessarily has textual mods. */
}
/* If there is a change, and the context indicates that we should
care about it, then hand it off to a delta stream. */
if (changed)
{
svn_txdelta_stream_t *delta_stream = NULL;
svn_checksum_t *source_checksum;
const char *source_hex_digest = NULL;
if (c->text_deltas)
{
/* Get a delta stream turning an empty file into one having
TARGET_PATH's contents. */
SVN_ERR(svn_fs_get_file_delta_stream
(&delta_stream,
source_path ? c->source_root : NULL,
source_path ? source_path : NULL,
c->target_root, target_path, subpool));
}
if (source_path)
{
SVN_ERR(svn_fs_file_checksum(&source_checksum, svn_checksum_md5,
c->source_root, source_path, TRUE,
subpool));
source_hex_digest = svn_checksum_to_cstring(source_checksum,
subpool);
}
SVN_ERR(send_text_delta(c, file_baton, source_hex_digest,
delta_stream, subpool));
}
/* Cleanup. */
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* Generic directory deltafication routines. */
/* Emit a delta to delete the entry named TARGET_ENTRY from DIR_BATON. */
static svn_error_t *
delete(struct context *c,
void *dir_baton,
const char *edit_path,
apr_pool_t *pool)
{
return c->editor->delete_entry(edit_path, SVN_INVALID_REVNUM,
dir_baton, pool);
}
/* If authorized, emit a delta to create the entry named TARGET_ENTRY
at the location EDIT_PATH. If not authorized, indicate that
EDIT_PATH is absent. Pass DIR_BATON through to editor functions
that require it. DEPTH is the depth from this point downward. */
static svn_error_t *
add_file_or_dir(struct context *c, void *dir_baton,
svn_depth_t depth,
const char *target_path,
const char *edit_path,
svn_node_kind_t tgt_kind,
apr_pool_t *pool)
{
struct context *context = c;
svn_boolean_t allowed;
SVN_ERR_ASSERT(target_path && edit_path);
if (c->authz_read_func)
{
SVN_ERR(c->authz_read_func(&allowed, c->target_root, target_path,
c->authz_read_baton, pool));
if (!allowed)
return absent_file_or_dir(c, dir_baton, edit_path, tgt_kind, pool);
}
if (tgt_kind == svn_node_dir)
{
void *subdir_baton;
SVN_ERR(context->editor->add_directory(edit_path, dir_baton, NULL,
SVN_INVALID_REVNUM, pool,
&subdir_baton));
SVN_ERR(delta_dirs(context, subdir_baton, MAYBE_DEMOTE_DEPTH(depth),
NULL, target_path, edit_path, pool));
return context->editor->close_directory(subdir_baton, pool);
}
else
{
void *file_baton;
svn_checksum_t *checksum;
SVN_ERR(context->editor->add_file(edit_path, dir_baton,
NULL, SVN_INVALID_REVNUM, pool,
&file_baton));
SVN_ERR(delta_files(context, file_baton, NULL, target_path, pool));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
context->target_root, target_path,
TRUE, pool));
return context->editor->close_file
(file_baton, svn_checksum_to_cstring(checksum, pool), pool);
}
}
/* If authorized, emit a delta to modify EDIT_PATH with the changes
from SOURCE_PATH to TARGET_PATH. If not authorized, indicate that
EDIT_PATH is absent. Pass DIR_BATON through to editor functions
that require it. DEPTH is the depth from this point downward. */
static svn_error_t *
replace_file_or_dir(struct context *c,
void *dir_baton,
svn_depth_t depth,
const char *source_path,
const char *target_path,
const char *edit_path,
svn_node_kind_t tgt_kind,
apr_pool_t *pool)
{
svn_revnum_t base_revision = SVN_INVALID_REVNUM;
svn_boolean_t allowed;
SVN_ERR_ASSERT(target_path && source_path && edit_path);
if (c->authz_read_func)
{
SVN_ERR(c->authz_read_func(&allowed, c->target_root, target_path,
c->authz_read_baton, pool));
if (!allowed)
return absent_file_or_dir(c, dir_baton, edit_path, tgt_kind, pool);
}
/* Get the base revision for the entry from the hash. */
base_revision = get_path_revision(c->source_root, source_path, pool);
if (tgt_kind == svn_node_dir)
{
void *subdir_baton;
SVN_ERR(c->editor->open_directory(edit_path, dir_baton,
base_revision, pool,
&subdir_baton));
SVN_ERR(delta_dirs(c, subdir_baton, MAYBE_DEMOTE_DEPTH(depth),
source_path, target_path, edit_path, pool));
return c->editor->close_directory(subdir_baton, pool);
}
else
{
void *file_baton;
svn_checksum_t *checksum;
SVN_ERR(c->editor->open_file(edit_path, dir_baton, base_revision,
pool, &file_baton));
SVN_ERR(delta_files(c, file_baton, source_path, target_path, pool));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
c->target_root, target_path, TRUE,
pool));
return c->editor->close_file
(file_baton, svn_checksum_to_cstring(checksum, pool), pool);
}
}
/* In directory DIR_BATON, indicate that EDIT_PATH (relative to the
edit root) is absent by invoking C->editor->absent_directory or
C->editor->absent_file (depending on TGT_KIND). */
static svn_error_t *
absent_file_or_dir(struct context *c,
void *dir_baton,
const char *edit_path,
svn_node_kind_t tgt_kind,
apr_pool_t *pool)
{
SVN_ERR_ASSERT(edit_path);
if (tgt_kind == svn_node_dir)
return c->editor->absent_directory(edit_path, dir_baton, pool);
else
return c->editor->absent_file(edit_path, dir_baton, pool);
}
/* Emit deltas to turn SOURCE_PATH into TARGET_PATH. Assume that
DIR_BATON represents the directory we're constructing to the editor
in the context C. */
static svn_error_t *
delta_dirs(struct context *c,
void *dir_baton,
svn_depth_t depth,
const char *source_path,
const char *target_path,
const char *edit_path,
apr_pool_t *pool)
{
apr_hash_t *s_entries = 0, *t_entries = 0;
apr_hash_index_t *hi;
apr_pool_t *subpool;
SVN_ERR_ASSERT(target_path);
/* Compare the property lists. */
SVN_ERR(delta_proplists(c, source_path, target_path,
change_dir_prop, dir_baton, pool));
/* Get the list of entries in each of source and target. */
SVN_ERR(svn_fs_dir_entries(&t_entries, c->target_root,
target_path, pool));
if (source_path)
SVN_ERR(svn_fs_dir_entries(&s_entries, c->source_root,
source_path, pool));
/* Make a subpool for local allocations. */
subpool = svn_pool_create(pool);
/* Loop over the hash of entries in the target, searching for its
partner in the source. If we find the matching partner entry,
use editor calls to replace the one in target with a new version
if necessary, then remove that entry from the source entries
hash. If we can't find a related node in the source, we use
editor calls to add the entry as a new item in the target.
Having handled all the entries that exist in target, any entries
still remaining the source entries hash represent entries that no
longer exist in target. Use editor calls to delete those entries
from the target tree. */
for (hi = apr_hash_first(pool, t_entries); hi; hi = apr_hash_next(hi))
{
const svn_fs_dirent_t *s_entry, *t_entry;
const void *key;
void *val;
apr_ssize_t klen;
const char *t_fullpath;
const char *e_fullpath;
const char *s_fullpath;
svn_node_kind_t tgt_kind;
/* Clear out our subpool for the next iteration... */
svn_pool_clear(subpool);
/* KEY is the entry name in target, VAL the dirent */
apr_hash_this(hi, &key, &klen, &val);
t_entry = val;
tgt_kind = t_entry->kind;
t_fullpath = svn_relpath_join(target_path, t_entry->name, subpool);
e_fullpath = svn_relpath_join(edit_path, t_entry->name, subpool);
/* Can we find something with the same name in the source
entries hash? */
if (s_entries && ((s_entry = apr_hash_get(s_entries, key, klen)) != 0))
{
svn_node_kind_t src_kind;
s_fullpath = svn_relpath_join(source_path, t_entry->name, subpool);
src_kind = s_entry->kind;
if (depth == svn_depth_infinity
|| src_kind != svn_node_dir
|| (src_kind == svn_node_dir
&& depth == svn_depth_immediates))
{
/* Use svn_fs_compare_ids() to compare our current
source and target ids.
0: means they are the same id, and this is a noop.
-1: means they are unrelated, so we have to delete the
old one and add the new one.
1: means the nodes are related through ancestry, so go
ahead and do the replace directly. */
int distance = svn_fs_compare_ids(s_entry->id, t_entry->id);
if (distance == 0)
{
/* no-op */
}
else if ((src_kind != tgt_kind)
|| ((distance == -1) && (! c->ignore_ancestry)))
{
SVN_ERR(delete(c, dir_baton, e_fullpath, subpool));
SVN_ERR(add_file_or_dir(c, dir_baton,
MAYBE_DEMOTE_DEPTH(depth),
t_fullpath, e_fullpath, tgt_kind,
subpool));
}
else
{
SVN_ERR(replace_file_or_dir(c, dir_baton,
MAYBE_DEMOTE_DEPTH(depth),
s_fullpath, t_fullpath,
e_fullpath, tgt_kind,
subpool));
}
}
/* Remove the entry from the source_hash. */
svn_hash_sets(s_entries, key, NULL);
}
else
{
if (depth == svn_depth_infinity
|| tgt_kind != svn_node_dir
|| (tgt_kind == svn_node_dir
&& depth == svn_depth_immediates))
{
SVN_ERR(add_file_or_dir(c, dir_baton,
MAYBE_DEMOTE_DEPTH(depth),
t_fullpath, e_fullpath, tgt_kind,
subpool));
}
}
}
/* All that is left in the source entries hash are things that need
to be deleted. Delete them. */
if (s_entries)
{
for (hi = apr_hash_first(pool, s_entries); hi; hi = apr_hash_next(hi))
{
const svn_fs_dirent_t *s_entry;
void *val;
const char *e_fullpath;
svn_node_kind_t src_kind;
/* Clear out our subpool for the next iteration... */
svn_pool_clear(subpool);
/* KEY is the entry name in source, VAL the dirent */
apr_hash_this(hi, NULL, NULL, &val);
s_entry = val;
src_kind = s_entry->kind;
e_fullpath = svn_relpath_join(edit_path, s_entry->name, subpool);
/* Do we actually want to delete the dir if we're non-recursive? */
if (depth == svn_depth_infinity
|| src_kind != svn_node_dir
|| (src_kind == svn_node_dir
&& depth == svn_depth_immediates))
{
SVN_ERR(delete(c, dir_baton, e_fullpath, subpool));
}
}
}
/* Destroy local allocation subpool. */
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}