svn_error_t *
svn_repos_open2(svn_repos_t **repos_p,
const char *path,
apr_hash_t *fs_config,
apr_pool_t *pool)
{
return svn_repos_open3(repos_p, path, fs_config, pool, 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;
}
/* Loads the authz config into *AUTHZ from the file at AUTHZ_FILE
in repository at REPOS_PATH from the transaction TXN_NAME. If GROUPS_FILE
is set, the resulting *AUTHZ will be constructed from AUTHZ_FILE with
global groups taken from GROUPS_FILE. Using POOL for allocations. */
static svn_error_t *
get_authz_from_txn(svn_authz_t **authz, const char *repos_path,
const char *authz_file, const char *groups_file,
const char *txn_name, apr_pool_t *pool)
{
svn_repos_t *repos;
svn_fs_t *fs;
svn_fs_txn_t *txn;
svn_fs_root_t *root;
svn_stream_t *authz_contents;
svn_stream_t *groups_contents;
svn_error_t *err;
/* Open up the repository and find the transaction root */
SVN_ERR(svn_repos_open3(&repos, repos_path, NULL, pool, pool));
fs = svn_repos_fs(repos);
SVN_ERR(svn_fs_open_txn(&txn, fs, txn_name, pool));
SVN_ERR(svn_fs_txn_root(&root, txn, pool));
/* Get the authz file contents. */
SVN_ERR(read_file_contents(&authz_contents, authz_file, root, pool));
/* Get the groups file contents if needed. */
if (groups_file)
SVN_ERR(read_file_contents(&groups_contents, groups_file, root, pool));
else
groups_contents = NULL;
err = svn_repos_authz_parse(authz, authz_contents, groups_contents, pool);
/* Add the filename 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 parsing authz file: '%s':", authz_file);
return SVN_NO_ERROR;
}
/* 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;
}