svn_error_t *
svn_repos_fs_get_locks(apr_hash_t **locks,
svn_repos_t *repos,
const char *path,
svn_repos_authz_func_t authz_read_func,
void *authz_read_baton,
apr_pool_t *pool)
{
apr_hash_t *all_locks = apr_hash_make(pool);
svn_revnum_t head_rev;
struct get_locks_baton_t baton;
/* Locks are always said to apply to HEAD revision, so we'll check
to see if locked-paths are readable in HEAD as well. */
SVN_ERR(svn_fs_youngest_rev(&head_rev, repos->fs, pool));
/* Populate our callback baton. */
baton.fs = repos->fs;
baton.locks = all_locks;
baton.authz_read_func = authz_read_func;
baton.authz_read_baton = authz_read_baton;
SVN_ERR(svn_fs_revision_root(&(baton.head_root), repos->fs,
head_rev, pool));
/* Get all the locks. */
SVN_ERR(svn_fs_get_locks(repos->fs, path, get_locks_callback,
&baton, pool));
*locks = baton.locks;
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_fs_get_locks2(apr_hash_t **locks,
svn_repos_t *repos,
const char *path,
svn_depth_t depth,
svn_repos_authz_func_t authz_read_func,
void *authz_read_baton,
apr_pool_t *pool)
{
apr_hash_t *all_locks = apr_hash_make(pool);
svn_revnum_t head_rev;
struct get_locks_baton_t baton;
SVN_ERR_ASSERT((depth == svn_depth_empty) ||
(depth == svn_depth_files) ||
(depth == svn_depth_immediates) ||
(depth == svn_depth_infinity));
SVN_ERR(svn_fs_youngest_rev(&head_rev, repos->fs, pool));
/* Populate our callback baton. */
baton.fs = repos->fs;
baton.locks = all_locks;
baton.authz_read_func = authz_read_func;
baton.authz_read_baton = authz_read_baton;
SVN_ERR(svn_fs_revision_root(&(baton.head_root), repos->fs,
head_rev, pool));
/* Get all the locks. */
SVN_ERR(svn_fs_get_locks2(repos->fs, path, depth,
get_locks_callback, &baton, pool));
*locks = baton.locks;
return SVN_NO_ERROR;
}
void set_revision(svn_revnum_t revnum)
{
if (revnum == 0)
{
check_svn(svn_fs_youngest_rev(&revnum, fs, apr_pool));
}
check_svn(svn_fs_revision_root(&fs_root, fs, revnum, apr_pool));
}
static svn_error_t *
svn_ra_local__get_latest_revnum(svn_ra_session_t *session,
svn_revnum_t *latest_revnum,
apr_pool_t *pool)
{
svn_ra_local__session_baton_t *sess = session->priv;
return svn_fs_youngest_rev(latest_revnum, sess->fs, pool);
}
Repository(char const* path)
{
svn_repos_t *repos;
check_svn(svn_repos_open(&repos, path, apr_pool));
fs = svn_repos_fs(repos);
svn_revnum_t revnum;
check_svn(svn_fs_youngest_rev(&revnum, fs, apr_pool));
check_svn(svn_fs_revision_root(&fs_root, fs, revnum, apr_pool));
}
/* Getting just one file. */
static svn_error_t *
svn_ra_local__get_file(svn_ra_session_t *session,
const char *path,
svn_revnum_t revision,
svn_stream_t *stream,
svn_revnum_t *fetched_rev,
apr_hash_t **props,
apr_pool_t *pool)
{
svn_fs_root_t *root;
svn_stream_t *contents;
svn_revnum_t youngest_rev;
svn_ra_local__session_baton_t *sess = session->priv;
const char *abs_path = svn_path_join(sess->fs_path->data, path, pool);
/* Open the revision's root. */
if (! SVN_IS_VALID_REVNUM(revision))
{
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, sess->fs, pool));
SVN_ERR(svn_fs_revision_root(&root, sess->fs, youngest_rev, pool));
if (fetched_rev != NULL)
*fetched_rev = youngest_rev;
}
else
SVN_ERR(svn_fs_revision_root(&root, sess->fs, revision, pool));
if (stream)
{
/* Get a stream representing the file's contents. */
SVN_ERR(svn_fs_file_contents(&contents, root, abs_path, pool));
/* Now push data from the fs stream back at the caller's stream.
Note that this particular RA layer does not computing a
checksum as we go, and confirming it against the repository's
checksum when done. That's because it calls
svn_fs_file_contents() directly, which already checks the
stored checksum, and all we're doing here is writing bytes in
a loop. Truly, Nothing Can Go Wrong :-). But RA layers that
go over a network should confirm the checksum.
Note: we are not supposed to close the passed-in stream, so
disown the thing.
*/
SVN_ERR(svn_stream_copy3(contents, svn_stream_disown(stream, pool),
sess->callbacks
? sess->callbacks->cancel_func : NULL,
sess->callback_baton,
pool));
}
/* Handle props if requested. */
if (props)
SVN_ERR(get_node_props(props, sess, root, abs_path, pool));
return SVN_NO_ERROR;
}
static svn_error_t *
open_root(void *edit_baton,
svn_revnum_t base_revision,
apr_pool_t *pool,
void **root_baton)
{
struct dir_baton *dirb;
struct edit_baton *eb = edit_baton;
svn_revnum_t youngest;
/* Ignore BASE_REVISION. We always build our transaction against
HEAD. However, we will keep it in our dir baton for out of
dateness checks. */
SVN_ERR(svn_fs_youngest_rev(&youngest, eb->fs, eb->pool));
if (base_revision > youngest)
return svn_error_createf(SVN_ERR_FS_NO_SUCH_REVISION, NULL,
_("No such revision %ld (HEAD is %ld)"),
base_revision, youngest);
/* Unless we've been instructed to use a specific transaction, we'll
make our own. */
if (eb->txn_owner)
{
SVN_ERR(svn_repos_fs_begin_txn_for_commit2(&(eb->txn),
eb->repos,
youngest,
eb->revprop_table,
eb->pool));
}
else /* Even if we aren't the owner of the transaction, we might
have been instructed to set some properties. */
{
apr_array_header_t *props = svn_prop_hash_to_array(eb->revprop_table,
pool);
SVN_ERR(svn_repos_fs_change_txn_props(eb->txn, props, pool));
}
SVN_ERR(svn_fs_txn_name(&(eb->txn_name), eb->txn, eb->pool));
SVN_ERR(svn_fs_txn_root(&(eb->txn_root), eb->txn, eb->pool));
/* Create a root dir baton. The `base_path' field is an -absolute-
path in the filesystem, upon which all further editor paths are
based. */
dirb = apr_pcalloc(pool, sizeof(*dirb));
dirb->edit_baton = edit_baton;
dirb->parent = NULL;
dirb->pool = pool;
dirb->was_copied = FALSE;
dirb->path = apr_pstrdup(pool, eb->base_path);
dirb->base_rev = base_revision;
*root_baton = dirb;
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_fs_get_mergeinfo(svn_mergeinfo_catalog_t *mergeinfo,
svn_repos_t *repos,
const apr_array_header_t *paths,
svn_revnum_t rev,
svn_mergeinfo_inheritance_t inherit,
svn_boolean_t include_descendants,
svn_repos_authz_func_t authz_read_func,
void *authz_read_baton,
apr_pool_t *pool)
{
/* Here we cast away 'const', but won't try to write through this pointer
* without first allocating a new array. */
apr_array_header_t *readable_paths = (apr_array_header_t *) paths;
svn_fs_root_t *root;
apr_pool_t *iterpool = svn_pool_create(pool);
if (!SVN_IS_VALID_REVNUM(rev))
SVN_ERR(svn_fs_youngest_rev(&rev, repos->fs, pool));
SVN_ERR(svn_fs_revision_root(&root, repos->fs, rev, pool));
/* Filter out unreadable paths before divining merge tracking info. */
if (authz_read_func)
{
int i;
for (i = 0; i < paths->nelts; i++)
{
svn_boolean_t readable;
const char *path = APR_ARRAY_IDX(paths, i, char *);
svn_pool_clear(iterpool);
SVN_ERR(authz_read_func(&readable, root, path, authz_read_baton,
iterpool));
if (readable && readable_paths != paths)
APR_ARRAY_PUSH(readable_paths, const char *) = path;
else if (!readable && readable_paths == paths)
{
/* Requested paths differ from readable paths. Fork
list of readable paths from requested paths. */
int j;
readable_paths = apr_array_make(pool, paths->nelts - 1,
sizeof(char *));
for (j = 0; j < i; j++)
{
path = APR_ARRAY_IDX(paths, j, char *);
APR_ARRAY_PUSH(readable_paths, const char *) = path;
}
}
}
}
static PyObject *fs_get_youngest_revision(FileSystemObject *self)
{
svn_revnum_t rev;
apr_pool_t *temp_pool;
PyObject *ret;
temp_pool = Pool(NULL);
if (temp_pool == NULL)
return NULL;
RUN_SVN_WITH_POOL(temp_pool, svn_fs_youngest_rev(&rev, self->fs, temp_pool));
ret = py_from_svn_revnum(rev);
apr_pool_destroy(temp_pool);
return ret;
}
/* The core logic. This function iterates the repository REPOS_PATH
* and sends all the (DATA and/or PROP) reps in each revision for counting
* by process_one_revision(). QUIET is passed to process_one_revision().
*/
static svn_error_t *process(const char *repos_path,
svn_boolean_t prop,
svn_boolean_t data,
svn_boolean_t quiet,
apr_pool_t *scratch_pool)
{
apr_hash_t *prop_reps = NULL;
apr_hash_t *data_reps = NULL;
apr_hash_t *both_reps = NULL;
svn_revnum_t rev, youngest;
apr_pool_t *iterpool;
svn_repos_t *repos;
svn_fs_t *fs;
if (prop)
prop_reps = apr_hash_make(scratch_pool);
if (data)
data_reps = apr_hash_make(scratch_pool);
if (prop && data)
both_reps = apr_hash_make(scratch_pool);
/* Open the FS. */
SVN_ERR(svn_repos_open2(&repos, repos_path, NULL, scratch_pool));
fs = svn_repos_fs(repos);
SVN_ERR(is_fs_fsfs(fs, scratch_pool));
SVN_ERR(svn_fs_youngest_rev(&youngest, fs, scratch_pool));
/* Iterate the revisions. */
iterpool = svn_pool_create(scratch_pool);
for (rev = 0; rev <= youngest; rev++)
{
svn_pool_clear(iterpool);
SVN_ERR(cancel_func(NULL));
SVN_ERR(process_one_revision(fs, rev, quiet,
prop_reps, data_reps, both_reps,
scratch_pool, iterpool));
}
svn_pool_destroy(iterpool);
/* Print stats. */
SVN_ERR(pretty_print("prop", prop_reps, scratch_pool));
SVN_ERR(pretty_print("data", data_reps, scratch_pool));
SVN_ERR(pretty_print("both", both_reps, scratch_pool));
return SVN_NO_ERROR;
}
static svn_error_t *
svn_ra_local__do_check_path(svn_ra_session_t *session,
const char *path,
svn_revnum_t revision,
svn_node_kind_t *kind,
apr_pool_t *pool)
{
svn_ra_local__session_baton_t *sess = session->priv;
svn_fs_root_t *root;
const char *abs_path = svn_path_join(sess->fs_path->data, path, pool);
if (! SVN_IS_VALID_REVNUM(revision))
SVN_ERR(svn_fs_youngest_rev(&revision, sess->fs, pool));
SVN_ERR(svn_fs_revision_root(&root, sess->fs, revision, pool));
return svn_fs_check_path(kind, root, abs_path, pool);
}
/* This implements `svn_opt_subcommand_t'. */
static svn_error_t *
subcommand_index (apr_getopt_t *os, void *baton, apr_pool_t *pool)
{
struct svnindex_opt_state *opt_state = baton;
svn_repos_t *repos;
svn_fs_t *fs;
svn_stream_t *stderr_stream = NULL;
struct recode_write_baton stderr_stream_rwb = { 0 };
svn_revnum_t lower = SVN_INVALID_REVNUM, upper = SVN_INVALID_REVNUM;
svn_revnum_t youngest;
SVN_ERR (open_repos (&repos, opt_state->repository_path, pool));
fs = svn_repos_fs (repos);
SVN_ERR (svn_fs_youngest_rev (&youngest, fs, pool));
/* Find the revision numbers at which to start and end. */
SVN_ERR (get_revnum (&lower, &opt_state->start_revision,
youngest, repos, pool));
SVN_ERR (get_revnum (&upper, &opt_state->end_revision,
youngest, repos, pool));
if (lower > upper)
return svn_error_create
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("First revision cannot be higher than second"));
/* Progress feedback goes to stderr, unless they asked to suppress
it. */
if (! opt_state->quiet)
{
stderr_stream = svn_stream_create (&stderr_stream_rwb, pool);
stderr_stream_rwb.pool = pool;
stderr_stream_rwb.out = stderr;
svn_stream_set_write (stderr_stream, recode_write);
}
SVN_ERR (svnindex__index (repos,
stderr_stream,
lower, upper,
opt_state->verbose,
opt_state->db,
check_cancel,
NULL,
pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs__editor_create(svn_editor_t **editor,
const char **txn_name,
svn_fs_t *fs,
apr_uint32_t flags,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_revnum_t revision;
svn_fs_txn_t *txn;
SVN_ERR(svn_fs_youngest_rev(&revision, fs, scratch_pool));
SVN_ERR(svn_fs_begin_txn2(&txn, fs, revision, flags, result_pool));
SVN_ERR(svn_fs_txn_name(txn_name, txn, result_pool));
return svn_error_trace(make_editor(editor, txn,
cancel_func, cancel_baton,
result_pool, scratch_pool));
}
static svn_error_t *
uuid_record(const char *uuid,
void *parse_baton,
apr_pool_t *pool)
{
struct parse_baton *pb = parse_baton;
svn_revnum_t youngest_rev;
if (pb->uuid_action == svn_repos_load_uuid_ignore)
return SVN_NO_ERROR;
if (pb->uuid_action != svn_repos_load_uuid_force)
{
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, pb->fs, pool));
if (youngest_rev != 0)
return SVN_NO_ERROR;
}
return svn_fs_set_uuid(pb->fs, uuid, pool);
}
/* Build the node-origins index for the repository located at REPOS_PATH. */
static svn_error_t *
build_index(const char *repos_path, apr_pool_t *pool)
{
svn_repos_t *repos;
svn_fs_t *fs;
svn_revnum_t youngest_rev, i;
size_t slotsize;
const char *progress_fmt;
apr_pool_t *subpool;
/* Open the repository. */
SVN_ERR(svn_repos_open3(&repos, repos_path, NULL, pool, pool));
/* Get a filesystem object. */
fs = svn_repos_fs(repos);
/* Fetch the youngest revision of the repository. */
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, fs, pool));
slotsize = strlen(apr_ltoa(pool, youngest_rev));
progress_fmt = apr_psprintf
(pool,
"[%%%" APR_SIZE_T_FMT "ld"
"/%%%" APR_SIZE_T_FMT "ld] "
"Found %%d new lines of history."
"\n", slotsize, slotsize);
/* Now, iterate over all the revisions, calling index_revision_adds(). */
subpool = svn_pool_create(pool);
for (i = 0; i < youngest_rev; i++)
{
int count;
svn_pool_clear(subpool);
SVN_ERR(index_revision_adds(&count, fs, i + 1, subpool));
printf(progress_fmt, i + 1, youngest_rev, count);
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
static svn_error_t *
set_revision_property(void *baton,
const char *name,
const svn_string_t *value)
{
struct revision_baton *rb = baton;
/* If we're skipping this revision, we're done here. */
if (rb->skipped)
return SVN_NO_ERROR;
if (rb->rev > 0)
{
if (rb->pb->validate_props)
SVN_ERR(svn_repos_fs_change_txn_prop(rb->txn, name, value, rb->pool));
else
SVN_ERR(svn_fs_change_txn_prop(rb->txn, name, value, rb->pool));
/* Remember any datestamp that passes through! (See comment in
close_revision() below.) */
if (! strcmp(name, SVN_PROP_REVISION_DATE))
rb->datestamp = svn_string_dup(value, rb->pool);
}
else if (rb->rev == 0)
{
/* Special case: set revision 0 properties when loading into an
'empty' filesystem. */
struct parse_baton *pb = rb->pb;
svn_revnum_t youngest_rev;
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, pb->fs, rb->pool));
if (youngest_rev == 0)
SVN_ERR(change_rev_prop(pb->repos, 0, name, value,
pb->validate_props, rb->pool));
}
return SVN_NO_ERROR;
}
dav_error *
dav_svn__create_activity(const dav_svn_repos *repos,
const char **ptxn_name,
apr_pool_t *pool)
{
svn_revnum_t rev;
svn_fs_txn_t *txn;
svn_error_t *serr;
serr = svn_fs_youngest_rev(&rev, repos->fs, pool);
if (serr != NULL)
{
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"could not determine youngest revision",
repos->pool);
}
serr = svn_repos_fs_begin_txn_for_commit(&txn, repos->repos, rev,
repos->username, NULL,
repos->pool);
if (serr != NULL)
{
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"could not begin a transaction",
repos->pool);
}
serr = svn_fs_txn_name(ptxn_name, txn, pool);
if (serr != NULL)
{
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"could not fetch transaction name",
repos->pool);
}
return NULL;
}
/* The main dumper. */
svn_error_t *
svn_repos_dump_fs3(svn_repos_t *repos,
svn_stream_t *stream,
svn_revnum_t start_rev,
svn_revnum_t end_rev,
svn_boolean_t incremental,
svn_boolean_t use_deltas,
svn_repos_notify_func_t notify_func,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
const svn_delta_editor_t *dump_editor;
void *dump_edit_baton = NULL;
svn_revnum_t i;
svn_fs_t *fs = svn_repos_fs(repos);
apr_pool_t *subpool = svn_pool_create(pool);
svn_revnum_t youngest;
const char *uuid;
int version;
svn_boolean_t found_old_reference = FALSE;
svn_boolean_t found_old_mergeinfo = FALSE;
svn_repos_notify_t *notify;
/* Determine the current youngest revision of the filesystem. */
SVN_ERR(svn_fs_youngest_rev(&youngest, fs, pool));
/* Use default vals if necessary. */
if (! SVN_IS_VALID_REVNUM(start_rev))
start_rev = 0;
if (! SVN_IS_VALID_REVNUM(end_rev))
end_rev = youngest;
if (! stream)
stream = svn_stream_empty(pool);
/* Validate the revisions. */
if (start_rev > end_rev)
return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
_("Start revision %ld"
" is greater than end revision %ld"),
start_rev, end_rev);
if (end_rev > youngest)
return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
_("End revision %ld is invalid "
"(youngest revision is %ld)"),
end_rev, youngest);
if ((start_rev == 0) && incremental)
incremental = FALSE; /* revision 0 looks the same regardless of
whether or not this is an incremental
dump, so just simplify things. */
/* Write out the UUID. */
SVN_ERR(svn_fs_get_uuid(fs, &uuid, pool));
/* If we're not using deltas, use the previous version, for
compatibility with svn 1.0.x. */
version = SVN_REPOS_DUMPFILE_FORMAT_VERSION;
if (!use_deltas)
version--;
/* Write out "general" metadata for the dumpfile. In this case, a
magic header followed by a dumpfile format version. */
SVN_ERR(svn_stream_printf(stream, pool,
SVN_REPOS_DUMPFILE_MAGIC_HEADER ": %d\n\n",
version));
SVN_ERR(svn_stream_printf(stream, pool, SVN_REPOS_DUMPFILE_UUID
": %s\n\n", uuid));
/* Create a notify object that we can reuse in the loop. */
if (notify_func)
notify = svn_repos_notify_create(svn_repos_notify_dump_rev_end,
pool);
/* Main loop: we're going to dump revision i. */
for (i = start_rev; i <= end_rev; i++)
{
svn_revnum_t from_rev, to_rev;
svn_fs_root_t *to_root;
svn_boolean_t use_deltas_for_rev;
svn_pool_clear(subpool);
/* Check for cancellation. */
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
/* Special-case the initial revision dump: it needs to contain
*all* nodes, because it's the foundation of all future
revisions in the dumpfile. */
if ((i == start_rev) && (! incremental))
{
/* Special-special-case a dump of revision 0. */
if (i == 0)
{
/* Just write out the one revision 0 record and move on.
The parser might want to use its properties. */
SVN_ERR(write_revision_record(stream, fs, 0, subpool));
to_rev = 0;
goto loop_end;
}
/* Compare START_REV to revision 0, so that everything
appears to be added. */
from_rev = 0;
to_rev = i;
}
else
{
/* In the normal case, we want to compare consecutive revs. */
from_rev = i - 1;
to_rev = i;
}
/* Write the revision record. */
SVN_ERR(write_revision_record(stream, fs, to_rev, subpool));
/* Fetch the editor which dumps nodes to a file. Regardless of
what we've been told, don't use deltas for the first rev of a
non-incremental dump. */
use_deltas_for_rev = use_deltas && (incremental || i != start_rev);
SVN_ERR(get_dump_editor(&dump_editor, &dump_edit_baton, fs, to_rev,
"", stream, notify_func, notify_baton,
start_rev, use_deltas_for_rev, FALSE, subpool));
/* Drive the editor in one way or another. */
SVN_ERR(svn_fs_revision_root(&to_root, fs, to_rev, subpool));
/* If this is the first revision of a non-incremental dump,
we're in for a full tree dump. Otherwise, we want to simply
replay the revision. */
if ((i == start_rev) && (! incremental))
{
svn_fs_root_t *from_root;
SVN_ERR(svn_fs_revision_root(&from_root, fs, from_rev, subpool));
SVN_ERR(svn_repos_dir_delta2(from_root, "", "",
to_root, "",
dump_editor, dump_edit_baton,
NULL,
NULL,
FALSE, /* don't send text-deltas */
svn_depth_infinity,
FALSE, /* don't send entry props */
FALSE, /* don't ignore ancestry */
subpool));
}
else
{
SVN_ERR(svn_repos_replay2(to_root, "", SVN_INVALID_REVNUM, FALSE,
dump_editor, dump_edit_baton,
NULL, NULL, subpool));
}
loop_end:
if (notify_func)
{
notify->revision = to_rev;
notify_func(notify_baton, notify, subpool);
}
if (dump_edit_baton) /* We never get an edit baton for r0. */
{
if (((struct edit_baton *)dump_edit_baton)->found_old_reference)
found_old_reference = TRUE;
if (((struct edit_baton *)dump_edit_baton)->found_old_mergeinfo)
found_old_mergeinfo = TRUE;
}
}
if (notify_func)
{
/* Did we issue any warnings about references to revisions older than
the oldest dumped revision? If so, then issue a final generic
warning, since the inline warnings already issued might easily be
missed. */
notify = svn_repos_notify_create(svn_repos_notify_dump_end, subpool);
notify_func(notify_baton, notify, subpool);
if (found_old_reference)
{
notify = svn_repos_notify_create(svn_repos_notify_warning, subpool);
notify->warning = svn_repos_notify_warning_found_old_reference;
notify->warning_str = _("The range of revisions dumped "
"contained references to "
"copy sources outside that "
"range.");
notify_func(notify_baton, notify, subpool);
}
/* Ditto if we issued any warnings about old revisions referenced
in dumped mergeinfo. */
if (found_old_mergeinfo)
{
notify = svn_repos_notify_create(svn_repos_notify_warning, subpool);
notify->warning = svn_repos_notify_warning_found_old_mergeinfo;
notify->warning_str = _("The range of revisions dumped "
"contained mergeinfo "
"which reference revisions outside "
"that range.");
notify_func(notify_baton, notify, subpool);
}
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* Getting a directory's entries */
static svn_error_t *
svn_ra_local__get_dir(svn_ra_session_t *session,
apr_hash_t **dirents,
svn_revnum_t *fetched_rev,
apr_hash_t **props,
const char *path,
svn_revnum_t revision,
apr_uint32_t dirent_fields,
apr_pool_t *pool)
{
svn_fs_root_t *root;
svn_revnum_t youngest_rev;
apr_hash_t *entries;
apr_hash_index_t *hi;
svn_ra_local__session_baton_t *sess = session->priv;
apr_pool_t *subpool;
const char *abs_path = svn_path_join(sess->fs_path->data, path, pool);
/* Open the revision's root. */
if (! SVN_IS_VALID_REVNUM(revision))
{
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, sess->fs, pool));
SVN_ERR(svn_fs_revision_root(&root, sess->fs, youngest_rev, pool));
if (fetched_rev != NULL)
*fetched_rev = youngest_rev;
}
else
SVN_ERR(svn_fs_revision_root(&root, sess->fs, revision, pool));
if (dirents)
{
/* Get the dir's entries. */
SVN_ERR(svn_fs_dir_entries(&entries, root, abs_path, pool));
/* Loop over the fs dirents, and build a hash of general
svn_dirent_t's. */
*dirents = apr_hash_make(pool);
subpool = svn_pool_create(pool);
for (hi = apr_hash_first(pool, entries); hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_t *prophash;
const char *datestring, *entryname, *fullpath;
svn_fs_dirent_t *fs_entry;
svn_dirent_t *entry = apr_pcalloc(pool, sizeof(*entry));
svn_pool_clear(subpool);
apr_hash_this(hi, &key, NULL, &val);
entryname = (const char *) key;
fs_entry = (svn_fs_dirent_t *) val;
fullpath = svn_path_join(abs_path, entryname, subpool);
if (dirent_fields & SVN_DIRENT_KIND)
{
/* node kind */
entry->kind = fs_entry->kind;
}
if (dirent_fields & SVN_DIRENT_SIZE)
{
/* size */
if (entry->kind == svn_node_dir)
entry->size = 0;
else
SVN_ERR(svn_fs_file_length(&(entry->size), root,
fullpath, subpool));
}
if (dirent_fields & SVN_DIRENT_HAS_PROPS)
{
/* has_props? */
SVN_ERR(svn_fs_node_proplist(&prophash, root, fullpath,
subpool));
entry->has_props = (apr_hash_count(prophash) != 0);
}
if ((dirent_fields & SVN_DIRENT_TIME)
|| (dirent_fields & SVN_DIRENT_LAST_AUTHOR)
|| (dirent_fields & SVN_DIRENT_CREATED_REV))
{
/* created_rev & friends */
SVN_ERR(svn_repos_get_committed_info(&(entry->created_rev),
&datestring,
&(entry->last_author),
root, fullpath, subpool));
if (datestring)
SVN_ERR(svn_time_from_cstring(&(entry->time), datestring,
pool));
if (entry->last_author)
entry->last_author = apr_pstrdup(pool, entry->last_author);
}
/* Store. */
apr_hash_set(*dirents, entryname, APR_HASH_KEY_STRING, entry);
}
svn_pool_destroy(subpool);
}
/* Handle props if requested. */
if (props)
SVN_ERR(get_node_props(props, sess, root, abs_path, pool));
return SVN_NO_ERROR;
}
static svn_error_t *
make_reporter(svn_ra_session_t *session,
const svn_ra_reporter3_t **reporter,
void **report_baton,
svn_revnum_t revision,
const char *target,
const char *other_url,
svn_boolean_t text_deltas,
svn_depth_t depth,
svn_boolean_t send_copyfrom_args,
svn_boolean_t ignore_ancestry,
const svn_delta_editor_t *editor,
void *edit_baton,
apr_pool_t *pool)
{
svn_ra_local__session_baton_t *sess = session->priv;
void *rbaton;
int repos_url_len;
const char *other_fs_path = NULL;
const char *repos_url_decoded;
/* Get the HEAD revision if one is not supplied. */
if (! SVN_IS_VALID_REVNUM(revision))
SVN_ERR(svn_fs_youngest_rev(&revision, sess->fs, pool));
/* If OTHER_URL was provided, validate it and convert it into a
regular filesystem path. */
if (other_url)
{
other_url = svn_path_uri_decode(other_url, pool);
repos_url_decoded = svn_path_uri_decode(sess->repos_url, pool);
repos_url_len = strlen(repos_url_decoded);
/* Sanity check: the other_url better be in the same repository as
the original session url! */
if (strncmp(other_url, repos_url_decoded, repos_url_len) != 0)
return svn_error_createf
(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("'%s'\n"
"is not the same repository as\n"
"'%s'"), other_url, sess->repos_url);
other_fs_path = other_url + repos_url_len;
}
/* Pass back our reporter */
*reporter = &ra_local_reporter;
SVN_ERR(get_username(session, pool));
if (sess->callbacks)
SVN_ERR(svn_delta_get_cancellation_editor(sess->callbacks->cancel_func,
sess->callback_baton,
editor,
edit_baton,
&editor,
&edit_baton,
pool));
/* Build a reporter baton. */
SVN_ERR(svn_repos_begin_report2(&rbaton,
revision,
sess->repos,
sess->fs_path->data,
target,
other_fs_path,
text_deltas,
depth,
ignore_ancestry,
send_copyfrom_args,
editor,
edit_baton,
NULL,
NULL,
pool));
/* Wrap the report baton given us by the repos layer with our own
reporter baton. */
*report_baton = make_reporter_baton(sess, rbaton, pool);
return SVN_NO_ERROR;
}
static dav_prop_insert
insert_prop_internal(const dav_resource *resource,
int propid,
dav_prop_insert what,
apr_text_header *phdr,
apr_pool_t *scratch_pool,
apr_pool_t *result_pool)
{
const char *value = NULL;
const char *s;
const dav_liveprop_spec *info;
int global_ns;
svn_error_t *serr;
/*
** Almost none of the SVN provider properties are defined if the
** resource does not exist. We do need to return the one VCC
** property and baseline-relative-path on lock-null resources,
** however, so that svn clients can run 'svn unlock' and 'svn info'
** on these things.
**
** Even though we state that the SVN properties are not defined, the
** client cannot store dead values -- we deny that thru the is_writable
** hook function.
*/
if ((! resource->exists)
&& (propid != DAV_PROPID_version_controlled_configuration)
&& (propid != SVN_PROPID_baseline_relative_path))
return DAV_PROP_INSERT_NOTSUPP;
/* ### we may want to respond to DAV_PROPID_resourcetype for PRIVATE
### resources. need to think on "proper" interaction with mod_dav */
switch (propid)
{
case DAV_PROPID_getlastmodified:
case DAV_PROPID_creationdate:
{
/* In subversion terms, the date attached to a file's CR is
the true "last modified" time. However, we're defining
creationdate in the same way. IMO, the "creationdate" is
really the date attached to the revision in which the item
*first* came into existence; this would found by tracing
back through the log of the file -- probably via
svn_fs_revisions_changed. gstein, is it a bad thing that
we're currently using 'creationdate' to mean the same thing
as 'last modified date'? */
const char *datestring;
apr_time_t timeval;
enum time_format format;
/* ### for now, our global VCC has no such property. */
if (resource->type == DAV_RESOURCE_TYPE_PRIVATE
&& (resource->info->restype == DAV_SVN_RESTYPE_VCC
|| resource->info->restype == DAV_SVN_RESTYPE_ME))
{
return DAV_PROP_INSERT_NOTSUPP;
}
if (propid == DAV_PROPID_creationdate)
{
/* Return an ISO8601 date; this is what the svn client
expects, and rfc2518 demands it. */
format = time_format_iso8601;
}
else /* propid == DAV_PROPID_getlastmodified */
{
format = time_format_rfc1123;
}
if (0 != get_last_modified_time(&datestring, &timeval,
resource, format, scratch_pool))
{
return DAV_PROP_INSERT_NOTDEF;
}
value = apr_xml_quote_string(scratch_pool, datestring, 1);
break;
}
case DAV_PROPID_creator_displayname:
{
svn_revnum_t committed_rev = SVN_INVALID_REVNUM;
svn_string_t *last_author = NULL;
/* ### for now, our global VCC has no such property. */
if (resource->type == DAV_RESOURCE_TYPE_PRIVATE
&& (resource->info->restype == DAV_SVN_RESTYPE_VCC
|| resource->info->restype == DAV_SVN_RESTYPE_ME))
{
return DAV_PROP_INSERT_NOTSUPP;
}
if (resource->baselined && resource->type == DAV_RESOURCE_TYPE_VERSION)
{
/* A baseline URI. */
committed_rev = resource->info->root.rev;
}
else if (resource->type == DAV_RESOURCE_TYPE_REGULAR
|| resource->type == DAV_RESOURCE_TYPE_WORKING
|| resource->type == DAV_RESOURCE_TYPE_VERSION)
{
/* Get the CR field out of the node's skel. Notice that the
root object might be an ID root -or- a revision root. */
serr = svn_fs_node_created_rev(&committed_rev,
resource->info->root.root,
resource->info->repos_path,
scratch_pool);
if (serr != NULL)
{
/* ### what to do? */
svn_error_clear(serr);
value = "###error###";
break;
}
}
else
{
return DAV_PROP_INSERT_NOTSUPP;
}
serr = get_path_revprop(&last_author,
resource,
committed_rev,
SVN_PROP_REVISION_AUTHOR,
scratch_pool);
if (serr)
{
/* ### what to do? */
svn_error_clear(serr);
value = "###error###";
break;
}
if (last_author == NULL)
return DAV_PROP_INSERT_NOTDEF;
value = apr_xml_quote_string(scratch_pool, last_author->data, 1);
break;
}
case DAV_PROPID_getcontentlanguage:
/* ### need something here */
return DAV_PROP_INSERT_NOTSUPP;
break;
case DAV_PROPID_getcontentlength:
{
svn_filesize_t len = 0;
/* our property, but not defined on collection resources */
if (resource->collection || resource->baselined)
return DAV_PROP_INSERT_NOTSUPP;
serr = svn_fs_file_length(&len, resource->info->root.root,
resource->info->repos_path, scratch_pool);
if (serr != NULL)
{
svn_error_clear(serr);
value = "0"; /* ### what to do? */
break;
}
value = apr_psprintf(scratch_pool, "%" SVN_FILESIZE_T_FMT, len);
break;
}
case DAV_PROPID_getcontenttype:
{
/* The subversion client assumes that any file without an
svn:mime-type property is of type text/plain. So it seems
safe (and consistent) to assume the same on the server. */
svn_string_t *pval;
const char *mime_type = NULL;
if (resource->baselined && resource->type == DAV_RESOURCE_TYPE_VERSION)
return DAV_PROP_INSERT_NOTSUPP;
if (resource->type == DAV_RESOURCE_TYPE_PRIVATE
&& (resource->info->restype == DAV_SVN_RESTYPE_VCC
|| resource->info->restype == DAV_SVN_RESTYPE_ME))
{
return DAV_PROP_INSERT_NOTSUPP;
}
if (resource->collection) /* defaults for directories */
{
if (resource->info->repos->xslt_uri)
mime_type = "text/xml";
else
mime_type = "text/html; charset=UTF-8";
}
else
{
if ((serr = svn_fs_node_prop(&pval, resource->info->root.root,
resource->info->repos_path,
SVN_PROP_MIME_TYPE, scratch_pool)))
{
svn_error_clear(serr);
pval = NULL;
}
if (pval)
mime_type = pval->data;
else if ((! resource->info->repos->is_svn_client)
&& resource->info->r->content_type)
mime_type = resource->info->r->content_type;
else
mime_type = "text/plain";
if ((serr = svn_mime_type_validate(mime_type, scratch_pool)))
{
/* Probably serr->apr == SVN_ERR_BAD_MIME_TYPE, but
there's no point even checking. No matter what the
error is, we can't claim to have a mime type for
this resource. */
ap_log_rerror(APLOG_MARK, APLOG_WARNING, serr->apr_err,
resource->info->r, "%s", serr->message);
svn_error_clear(serr);
return DAV_PROP_INSERT_NOTDEF;
}
}
value = mime_type;
break;
}
case DAV_PROPID_getetag:
if (resource->type == DAV_RESOURCE_TYPE_PRIVATE
&& (resource->info->restype == DAV_SVN_RESTYPE_VCC
|| resource->info->restype == DAV_SVN_RESTYPE_ME))
{
return DAV_PROP_INSERT_NOTSUPP;
}
value = dav_svn__getetag(resource, scratch_pool);
break;
case DAV_PROPID_auto_version:
/* we only support one autoversioning behavior, and thus only
return this one static value; someday when we support
locking, there are other possible values/behaviors for this. */
if (resource->info->repos->autoversioning)
value = "DAV:checkout-checkin";
else
return DAV_PROP_INSERT_NOTDEF;
break;
case DAV_PROPID_baseline_collection:
/* only defined for Baselines */
/* ### whoops. also defined for a VCC. deal with it later. */
if (resource->type != DAV_RESOURCE_TYPE_VERSION || !resource->baselined)
return DAV_PROP_INSERT_NOTSUPP;
value = dav_svn__build_uri(resource->info->repos, DAV_SVN__BUILD_URI_BC,
resource->info->root.rev, NULL,
1 /* add_href */, scratch_pool);
break;
case DAV_PROPID_checked_in:
/* only defined for VCRs (in the public space and in a BC space) */
/* ### note that a VCC (a special VCR) is defined as _PRIVATE for now */
if (resource->type == DAV_RESOURCE_TYPE_PRIVATE
&& (resource->info->restype == DAV_SVN_RESTYPE_VCC
|| resource->info->restype == DAV_SVN_RESTYPE_ME))
{
svn_revnum_t revnum;
serr = svn_fs_youngest_rev(&revnum, resource->info->repos->fs,
scratch_pool);
if (serr != NULL)
{
/* ### what to do? */
svn_error_clear(serr);
value = "###error###";
break;
}
s = dav_svn__build_uri(resource->info->repos,
DAV_SVN__BUILD_URI_BASELINE,
revnum, NULL, 0 /* add_href */, scratch_pool);
value = apr_psprintf(scratch_pool, "<D:href>%s</D:href>",
apr_xml_quote_string(scratch_pool, s, 1));
}
else if (resource->type != DAV_RESOURCE_TYPE_REGULAR)
{
/* not defined for this resource type */
return DAV_PROP_INSERT_NOTSUPP;
}
else
{
svn_revnum_t rev_to_use =
dav_svn__get_safe_cr(resource->info->root.root,
resource->info->repos_path, scratch_pool);
s = dav_svn__build_uri(resource->info->repos,
DAV_SVN__BUILD_URI_VERSION,
rev_to_use, resource->info->repos_path,
0 /* add_href */, scratch_pool);
value = apr_psprintf(scratch_pool, "<D:href>%s</D:href>",
apr_xml_quote_string(scratch_pool, s, 1));
}
break;
case DAV_PROPID_version_controlled_configuration:
/* only defined for VCRs */
/* ### VCRs within the BC should not have this property! */
/* ### note that a VCC (a special VCR) is defined as _PRIVATE for now */
if (resource->type != DAV_RESOURCE_TYPE_REGULAR)
return DAV_PROP_INSERT_NOTSUPP;
value = dav_svn__build_uri(resource->info->repos, DAV_SVN__BUILD_URI_VCC,
SVN_IGNORED_REVNUM, NULL,
1 /* add_href */, scratch_pool);
break;
case DAV_PROPID_version_name:
/* only defined for Version Resources and Baselines */
/* ### whoops. also defined for VCRs. deal with it later. */
if ((resource->type != DAV_RESOURCE_TYPE_VERSION)
&& (! resource->versioned))
return DAV_PROP_INSERT_NOTSUPP;
if (resource->type == DAV_RESOURCE_TYPE_PRIVATE
&& (resource->info->restype == DAV_SVN_RESTYPE_VCC
|| resource->info->restype == DAV_SVN_RESTYPE_ME))
{
return DAV_PROP_INSERT_NOTSUPP;
}
if (resource->baselined)
{
/* just the revision number for baselines */
value = apr_psprintf(scratch_pool, "%ld",
resource->info->root.rev);
}
else
{
svn_revnum_t committed_rev = SVN_INVALID_REVNUM;
/* Get the CR field out of the node's skel. Notice that the
root object might be an ID root -or- a revision root. */
serr = svn_fs_node_created_rev(&committed_rev,
resource->info->root.root,
resource->info->repos_path,
scratch_pool);
if (serr != NULL)
{
/* ### what to do? */
svn_error_clear(serr);
value = "###error###";
break;
}
/* Convert the revision into a quoted string */
s = apr_psprintf(scratch_pool, "%ld", committed_rev);
value = apr_xml_quote_string(scratch_pool, s, 1);
}
break;
case SVN_PROPID_baseline_relative_path:
/* only defined for VCRs */
/* ### VCRs within the BC should not have this property! */
/* ### note that a VCC (a special VCR) is defined as _PRIVATE for now */
if (resource->type != DAV_RESOURCE_TYPE_REGULAR)
return DAV_PROP_INSERT_NOTSUPP;
/* drop the leading slash, so it is relative */
s = resource->info->repos_path + 1;
value = apr_xml_quote_string(scratch_pool, s, 1);
break;
case SVN_PROPID_md5_checksum:
if ((! resource->collection)
&& (! resource->baselined)
&& (resource->type == DAV_RESOURCE_TYPE_REGULAR
|| resource->type == DAV_RESOURCE_TYPE_WORKING
|| resource->type == DAV_RESOURCE_TYPE_VERSION))
{
svn_checksum_t *checksum;
serr = svn_fs_file_checksum(&checksum, svn_checksum_md5,
resource->info->root.root,
resource->info->repos_path, TRUE,
scratch_pool);
if (serr != NULL)
{
/* ### what to do? */
svn_error_clear(serr);
value = "###error###";
break;
}
value = svn_checksum_to_cstring(checksum, scratch_pool);
if (! value)
return DAV_PROP_INSERT_NOTSUPP;
}
else
return DAV_PROP_INSERT_NOTSUPP;
break;
case SVN_PROPID_repository_uuid:
serr = svn_fs_get_uuid(resource->info->repos->fs, &value, scratch_pool);
if (serr != NULL)
{
/* ### what to do? */
svn_error_clear(serr);
value = "###error###";
break;
}
break;
case SVN_PROPID_deadprop_count:
{
unsigned int propcount;
apr_hash_t *proplist;
if (resource->type != DAV_RESOURCE_TYPE_REGULAR)
return DAV_PROP_INSERT_NOTSUPP;
serr = svn_fs_node_proplist(&proplist,
resource->info->root.root,
resource->info->repos_path, scratch_pool);
if (serr != NULL)
{
/* ### what to do? */
svn_error_clear(serr);
value = "###error###";
break;
}
propcount = apr_hash_count(proplist);
value = apr_psprintf(scratch_pool, "%u", propcount);
break;
}
default:
/* ### what the heck was this property? */
return DAV_PROP_INSERT_NOTDEF;
}
/* assert: value != NULL */
/* get the information and global NS index for the property */
global_ns = dav_get_liveprop_info(propid, &dav_svn__liveprop_group, &info);
/* assert: info != NULL && info->name != NULL */
if (what == DAV_PROP_INSERT_NAME
|| (what == DAV_PROP_INSERT_VALUE && *value == '\0')) {
s = apr_psprintf(result_pool, "<lp%d:%s/>" DEBUG_CR, global_ns,
info->name);
}
else if (what == DAV_PROP_INSERT_VALUE) {
s = apr_psprintf(result_pool, "<lp%d:%s>%s</lp%d:%s>" DEBUG_CR,
global_ns, info->name, value, global_ns, info->name);
}
else {
/* assert: what == DAV_PROP_INSERT_SUPPORTED */
s = apr_psprintf(result_pool,
"<D:supported-live-property D:name=\"%s\" "
"D:namespace=\"%s\"/>" DEBUG_CR,
info->name, namespace_uris[info->ns]);
}
apr_text_append(result_pool, phdr, s);
/* we inserted whatever was asked for */
return what;
}
/* Retrieve the file at DIRENT (contained in a repo) then parse it as a config
* file placing the result into CFG_P allocated in POOL.
*
* If DIRENT cannot be parsed as a config file then an error is returned. The
* contents of CFG_P is then undefined. If MUST_EXIST is TRUE, a missing
* authz file is also an error. The CASE_SENSITIVE controls the lookup
* behavior for section and option names alike.
*
* SCRATCH_POOL will be used for temporary allocations. */
static svn_error_t *
authz_retrieve_config_repo(svn_config_t **cfg_p,
const char *dirent,
svn_boolean_t must_exist,
svn_boolean_t case_sensitive,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_error_t *err;
svn_repos_t *repos;
const char *repos_root_dirent;
const char *fs_path;
svn_fs_t *fs;
svn_fs_root_t *root;
svn_revnum_t youngest_rev;
svn_node_kind_t node_kind;
svn_stream_t *contents;
/* Search for a repository in the full path. */
repos_root_dirent = svn_repos_find_root_path(dirent, scratch_pool);
if (!repos_root_dirent)
return svn_error_createf(SVN_ERR_RA_LOCAL_REPOS_NOT_FOUND, NULL,
"Unable to find repository at '%s'", dirent);
/* Attempt to open a repository at repos_root_dirent. */
SVN_ERR(svn_repos_open3(&repos, repos_root_dirent, NULL, scratch_pool,
scratch_pool));
fs_path = &dirent[strlen(repos_root_dirent)];
/* Root path is always a directory so no reason to go any further */
if (*fs_path == '\0')
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
"'/' is not a file in repo '%s'",
repos_root_dirent);
/* We skip some things that are non-important for how we're going to use
* this repo connection. We do not set any capabilities since none of
* the current ones are important for what we're doing. We also do not
* setup the environment that repos hooks would run under since we won't
* be triggering any. */
/* Get the filesystem. */
fs = svn_repos_fs(repos);
/* Find HEAD and the revision root */
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, fs, scratch_pool));
SVN_ERR(svn_fs_revision_root(&root, fs, youngest_rev, scratch_pool));
SVN_ERR(svn_fs_check_path(&node_kind, root, fs_path, scratch_pool));
if (node_kind == svn_node_none)
{
if (!must_exist)
{
SVN_ERR(svn_config_create2(cfg_p, case_sensitive, case_sensitive,
result_pool));
return SVN_NO_ERROR;
}
else
{
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
"'%s' path not found in repo '%s'", fs_path,
repos_root_dirent);
}
}
else if (node_kind != svn_node_file)
{
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
"'%s' is not a file in repo '%s'", fs_path,
repos_root_dirent);
}
SVN_ERR(svn_fs_file_contents(&contents, root, fs_path, scratch_pool));
err = svn_config_parse(cfg_p, contents, case_sensitive, case_sensitive,
result_pool);
/* Add the URL to the error stack since the parser doesn't have it. */
if (err != SVN_NO_ERROR)
return svn_error_createf(err->apr_err, err,
"Error while parsing config file: '%s' in repo '%s':",
fs_path, repos_root_dirent);
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos_verify_fs2(svn_repos_t *repos,
svn_revnum_t start_rev,
svn_revnum_t end_rev,
svn_repos_notify_func_t notify_func,
void *notify_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
svn_fs_t *fs = svn_repos_fs(repos);
svn_revnum_t youngest;
svn_revnum_t rev;
apr_pool_t *iterpool = svn_pool_create(pool);
svn_repos_notify_t *notify;
/* Determine the current youngest revision of the filesystem. */
SVN_ERR(svn_fs_youngest_rev(&youngest, fs, pool));
/* Use default vals if necessary. */
if (! SVN_IS_VALID_REVNUM(start_rev))
start_rev = 0;
if (! SVN_IS_VALID_REVNUM(end_rev))
end_rev = youngest;
/* Validate the revisions. */
if (start_rev > end_rev)
return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
_("Start revision %ld"
" is greater than end revision %ld"),
start_rev, end_rev);
if (end_rev > youngest)
return svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, NULL,
_("End revision %ld is invalid "
"(youngest revision is %ld)"),
end_rev, youngest);
/* Create a notify object that we can reuse within the loop. */
if (notify_func)
notify = svn_repos_notify_create(svn_repos_notify_verify_rev_end,
pool);
for (rev = start_rev; rev <= end_rev; rev++)
{
svn_delta_editor_t *dump_editor;
void *dump_edit_baton;
const svn_delta_editor_t *cancel_editor;
void *cancel_edit_baton;
svn_fs_root_t *to_root;
apr_hash_t *props;
svn_pool_clear(iterpool);
/* Get cancellable dump editor, but with our close_directory handler. */
SVN_ERR(get_dump_editor((const svn_delta_editor_t **)&dump_editor,
&dump_edit_baton, fs, rev, "",
svn_stream_empty(pool),
notify_func, notify_baton,
start_rev,
FALSE, TRUE, /* use_deltas, verify */
iterpool));
dump_editor->close_directory = verify_close_directory;
SVN_ERR(svn_delta_get_cancellation_editor(cancel_func, cancel_baton,
dump_editor, dump_edit_baton,
&cancel_editor,
&cancel_edit_baton,
iterpool));
SVN_ERR(svn_fs_revision_root(&to_root, fs, rev, iterpool));
SVN_ERR(svn_repos_replay2(to_root, "", SVN_INVALID_REVNUM, FALSE,
cancel_editor, cancel_edit_baton,
NULL, NULL, iterpool));
SVN_ERR(svn_fs_revision_proplist(&props, fs, rev, iterpool));
if (notify_func)
{
notify->revision = rev;
notify_func(notify_baton, notify, iterpool);
}
}
/* We're done. */
if (notify_func)
{
notify = svn_repos_notify_create(svn_repos_notify_verify_end, iterpool);
notify_func(notify_baton, notify, iterpool);
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
static svn_error_t *
close_revision(void *baton)
{
struct revision_baton *rb = baton;
struct parse_baton *pb = rb->pb;
const char *conflict_msg = NULL;
svn_revnum_t committed_rev;
svn_error_t *err;
const char *txn_name = NULL;
apr_hash_t *hooks_env;
/* If we're skipping this revision we're done here. */
if (rb->skipped)
return SVN_NO_ERROR;
if (rb->rev == 0)
{
/* Special case: set revision 0 properties when loading into an
'empty' filesystem. */
svn_revnum_t youngest_rev;
SVN_ERR(svn_fs_youngest_rev(&youngest_rev, pb->fs, rb->pool));
if (youngest_rev == 0)
{
apr_hash_t *orig_props;
apr_hash_t *new_props;
apr_array_header_t *diff;
int i;
SVN_ERR(svn_fs_revision_proplist(&orig_props, pb->fs, 0, rb->pool));
new_props = svn_prop_array_to_hash(rb->revprops, rb->pool);
SVN_ERR(svn_prop_diffs(&diff, new_props, orig_props, rb->pool));
for (i = 0; i < diff->nelts; i++)
{
const svn_prop_t *prop = &APR_ARRAY_IDX(diff, i, svn_prop_t);
SVN_ERR(change_rev_prop(pb->repos, 0, prop->name, prop->value,
pb->validate_props, rb->pool));
}
}
return SVN_NO_ERROR;
}
/* If the dumpstream doesn't have an 'svn:date' property and we
aren't ignoring the dates in the dumpstream altogether, remove
any 'svn:date' revision property that was set by FS layer when
the TXN was created. */
if (! (pb->ignore_dates || rb->datestamp))
{
svn_prop_t *prop = &APR_ARRAY_PUSH(rb->revprops, svn_prop_t);
prop->name = SVN_PROP_REVISION_DATE;
prop->value = NULL;
}
/* Apply revision property changes. */
if (rb->pb->validate_props)
SVN_ERR(svn_repos_fs_change_txn_props(rb->txn, rb->revprops, rb->pool));
else
SVN_ERR(svn_fs_change_txn_props(rb->txn, rb->revprops, rb->pool));
/* Get the txn name and hooks environment if they will be needed. */
if (pb->use_pre_commit_hook || pb->use_post_commit_hook)
{
SVN_ERR(svn_repos__parse_hooks_env(&hooks_env, pb->repos->hooks_env_path,
rb->pool, rb->pool));
err = svn_fs_txn_name(&txn_name, rb->txn, rb->pool);
if (err)
{
svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool));
return svn_error_trace(err);
}
}
/* Run the pre-commit hook, if so commanded. */
if (pb->use_pre_commit_hook)
{
err = svn_repos__hooks_pre_commit(pb->repos, hooks_env,
txn_name, rb->pool);
if (err)
{
svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool));
return svn_error_trace(err);
}
}
/* Commit. */
err = svn_fs_commit_txn(&conflict_msg, &committed_rev, rb->txn, rb->pool);
if (SVN_IS_VALID_REVNUM(committed_rev))
{
if (err)
{
/* ### Log any error, but better yet is to rev
### close_revision()'s API to allow both committed_rev and err
### to be returned, see #3768. */
svn_error_clear(err);
}
}
else
{
svn_error_clear(svn_fs_abort_txn(rb->txn, rb->pool));
if (conflict_msg)
return svn_error_quick_wrap(err, conflict_msg);
else
return svn_error_trace(err);
}
/* Run post-commit hook, if so commanded. */
if (pb->use_post_commit_hook)
{
if ((err = svn_repos__hooks_post_commit(pb->repos, hooks_env,
committed_rev, txn_name,
rb->pool)))
return svn_error_create
(SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED, err,
_("Commit succeeded, but post-commit hook failed"));
}
/* After a successful commit, must record the dump-rev -> in-repos-rev
mapping, so that copyfrom instructions in the dump file can look up the
correct repository revision to copy from. */
set_revision_mapping(pb->rev_map, rb->rev, committed_rev);
/* If the incoming dump stream has non-contiguous revisions (e.g. from
using svndumpfilter --drop-empty-revs without --renumber-revs) then
we must account for the missing gaps in PB->REV_MAP. Otherwise we
might not be able to map all mergeinfo source revisions to the correct
revisions in the target repos. */
if ((pb->last_rev_mapped != SVN_INVALID_REVNUM)
&& (rb->rev != pb->last_rev_mapped + 1))
{
svn_revnum_t i;
for (i = pb->last_rev_mapped + 1; i < rb->rev; i++)
{
set_revision_mapping(pb->rev_map, i, pb->last_rev_mapped);
}
}
/* Update our "last revision mapped". */
pb->last_rev_mapped = rb->rev;
/* Deltify the predecessors of paths changed in this revision. */
SVN_ERR(svn_fs_deltify_revision(pb->fs, committed_rev, rb->pool));
if (pb->notify_func)
{
/* ### TODO: Use proper scratch pool instead of pb->notify_pool */
svn_repos_notify_t *notify = svn_repos_notify_create(
svn_repos_notify_load_txn_committed,
pb->notify_pool);
notify->new_revision = committed_rev;
notify->old_revision = ((committed_rev == rb->rev)
? SVN_INVALID_REVNUM
: rb->rev);
pb->notify_func(pb->notify_baton, notify, pb->notify_pool);
svn_pool_clear(pb->notify_pool);
}
return SVN_NO_ERROR;
}
static svn_error_t *
new_revision_record(void **revision_baton,
apr_hash_t *headers,
void *parse_baton,
apr_pool_t *pool)
{
struct parse_baton *pb = parse_baton;
struct revision_baton *rb;
svn_revnum_t head_rev;
rb = make_revision_baton(headers, pb, pool);
/* ### If we're filtering revisions, and this is one we've skipped,
### and we've skipped it because it has a revision number younger
### than the youngest in our acceptable range, then should we
### just bail out here? */
/*
if (rb->skipped && (rb->rev > pb->end_rev))
return svn_error_createf(SVN_ERR_CEASE_INVOCATION, 0,
_("Finished processing acceptable load "
"revision range"));
*/
SVN_ERR(svn_fs_youngest_rev(&head_rev, pb->fs, pool));
/* FIXME: This is a lame fallback loading multiple segments of dump in
several separate operations. It is highly susceptible to race conditions.
Calculate the revision 'offset' for finding copyfrom sources.
It might be positive or negative. */
rb->rev_offset = (apr_int32_t) ((rb->rev) - (head_rev + 1));
if ((rb->rev > 0) && (! rb->skipped))
{
/* Create a new fs txn. */
SVN_ERR(svn_fs_begin_txn2(&(rb->txn), pb->fs, head_rev,
SVN_FS_TXN_CLIENT_DATE, pool));
SVN_ERR(svn_fs_txn_root(&(rb->txn_root), rb->txn, pool));
if (pb->notify_func)
{
/* ### TODO: Use proper scratch pool instead of pb->notify_pool */
svn_repos_notify_t *notify = svn_repos_notify_create(
svn_repos_notify_load_txn_start,
pb->notify_pool);
notify->old_revision = rb->rev;
pb->notify_func(pb->notify_baton, notify, pb->notify_pool);
svn_pool_clear(pb->notify_pool);
}
/* Stash the oldest "old" revision committed from the load stream. */
if (!SVN_IS_VALID_REVNUM(pb->oldest_dumpstream_rev))
pb->oldest_dumpstream_rev = rb->rev;
}
/* If we're skipping this revision, try to notify someone. */
if (rb->skipped && pb->notify_func)
{
/* ### TODO: Use proper scratch pool instead of pb->notify_pool */
svn_repos_notify_t *notify = svn_repos_notify_create(
svn_repos_notify_load_skipped_rev,
pb->notify_pool);
notify->old_revision = rb->rev;
pb->notify_func(pb->notify_baton, notify, pb->notify_pool);
svn_pool_clear(pb->notify_pool);
}
/* If we're parsing revision 0, only the revision props are (possibly)
interesting to us: when loading the stream into an empty
filesystem, then we want new filesystem's revision 0 to have the
same props. Otherwise, we just ignore revision 0 in the stream. */
*revision_baton = rb;
return SVN_NO_ERROR;
}
/*
** Append the specified lock(s) to the set of locks on this resource.
**
** If "make_indirect" is true (non-zero), then the specified lock(s)
** should be converted to an indirect lock (if it is a direct lock)
** before appending. Note that the conversion to an indirect lock does
** not alter the passed-in lock -- the change is internal the
** append_locks function.
**
** Multiple locks are specified using the lock->next links.
*/
static dav_error *
append_locks(dav_lockdb *lockdb,
const dav_resource *resource,
int make_indirect,
const dav_lock *lock)
{
dav_lockdb_private *info = lockdb->info;
svn_lock_t *slock;
svn_error_t *serr;
dav_error *derr;
/* If the resource's fs path is unreadable, we don't allow a lock to
be created on it. */
if (! dav_svn__allow_read_resource(resource, SVN_INVALID_REVNUM,
resource->pool))
return dav_svn__new_error(resource->pool, HTTP_FORBIDDEN,
DAV_ERR_LOCK_SAVE_LOCK,
"Path is not accessible.");
if (lock->next)
return dav_svn__new_error(resource->pool, HTTP_BAD_REQUEST,
DAV_ERR_LOCK_SAVE_LOCK,
"Tried to attach multiple locks to a resource.");
/* RFC2518bis (section 7.4) doesn't require us to support
'lock-null' resources at all. Instead, it asks that we treat
'LOCK nonexistentURL' as a PUT (followed by a LOCK) of a 0-byte file. */
if (! resource->exists)
{
svn_revnum_t rev, new_rev;
svn_fs_txn_t *txn;
svn_fs_root_t *txn_root;
const char *conflict_msg;
dav_svn_repos *repos = resource->info->repos;
apr_hash_t *revprop_table = apr_hash_make(resource->pool);
apr_hash_set(revprop_table, SVN_PROP_REVISION_AUTHOR,
APR_HASH_KEY_STRING, svn_string_create(repos->username,
resource->pool));
if (resource->info->repos->is_svn_client)
return dav_svn__new_error(resource->pool, HTTP_METHOD_NOT_ALLOWED,
DAV_ERR_LOCK_SAVE_LOCK,
"Subversion clients may not lock "
"nonexistent paths.");
else if (! resource->info->repos->autoversioning)
return dav_svn__new_error(resource->pool, HTTP_METHOD_NOT_ALLOWED,
DAV_ERR_LOCK_SAVE_LOCK,
"Attempted to lock non-existent path; "
"turn on autoversioning first.");
/* Commit a 0-byte file: */
if ((serr = svn_fs_youngest_rev(&rev, repos->fs, resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not determine youngest revision",
resource->pool);
if ((serr = svn_repos_fs_begin_txn_for_commit2(&txn, repos->repos, rev,
revprop_table,
resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not begin a transaction",
resource->pool);
if ((serr = svn_fs_txn_root(&txn_root, txn, resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not begin a transaction",
resource->pool);
if ((serr = svn_fs_make_file(txn_root, resource->info->repos_path,
resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not create empty file.",
resource->pool);
if ((serr = dav_svn__attach_auto_revprops(txn,
resource->info->repos_path,
resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not create empty file.",
resource->pool);
serr = svn_repos_fs_commit_txn(&conflict_msg, repos->repos,
&new_rev, txn, resource->pool);
if (SVN_IS_VALID_REVNUM(new_rev))
{
/* ### Log an error in post commit FS processing? */
svn_error_clear(serr);
}
else
{
svn_error_clear(svn_fs_abort_txn(txn, resource->pool));
if (serr)
return dav_svn__convert_err(serr, HTTP_CONFLICT,
apr_psprintf(resource->pool,
"Conflict when "
"committing '%s'.",
conflict_msg),
resource->pool);
else
return dav_svn__new_error(resource->pool,
HTTP_INTERNAL_SERVER_ERROR,
0,
"Commit failed but there was no error "
"provided.");
}
}
/* Convert the dav_lock into an svn_lock_t. */
derr = dav_lock_to_svn_lock(&slock, lock, resource->info->repos_path,
info, resource->info->repos->is_svn_client,
resource->pool);
if (derr)
return derr;
/* Now use the svn_lock_t to actually perform the lock. */
serr = svn_repos_fs_lock(&slock,
resource->info->repos->repos,
slock->path,
slock->token,
slock->comment,
slock->is_dav_comment,
slock->expiration_date,
info->working_revnum,
info->lock_steal,
resource->pool);
if (serr && serr->apr_err == SVN_ERR_FS_NO_USER)
{
svn_error_clear(serr);
return dav_svn__new_error(resource->pool, HTTP_UNAUTHORIZED,
DAV_ERR_LOCK_SAVE_LOCK,
"Anonymous lock creation is not allowed.");
}
else if (serr)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Failed to create new lock.",
resource->pool);
/* A standard webdav LOCK response doesn't include any information
about the creation date. We send it in a custom header, so that
svn clients can fill in svn_lock_t->creation_date. A generic DAV
client should just ignore the header. */
apr_table_setn(info->r->headers_out, SVN_DAV_CREATIONDATE_HEADER,
svn_time_to_cstring(slock->creation_date, resource->pool));
/* A standard webdav LOCK response doesn't include any information
about the owner of the lock. ('DAV:owner' has nothing to do with
authorization, it's just a comment that we map to
svn_lock_t->comment.) We send the owner in a custom header, so
that svn clients can fill in svn_lock_t->owner. A generic DAV
client should just ignore the header. */
apr_table_setn(info->r->headers_out, SVN_DAV_LOCK_OWNER_HEADER,
slock->owner);
/* Log the locking as a 'high-level' action. */
dav_svn__operational_log(resource->info,
svn_log__lock_one_path(slock->path, info->lock_steal,
resource->info->r->pool));
return 0;
}
dav_error *
dav_svn__get_location_segments_report(const dav_resource *resource,
const apr_xml_doc *doc,
ap_filter_t *output)
{
svn_error_t *serr;
dav_error *derr = NULL;
apr_bucket_brigade *bb;
int ns;
apr_xml_elem *child;
const char *abs_path = NULL;
svn_revnum_t peg_revision = SVN_INVALID_REVNUM;
svn_revnum_t start_rev = SVN_INVALID_REVNUM;
svn_revnum_t end_rev = SVN_INVALID_REVNUM;
dav_svn__authz_read_baton arb;
struct location_segment_baton location_segment_baton;
/* Sanity check. */
if (!resource->info->repos_path)
return dav_svn__new_error(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not specify a repository path");
ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE);
if (ns == -1)
{
return dav_svn__new_error_svn(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not contain the 'svn:' "
"namespace, so it is not going to have "
"certain required elements");
}
/* Gather the parameters. */
for (child = doc->root->first_child; child != NULL; child = child->next)
{
/* If this element isn't one of ours, then skip it. */
if (child->ns != ns)
continue;
if (strcmp(child->name, "peg-revision") == 0)
{
peg_revision = SVN_STR_TO_REV(dav_xml_get_cdata(child,
resource->pool, 1));
}
else if (strcmp(child->name, "start-revision") == 0)
{
start_rev = SVN_STR_TO_REV(dav_xml_get_cdata(child,
resource->pool, 1));
}
else if (strcmp(child->name, "end-revision") == 0)
{
end_rev = SVN_STR_TO_REV(dav_xml_get_cdata(child,
resource->pool, 1));
}
else if (strcmp(child->name, "path") == 0)
{
const char *rel_path = dav_xml_get_cdata(child, resource->pool, 0);
if ((derr = dav_svn__test_canonical(rel_path, resource->pool)))
return derr;
/* Force REL_PATH to be a relative path, not an fspath. */
rel_path = svn_relpath_canonicalize(rel_path, resource->pool);
/* Append the REL_PATH to the base FS path to get an
absolute repository path. */
abs_path = svn_fspath__join(resource->info->repos_path, rel_path,
resource->pool);
}
}
/* Check that all parameters are present and valid. */
if (! abs_path)
return dav_svn__new_error_svn(resource->pool, HTTP_BAD_REQUEST, 0,
"Not all parameters passed");
/* No START_REV or PEG_REVISION? We'll use HEAD. */
if (!SVN_IS_VALID_REVNUM(start_rev) || !SVN_IS_VALID_REVNUM(peg_revision))
{
svn_revnum_t youngest;
serr = svn_fs_youngest_rev(&youngest, resource->info->repos->fs,
resource->pool);
if (serr != NULL)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not determine youngest revision",
resource->pool);
if (!SVN_IS_VALID_REVNUM(start_rev))
start_rev = youngest;
if (!SVN_IS_VALID_REVNUM(peg_revision))
peg_revision = youngest;
}
/* No END_REV? We'll use 0. */
if (!SVN_IS_VALID_REVNUM(end_rev))
end_rev = 0;
if (end_rev > start_rev)
return dav_svn__new_error_svn(resource->pool, HTTP_BAD_REQUEST, 0,
"End revision must not be younger than "
"start revision");
if (start_rev > peg_revision)
return dav_svn__new_error_svn(resource->pool, HTTP_BAD_REQUEST, 0,
"Start revision must not be younger than "
"peg revision");
/* Build an authz read baton. */
arb.r = resource->info->r;
arb.repos = resource->info->repos;
/* Build the bucket brigade we'll use for output. */
bb = apr_brigade_create(resource->pool, output->c->bucket_alloc);
/* Do what we came here for. */
location_segment_baton.sent_opener = FALSE;
location_segment_baton.output = output;
location_segment_baton.bb = bb;
if ((serr = svn_repos_node_location_segments(resource->info->repos->repos,
abs_path, peg_revision,
start_rev, end_rev,
location_segment_receiver,
&location_segment_baton,
dav_svn__authz_read_func(&arb),
&arb, resource->pool)))
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, NULL,
resource->pool);
goto cleanup;
}
if ((serr = maybe_send_opener(&location_segment_baton)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error beginning REPORT response.",
resource->pool);
goto cleanup;
}
if ((serr = dav_svn__brigade_puts(bb, output,
"</S:get-location-segments-report>"
DEBUG_CR)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
cleanup:
return dav_svn__final_flush_or_error(resource->info->r, bb, output,
derr, resource->pool);
}
