svn_wc_notify_t *
svn_wc_dup_notify(const svn_wc_notify_t *notify,
apr_pool_t *pool)
{
svn_wc_notify_t *ret = apr_palloc(pool, sizeof(*ret));
*ret = *notify;
if (ret->path)
ret->path = apr_pstrdup(pool, ret->path);
if (ret->mime_type)
ret->mime_type = apr_pstrdup(pool, ret->mime_type);
if (ret->lock)
ret->lock = svn_lock_dup(ret->lock, pool);
if (ret->err)
{
ret->err = svn_error_dup(ret->err);
apr_pool_cleanup_register(pool, ret->err, err_cleanup,
apr_pool_cleanup_null);
}
if (ret->changelist_name)
ret->changelist_name = apr_pstrdup(pool, ret->changelist_name);
if (ret->merge_range)
ret->merge_range = svn_merge_range_dup(ret->merge_range, pool);
if (ret->url)
ret->url = apr_pstrdup(pool, ret->url);
if (ret->path_prefix)
ret->path_prefix = apr_pstrdup(pool, ret->path_prefix);
if (ret->prop_name)
ret->prop_name = apr_pstrdup(pool, ret->prop_name);
if (ret->rev_props)
ret->rev_props = svn_prop_hash_dup(ret->rev_props, pool);
return ret;
}
/* Callback for log messages: implements svn_log_entry_receiver_t and
accumulates revision metadata into a chronologically ordered list stored in
the baton. */
static svn_error_t *
fr_log_message_receiver(void *baton,
svn_log_entry_t *log_entry,
apr_pool_t *pool)
{
struct fr_log_message_baton *lmb = baton;
struct rev *rev;
rev = apr_palloc(lmb->pool, sizeof(*rev));
rev->revision = log_entry->revision;
rev->path = lmb->path;
rev->next = lmb->eldest;
lmb->eldest = rev;
/* Duplicate log_entry revprops into rev->props */
rev->props = svn_prop_hash_dup(log_entry->revprops, lmb->pool);
return prev_log_path(&lmb->path, &lmb->action,
&lmb->copyrev, log_entry->changed_paths2,
lmb->path, svn_node_file, log_entry->revision,
lmb->pool);
}
/* Add PATH to the operations tree rooted at OPERATION, creating any
intermediate nodes that are required. Here's what's expected for
each action type:
ACTION URL REV SRC-FILE PROPNAME
------------ ----- ------- -------- --------
ACTION_MKDIR NULL invalid NULL NULL
ACTION_CP valid valid NULL NULL
ACTION_PUT NULL invalid valid NULL
ACTION_RM NULL invalid NULL NULL
ACTION_PROPSET valid invalid NULL valid
Node type information is obtained for any copy source (to determine
whether to create a file or directory) and for any deleted path (to
ensure it exists since svn_delta_editor_t->delete_entry doesn't
return an error on non-existent nodes). */
static svn_error_t *
build(struct editor_baton *eb,
action_code_t action,
const char *relpath,
const char *url,
svn_revnum_t rev,
apr_hash_t *props,
const char *src_file,
svn_revnum_t head,
apr_pool_t *scratch_pool)
{
apr_array_header_t *path_bits = svn_path_decompose(relpath, scratch_pool);
const char *path_so_far = "";
struct operation *operation = &eb->root;
int i;
/* We should only see PROPS when action is ACTION_PROPSET. */
SVN_ERR_ASSERT((props && action == ACTION_PROPSET)
|| (!props && action != ACTION_PROPSET) );
/* Look for any previous operations we've recognized for PATH. If
any of PATH's ancestors have not yet been traversed, we'll be
creating OP_OPEN operations for them as we walk down PATH's path
components. */
for (i = 0; i < path_bits->nelts; ++i)
{
const char *path_bit = APR_ARRAY_IDX(path_bits, i, const char *);
path_so_far = svn_relpath_join(path_so_far, path_bit, scratch_pool);
operation = get_operation(path_so_far, operation, eb->edit_pool);
}
/* Handle property changes. */
if (props)
{
SVN_ERR(eb->fetch_kind_func(&operation->kind, eb->fetch_kind_baton,
relpath, scratch_pool));
/* If we're not adding this thing ourselves, check for existence. */
if (! ((operation->operation == OP_ADD) ||
(operation->operation == OP_REPLACE)))
{
if ((operation->kind == svn_node_file)
&& (operation->operation == OP_OPEN))
operation->operation = OP_PROPSET;
}
operation->props = svn_prop_hash_dup(props, eb->edit_pool);
if (!operation->rev)
operation->rev = rev;
return SVN_NO_ERROR;
}
if (action == ACTION_RM)
operation->operation = OP_DELETE;
/* Handle copy operations (which can be adds or replacements). */
else if (action == ACTION_CP)
{
operation->operation =
operation->operation == OP_DELETE ? OP_REPLACE : OP_ADD;
SVN_ERR(eb->fetch_kind_func(&operation->kind, eb->fetch_kind_baton,
relpath, scratch_pool));
operation->url = url;
operation->rev = rev;
}
/* Handle mkdir operations (which can be adds or replacements). */
else if (action == ACTION_MKDIR)
{
operation->operation =
operation->operation == OP_DELETE ? OP_REPLACE : OP_ADD;
operation->kind = svn_node_dir;
}
/* Handle put operations (which can be adds, replacements, or opens). */
else if (action == ACTION_PUT)
{
if (operation->operation == OP_DELETE)
{
operation->operation = OP_REPLACE;
}
else
{
SVN_ERR(eb->fetch_kind_func(&operation->kind, eb->fetch_kind_baton,
relpath, scratch_pool));
if (operation->kind == svn_node_file)
operation->operation = OP_OPEN;
else if (operation->kind == svn_node_none)
operation->operation = OP_ADD;
else
return svn_error_createf(SVN_ERR_BAD_URL, NULL,
"'%s' is not a file", relpath);
}
operation->kind = svn_node_file;
operation->src_file = src_file;
}
else
{
/* We shouldn't get here. */
SVN_ERR_MALFUNCTION();
}
return SVN_NO_ERROR;
}
static svn_error_t *
file_rev_handler(void *baton, const char *path, svn_revnum_t revnum,
apr_hash_t *rev_props,
svn_boolean_t merged_revision,
svn_txdelta_window_handler_t *content_delta_handler,
void **content_delta_baton,
apr_array_header_t *prop_diffs,
apr_pool_t *pool)
{
struct file_rev_baton *frb = baton;
svn_stream_t *last_stream;
svn_stream_t *cur_stream;
struct delta_baton *delta_baton;
apr_pool_t *filepool;
/* Clear the current pool. */
svn_pool_clear(frb->currpool);
/* If this file has a non-textual mime-type, bail out. */
if (! frb->ignore_mime_type)
SVN_ERR(check_mimetype(prop_diffs, frb->target, frb->currpool));
if (frb->ctx->notify_func2)
{
svn_wc_notify_t *notify
= svn_wc_create_notify_url(
svn_path_url_add_component2(frb->repos_root_url,
path+1, pool),
svn_wc_notify_blame_revision, pool);
notify->path = path;
notify->kind = svn_node_none;
notify->content_state = notify->prop_state
= svn_wc_notify_state_inapplicable;
notify->lock_state = svn_wc_notify_lock_state_inapplicable;
notify->revision = revnum;
notify->rev_props = rev_props;
frb->ctx->notify_func2(frb->ctx->notify_baton2, notify, pool);
}
if (frb->ctx->cancel_func)
SVN_ERR(frb->ctx->cancel_func(frb->ctx->cancel_baton));
/* If there were no content changes, we couldn't care less about this
revision now. Note that we checked the mime type above, so things
work if the user just changes the mime type in a commit.
Also note that we don't switch the pools in this case. This is important,
since the tempfile will be removed by the pool and we need the tempfile
from the last revision with content changes. */
if (!content_delta_handler)
return SVN_NO_ERROR;
frb->merged_revision = merged_revision;
/* Create delta baton. */
delta_baton = apr_palloc(frb->currpool, sizeof(*delta_baton));
/* Prepare the text delta window handler. */
if (frb->last_filename)
SVN_ERR(svn_stream_open_readonly(&delta_baton->source_stream, frb->last_filename,
frb->currpool, pool));
else
/* Means empty stream below. */
delta_baton->source_stream = NULL;
last_stream = svn_stream_disown(delta_baton->source_stream, pool);
if (frb->include_merged_revisions && !frb->merged_revision)
filepool = frb->filepool;
else
filepool = frb->currpool;
SVN_ERR(svn_stream_open_unique(&cur_stream, &delta_baton->filename, NULL,
svn_io_file_del_on_pool_cleanup,
filepool, filepool));
/* Get window handler for applying delta. */
svn_txdelta_apply(last_stream, cur_stream, NULL, NULL,
frb->currpool,
&delta_baton->wrapped_handler,
&delta_baton->wrapped_baton);
/* Wrap the window handler with our own. */
delta_baton->file_rev_baton = frb;
*content_delta_handler = window_handler;
*content_delta_baton = delta_baton;
/* Create the rev structure. */
frb->rev = apr_pcalloc(frb->mainpool, sizeof(struct rev));
if (revnum < frb->start_rev)
{
/* We shouldn't get more than one revision before the starting
revision (unless of including merged revisions). */
SVN_ERR_ASSERT((frb->last_filename == NULL)
|| frb->include_merged_revisions);
/* The file existed before start_rev; generate no blame info for
lines from this revision (or before). */
frb->rev->revision = SVN_INVALID_REVNUM;
}
else
{
SVN_ERR_ASSERT(revnum <= frb->end_rev);
/* Set values from revision props. */
frb->rev->revision = revnum;
frb->rev->rev_props = svn_prop_hash_dup(rev_props, frb->mainpool);
}
if (frb->include_merged_revisions)
frb->rev->path = apr_pstrdup(frb->mainpool, path);
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_get_commit_editor5(const svn_delta_editor_t **editor,
void **edit_baton,
svn_repos_t *repos,
svn_fs_txn_t *txn,
const char *repos_url,
const char *base_path,
apr_hash_t *revprop_table,
svn_commit_callback2_t callback,
void *callback_baton,
svn_repos_authz_callback_t authz_callback,
void *authz_baton,
apr_pool_t *pool)
{
svn_delta_editor_t *e;
apr_pool_t *subpool = svn_pool_create(pool);
struct edit_baton *eb;
/* Do a global authz access lookup. Users with no write access
whatsoever to the repository don't get a commit editor. */
if (authz_callback)
{
svn_boolean_t allowed;
SVN_ERR(authz_callback(svn_authz_write, &allowed, NULL, NULL,
authz_baton, pool));
if (!allowed)
return svn_error_create(SVN_ERR_AUTHZ_UNWRITABLE, NULL,
"Not authorized to open a commit editor.");
}
/* Allocate the structures. */
e = svn_delta_default_editor(pool);
eb = apr_pcalloc(subpool, sizeof(*eb));
/* Set up the editor. */
e->open_root = open_root;
e->delete_entry = delete_entry;
e->add_directory = add_directory;
e->open_directory = open_directory;
e->change_dir_prop = change_dir_prop;
e->add_file = add_file;
e->open_file = open_file;
e->close_file = close_file;
e->apply_textdelta = apply_textdelta;
e->change_file_prop = change_file_prop;
e->close_edit = close_edit;
e->abort_edit = abort_edit;
/* Set up the edit baton. */
eb->pool = subpool;
eb->revprop_table = svn_prop_hash_dup(revprop_table, subpool);
eb->commit_callback = callback;
eb->commit_callback_baton = callback_baton;
eb->authz_callback = authz_callback;
eb->authz_baton = authz_baton;
eb->base_path = svn_fspath__canonicalize(base_path, subpool);
eb->repos = repos;
eb->repos_url = repos_url;
eb->repos_name = svn_dirent_basename(svn_repos_path(repos, subpool),
subpool);
eb->fs = svn_repos_fs(repos);
eb->txn = txn;
eb->txn_owner = txn == NULL;
*edit_baton = eb;
*editor = e;
return SVN_NO_ERROR;
}
