svn_error_t *
svn_fs_file_checksum(svn_checksum_t **checksum,
svn_checksum_kind_t kind,
svn_fs_root_t *root,
const char *path,
svn_boolean_t force,
apr_pool_t *pool)
{
SVN_ERR(root->vtable->file_checksum(checksum, kind, root, path, pool));
if (force && (*checksum == NULL || (*checksum)->kind != kind))
{
svn_stream_t *contents, *checksum_contents;
SVN_ERR(svn_fs_file_contents(&contents, root, path, pool));
checksum_contents = svn_stream_checksummed2(contents, checksum, NULL,
kind, TRUE, pool);
/* This will force a read of any remaining data (which is all of it in
this case) and dump the checksum into checksum->digest. */
SVN_ERR(svn_stream_close(checksum_contents));
}
return SVN_NO_ERROR;
}
static PyObject *fs_root_file_contents(FileSystemRootObject *self, PyObject *args)
{
svn_stream_t *stream;
apr_pool_t *pool;
StreamObject *ret;
char *path;
if (!PyArg_ParseTuple(args, "s", &path))
return NULL;
pool = Pool(NULL);
if (pool == NULL)
return NULL;
RUN_SVN_WITH_POOL(pool, svn_fs_file_contents(&stream, self->root,
path, pool));
ret = PyObject_New(StreamObject, &Stream_Type);
if (ret == NULL)
return NULL;
ret->pool = pool;
ret->closed = FALSE;
ret->stream = stream;
return (PyObject *)ret;
}
/* 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;
}
/* Loads the fs FILENAME contents into *CONTENTS ensuring that the
corresponding node is a file. Using POOL for allocations. */
static svn_error_t *
read_file_contents(svn_stream_t **contents, const char *filename,
svn_fs_root_t *root, apr_pool_t *pool)
{
svn_node_kind_t node_kind;
/* Make sure the path is a file */
SVN_ERR(svn_fs_check_path(&node_kind, root, filename, pool));
if (node_kind != svn_node_file)
return svn_error_createf(SVN_ERR_FS_NOT_FILE, NULL,
"Path '%s' is not a file", filename);
SVN_ERR(svn_fs_file_contents(contents, root, filename, pool));
return SVN_NO_ERROR;
}
static svn_error_t *
read_packed_fs(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
svn_fs_t *fs;
svn_stream_t *rstream;
svn_stringbuf_t *rstring;
svn_revnum_t i;
*msg = "read from a packed FSFS filesystem";
if (msg_only)
return SVN_NO_ERROR;
/* Bail (with success) on known-untestable scenarios */
if ((strcmp(opts->fs_type, "fsfs") != 0)
|| (opts->server_minor_version && (opts->server_minor_version < 6)))
return SVN_NO_ERROR;
SVN_ERR(create_packed_filesystem(REPO_NAME, opts, 11, 5, pool));
SVN_ERR(svn_fs_open(&fs, REPO_NAME, NULL, pool));
for (i = 1; i < 12; i++)
{
svn_fs_root_t *rev_root;
svn_stringbuf_t *sb;
SVN_ERR(svn_fs_revision_root(&rev_root, fs, i, pool));
SVN_ERR(svn_fs_file_contents(&rstream, rev_root, "iota", pool));
SVN_ERR(svn_test__stream_to_string(&rstring, rstream, pool));
if (i == 1)
sb = svn_stringbuf_create("This is the file 'iota'.\n", pool);
else
sb = svn_stringbuf_create(get_rev_contents(i, pool), pool);
if (! svn_stringbuf_compare(rstring, sb))
return svn_error_createf(SVN_ERR_FS_GENERAL, NULL,
"Bad data in revision %ld.", i);
}
return SVN_NO_ERROR;
}
static svn_error_t *
fetch_base_func(const char **filename,
void *baton,
const char *path,
svn_revnum_t base_revision,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
struct edit_baton *eb = baton;
svn_stream_t *contents;
svn_stream_t *file_stream;
const char *tmp_filename;
svn_fs_root_t *fs_root;
svn_error_t *err;
if (!SVN_IS_VALID_REVNUM(base_revision))
base_revision = svn_fs_txn_base_revision(eb->txn);
SVN_ERR(svn_fs_revision_root(&fs_root, eb->fs, base_revision, scratch_pool));
err = svn_fs_file_contents(&contents, fs_root, path, scratch_pool);
if (err && err->apr_err == SVN_ERR_FS_NOT_FOUND)
{
svn_error_clear(err);
*filename = NULL;
return SVN_NO_ERROR;
}
else if (err)
return svn_error_trace(err);
SVN_ERR(svn_stream_open_unique(&file_stream, &tmp_filename, NULL,
svn_io_file_del_on_pool_cleanup,
scratch_pool, scratch_pool));
SVN_ERR(svn_stream_copy3(contents, file_stream, NULL, NULL, scratch_pool));
*filename = apr_pstrdup(result_pool, tmp_filename);
return SVN_NO_ERROR;
}
/* This helper is the main "meat" of the editor -- it does all the
work of writing a node record.
Write out a node record for PATH of type KIND under EB->FS_ROOT.
ACTION describes what is happening to the node (see enum svn_node_action).
Write record to writable EB->STREAM, using EB->BUFFER to write in chunks.
If the node was itself copied, IS_COPY is TRUE and the
path/revision of the copy source are in CMP_PATH/CMP_REV. If
IS_COPY is FALSE, yet CMP_PATH/CMP_REV are valid, this node is part
of a copied subtree.
*/
static svn_error_t *
dump_node(struct edit_baton *eb,
const char *path,
svn_node_kind_t kind,
enum svn_node_action action,
svn_boolean_t is_copy,
const char *cmp_path,
svn_revnum_t cmp_rev,
apr_pool_t *pool)
{
svn_stringbuf_t *propstring;
svn_filesize_t content_length = 0;
apr_size_t len;
svn_boolean_t must_dump_text = FALSE, must_dump_props = FALSE;
const char *compare_path = path;
svn_revnum_t compare_rev = eb->current_rev - 1;
svn_fs_root_t *compare_root = NULL;
apr_file_t *delta_file = NULL;
/* Maybe validate the path. */
if (eb->verify || eb->notify_func)
{
svn_error_t *err = svn_fs__path_valid(path, pool);
if (err)
{
if (eb->notify_func)
{
char errbuf[512]; /* ### svn_strerror() magic number */
svn_repos_notify_t *notify;
notify = svn_repos_notify_create(svn_repos_notify_warning, pool);
notify->warning = svn_repos_notify_warning_invalid_fspath;
notify->warning_str = apr_psprintf(
pool,
_("E%06d: While validating fspath '%s': %s"),
err->apr_err, path,
svn_err_best_message(err, errbuf, sizeof(errbuf)));
eb->notify_func(eb->notify_baton, notify, pool);
}
/* Return the error in addition to notifying about it. */
if (eb->verify)
return svn_error_trace(err);
else
svn_error_clear(err);
}
}
/* Write out metadata headers for this file node. */
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_PATH ": %s\n",
path));
if (kind == svn_node_file)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_KIND ": file\n"));
else if (kind == svn_node_dir)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_KIND ": dir\n"));
/* Remove leading slashes from copyfrom paths. */
if (cmp_path)
cmp_path = svn_relpath_canonicalize(cmp_path, pool);
/* Validate the comparison path/rev. */
if (ARE_VALID_COPY_ARGS(cmp_path, cmp_rev))
{
compare_path = cmp_path;
compare_rev = cmp_rev;
}
if (action == svn_node_action_change)
{
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION
": change\n"));
/* either the text or props changed, or possibly both. */
SVN_ERR(svn_fs_revision_root(&compare_root,
svn_fs_root_fs(eb->fs_root),
compare_rev, pool));
SVN_ERR(svn_fs_props_changed(&must_dump_props,
compare_root, compare_path,
eb->fs_root, path, pool));
if (kind == svn_node_file)
SVN_ERR(svn_fs_contents_changed(&must_dump_text,
compare_root, compare_path,
eb->fs_root, path, pool));
}
else if (action == svn_node_action_replace)
{
if (! is_copy)
{
/* a simple delete+add, implied by a single 'replace' action. */
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION
": replace\n"));
/* definitely need to dump all content for a replace. */
if (kind == svn_node_file)
must_dump_text = TRUE;
must_dump_props = TRUE;
}
else
{
/* more complex: delete original, then add-with-history. */
/* the path & kind headers have already been printed; just
add a delete action, and end the current record.*/
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION
": delete\n\n"));
/* recurse: print an additional add-with-history record. */
SVN_ERR(dump_node(eb, path, kind, svn_node_action_add,
is_copy, compare_path, compare_rev, pool));
/* we can leave this routine quietly now, don't need to dump
any content; that was already done in the second record. */
must_dump_text = FALSE;
must_dump_props = FALSE;
}
}
else if (action == svn_node_action_delete)
{
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION
": delete\n"));
/* we can leave this routine quietly now, don't need to dump
any content. */
must_dump_text = FALSE;
must_dump_props = FALSE;
}
else if (action == svn_node_action_add)
{
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_ACTION ": add\n"));
if (! is_copy)
{
/* Dump all contents for a simple 'add'. */
if (kind == svn_node_file)
must_dump_text = TRUE;
must_dump_props = TRUE;
}
else
{
if (!eb->verify && cmp_rev < eb->oldest_dumped_rev
&& eb->notify_func)
{
svn_repos_notify_t *notify =
svn_repos_notify_create(svn_repos_notify_warning, pool);
notify->warning = svn_repos_notify_warning_found_old_reference;
notify->warning_str = apr_psprintf(
pool,
_("Referencing data in revision %ld,"
" which is older than the oldest"
" dumped revision (r%ld). Loading this dump"
" into an empty repository"
" will fail."),
cmp_rev, eb->oldest_dumped_rev);
eb->found_old_reference = TRUE;
eb->notify_func(eb->notify_baton, notify, pool);
}
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_NODE_COPYFROM_REV
": %ld\n"
SVN_REPOS_DUMPFILE_NODE_COPYFROM_PATH
": %s\n",
cmp_rev, cmp_path));
SVN_ERR(svn_fs_revision_root(&compare_root,
svn_fs_root_fs(eb->fs_root),
compare_rev, pool));
/* Need to decide if the copied node had any extra textual or
property mods as well. */
SVN_ERR(svn_fs_props_changed(&must_dump_props,
compare_root, compare_path,
eb->fs_root, path, pool));
if (kind == svn_node_file)
{
svn_checksum_t *checksum;
const char *hex_digest;
SVN_ERR(svn_fs_contents_changed(&must_dump_text,
compare_root, compare_path,
eb->fs_root, path, pool));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
compare_root, compare_path,
FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_MD5
": %s\n", hex_digest));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
compare_root, compare_path,
FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_COPY_SOURCE_SHA1
": %s\n", hex_digest));
}
}
}
if ((! must_dump_text) && (! must_dump_props))
{
/* If we're not supposed to dump text or props, so be it, we can
just go home. However, if either one needs to be dumped,
then our dumpstream format demands that at a *minimum*, we
see a lone "PROPS-END" as a divider between text and props
content within the content-block. */
len = 2;
return svn_stream_write(eb->stream, "\n\n", &len); /* ### needed? */
}
/*** Start prepping content to dump... ***/
/* If we are supposed to dump properties, write out a property
length header and generate a stringbuf that contains those
property values here. */
if (must_dump_props)
{
apr_hash_t *prophash, *oldhash = NULL;
apr_size_t proplen;
svn_stream_t *propstream;
SVN_ERR(svn_fs_node_proplist(&prophash, eb->fs_root, path, pool));
/* If this is a partial dump, then issue a warning if we dump mergeinfo
properties that refer to revisions older than the first revision
dumped. */
if (!eb->verify && eb->notify_func && eb->oldest_dumped_rev > 1)
{
svn_string_t *mergeinfo_str = apr_hash_get(prophash,
SVN_PROP_MERGEINFO,
APR_HASH_KEY_STRING);
if (mergeinfo_str)
{
svn_mergeinfo_t mergeinfo, old_mergeinfo;
SVN_ERR(svn_mergeinfo_parse(&mergeinfo, mergeinfo_str->data,
pool));
SVN_ERR(svn_mergeinfo__filter_mergeinfo_by_ranges(
&old_mergeinfo, mergeinfo,
eb->oldest_dumped_rev - 1, 0,
TRUE, pool, pool));
if (apr_hash_count(old_mergeinfo))
{
svn_repos_notify_t *notify =
svn_repos_notify_create(svn_repos_notify_warning, pool);
notify->warning = svn_repos_notify_warning_found_old_mergeinfo;
notify->warning_str = apr_psprintf(
pool,
_("Mergeinfo referencing revision(s) prior "
"to the oldest dumped revision (r%ld). "
"Loading this dump may result in invalid "
"mergeinfo."),
eb->oldest_dumped_rev);
eb->found_old_mergeinfo = TRUE;
eb->notify_func(eb->notify_baton, notify, pool);
}
}
}
if (eb->use_deltas && compare_root)
{
/* Fetch the old property hash to diff against and output a header
saying that our property contents are a delta. */
SVN_ERR(svn_fs_node_proplist(&oldhash, compare_root, compare_path,
pool));
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_PROP_DELTA
": true\n"));
}
else
oldhash = apr_hash_make(pool);
propstring = svn_stringbuf_create_ensure(0, pool);
propstream = svn_stream_from_stringbuf(propstring, pool);
SVN_ERR(svn_hash_write_incremental(prophash, oldhash, propstream,
"PROPS-END", pool));
SVN_ERR(svn_stream_close(propstream));
proplen = propstring->len;
content_length += proplen;
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH
": %" APR_SIZE_T_FMT "\n", proplen));
}
/* If we are supposed to dump text, write out a text length header
here, and an MD5 checksum (if available). */
if (must_dump_text && (kind == svn_node_file))
{
svn_checksum_t *checksum;
const char *hex_digest;
svn_filesize_t textlen;
if (eb->use_deltas)
{
/* Compute the text delta now and write it into a temporary
file, so that we can find its length. Output a header
saying our text contents are a delta. */
SVN_ERR(store_delta(&delta_file, &textlen, compare_root,
compare_path, eb->fs_root, path, pool));
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_DELTA
": true\n"));
if (compare_root)
{
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
compare_root, compare_path,
FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_MD5
": %s\n", hex_digest));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
compare_root, compare_path,
FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_DELTA_BASE_SHA1
": %s\n", hex_digest));
}
}
else
{
/* Just fetch the length of the file. */
SVN_ERR(svn_fs_file_length(&textlen, eb->fs_root, path, pool));
}
content_length += textlen;
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_CONTENT_LENGTH
": %" SVN_FILESIZE_T_FMT "\n", textlen));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_md5,
eb->fs_root, path, FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_CONTENT_MD5
": %s\n", hex_digest));
SVN_ERR(svn_fs_file_checksum(&checksum, svn_checksum_sha1,
eb->fs_root, path, FALSE, pool));
hex_digest = svn_checksum_to_cstring(checksum, pool);
if (hex_digest)
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_TEXT_CONTENT_SHA1
": %s\n", hex_digest));
}
/* 'Content-length:' is the last header before we dump the content,
and is the sum of the text and prop contents lengths. We write
this only for the benefit of non-Subversion RFC-822 parsers. */
SVN_ERR(svn_stream_printf(eb->stream, pool,
SVN_REPOS_DUMPFILE_CONTENT_LENGTH
": %" SVN_FILESIZE_T_FMT "\n\n",
content_length));
/* Dump property content if we're supposed to do so. */
if (must_dump_props)
{
len = propstring->len;
SVN_ERR(svn_stream_write(eb->stream, propstring->data, &len));
}
/* Dump text content */
if (must_dump_text && (kind == svn_node_file))
{
svn_stream_t *contents;
if (delta_file)
{
/* Make sure to close the underlying file when the stream is
closed. */
contents = svn_stream_from_aprfile2(delta_file, FALSE, pool);
}
else
SVN_ERR(svn_fs_file_contents(&contents, eb->fs_root, path, pool));
SVN_ERR(svn_stream_copy3(contents, svn_stream_disown(eb->stream, pool),
NULL, NULL, pool));
}
len = 2;
return svn_stream_write(eb->stream, "\n\n", &len); /* ### needed? */
}
/* 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;
}
