/* svn_wc_upgrade_get_repos_info_t implementation for calling
svn_wc_upgrade() from svn_client_upgrade() */
static svn_error_t *
fetch_repos_info(const char **repos_root,
const char **repos_uuid,
void *baton,
const char *url,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
struct repos_info_baton *ri = baton;
apr_pool_t *subpool;
svn_ra_session_t *ra_session;
/* The same info is likely to retrieved multiple times (e.g. externals) */
if (ri->last_repos && svn_uri__is_child(ri->last_repos, url, scratch_pool))
{
*repos_root = apr_pstrdup(result_pool, ri->last_repos);
*repos_uuid = apr_pstrdup(result_pool, ri->last_uuid);
return SVN_NO_ERROR;
}
subpool = svn_pool_create(scratch_pool);
SVN_ERR(svn_client_open_ra_session(&ra_session, url, ri->ctx, subpool));
SVN_ERR(svn_ra_get_repos_root2(ra_session, repos_root, result_pool));
SVN_ERR(svn_ra_get_uuid2(ra_session, repos_uuid, result_pool));
/* Store data for further calls */
ri->last_repos = apr_pstrdup(ri->state_pool, *repos_root);
ri->last_uuid = apr_pstrdup(ri->state_pool, *repos_uuid);
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* Handle the "load" subcommand. Implements `svn_opt_subcommand_t'. */
static svn_error_t *
load_cmd(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
opt_baton_t *opt_baton = baton;
svn_ra_session_t *aux_session;
SVN_ERR(svn_client_open_ra_session(&aux_session, opt_baton->url,
opt_baton->ctx, pool));
return load_revisions(opt_baton->session, aux_session, opt_baton->url,
opt_baton->quiet, pool);
}
bool Client_impl::RepoHasCapability(const Path &repository, Capability capability)
{
svn_error_t *error = 0;
Pool pool;
svn_ra_session_t *session = 0;
// todo svn 1.8: svn_client_open_ra_session2
error = svn_client_open_ra_session(&session,
repository.cstr(),
*m_context,
pool);
if (error != 0) {
throw ClientException(error);
}
if (!session) {
return false;
}
const char *capa = 0;
switch (capability) {
case CapabilityMergeinfo:
capa = SVN_RA_CAPABILITY_MERGEINFO;
break;
case CapabilityDepth:
capa = SVN_RA_CAPABILITY_DEPTH;
break;
case CapabilityCommitRevProps:
capa = SVN_RA_CAPABILITY_COMMIT_REVPROPS;
break;
case CapabilityLogRevProps:
capa = SVN_RA_CAPABILITY_LOG_REVPROPS;
break;
default:
return false;
}
svn_boolean_t has = 0;
error = svn_ra_has_capability(session, &has, capa, pool);
if (error != 0) {
throw ClientException(error);
}
return has;
}
/* Handle the "dump" subcommand. Implements `svn_opt_subcommand_t'. */
static svn_error_t *
dump_cmd(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
opt_baton_t *opt_baton = baton;
svn_ra_session_t *extra_ra_session;
const char *repos_root;
SVN_ERR(svn_client_open_ra_session(&extra_ra_session,
opt_baton->url,
opt_baton->ctx, pool));
SVN_ERR(svn_ra_get_repos_root2(extra_ra_session, &repos_root, pool));
SVN_ERR(svn_ra_reparent(extra_ra_session, repos_root, pool));
return replay_revisions(opt_baton->session, extra_ra_session,
opt_baton->url,
opt_baton->start_revision.value.number,
opt_baton->end_revision.value.number,
opt_baton->quiet, opt_baton->incremental, pool);
}
int
main(int argc, const char **argv)
{
svn_error_t *err = SVN_NO_ERROR;
const svn_opt_subcommand_desc2_t *subcommand = NULL;
opt_baton_t *opt_baton;
svn_revnum_t latest_revision = SVN_INVALID_REVNUM;
apr_pool_t *pool = NULL;
const char *config_dir = NULL;
const char *username = NULL;
const char *password = NULL;
svn_boolean_t no_auth_cache = FALSE;
svn_boolean_t trust_server_cert = FALSE;
svn_boolean_t non_interactive = FALSE;
apr_array_header_t *config_options = NULL;
apr_getopt_t *os;
const char *first_arg;
apr_array_header_t *received_opts;
apr_allocator_t *allocator;
int i;
if (svn_cmdline_init ("svnrdump", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create our top-level pool. Use a separate mutexless allocator,
* given this application is single threaded.
*/
if (apr_allocator_create(&allocator))
return EXIT_FAILURE;
apr_allocator_max_free_set(allocator, SVN_ALLOCATOR_RECOMMENDED_MAX_FREE);
pool = svn_pool_create_ex(NULL, allocator);
apr_allocator_owner_set(allocator, pool);
opt_baton = apr_pcalloc(pool, sizeof(*opt_baton));
opt_baton->start_revision.kind = svn_opt_revision_unspecified;
opt_baton->end_revision.kind = svn_opt_revision_unspecified;
opt_baton->url = NULL;
SVNRDUMP_ERR(svn_cmdline__getopt_init(&os, argc, argv, pool));
os->interleave = TRUE; /* Options and arguments can be interleaved */
/* Set up our cancellation support. */
apr_signal(SIGINT, signal_handler);
#ifdef SIGBREAK
/* SIGBREAK is a Win32 specific signal generated by ctrl-break. */
apr_signal(SIGBREAK, signal_handler);
#endif
#ifdef SIGHUP
apr_signal(SIGHUP, signal_handler);
#endif
#ifdef SIGTERM
apr_signal(SIGTERM, signal_handler);
#endif
#ifdef SIGPIPE
/* Disable SIGPIPE generation for the platforms that have it. */
apr_signal(SIGPIPE, SIG_IGN);
#endif
#ifdef SIGXFSZ
/* Disable SIGXFSZ generation for the platforms that have it, otherwise
* working with large files when compiled against an APR that doesn't have
* large file support will crash the program, which is uncool. */
apr_signal(SIGXFSZ, SIG_IGN);
#endif
received_opts = apr_array_make(pool, SVN_OPT_MAX_OPTIONS, sizeof(int));
while (1)
{
int opt;
const char *opt_arg;
apr_status_t status = apr_getopt_long(os, svnrdump__options, &opt,
&opt_arg);
if (APR_STATUS_IS_EOF(status))
break;
if (status != APR_SUCCESS)
{
SVNRDUMP_ERR(usage(argv[0], pool));
exit(EXIT_FAILURE);
}
/* Stash the option code in an array before parsing it. */
APR_ARRAY_PUSH(received_opts, int) = opt;
switch(opt)
{
case 'r':
{
/* Make sure we've not seen -r already. */
if (opt_baton->start_revision.kind != svn_opt_revision_unspecified)
{
err = svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Multiple revision arguments "
"encountered; try '-r N:M' instead "
"of '-r N -r M'"));
return svn_cmdline_handle_exit_error(err, pool, "svnrdump: ");
}
/* Parse the -r argument. */
if (svn_opt_parse_revision(&(opt_baton->start_revision),
&(opt_baton->end_revision),
opt_arg, pool) != 0)
{
const char *utf8_opt_arg;
err = svn_utf_cstring_to_utf8(&utf8_opt_arg, opt_arg, pool);
if (! err)
err = svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Syntax error in revision "
"argument '%s'"), utf8_opt_arg);
return svn_cmdline_handle_exit_error(err, pool, "svnrdump: ");
}
}
break;
case 'q':
opt_baton->quiet = TRUE;
break;
case opt_config_dir:
config_dir = opt_arg;
break;
case opt_version:
opt_baton->version = TRUE;
break;
case 'h':
opt_baton->help = TRUE;
break;
case opt_auth_username:
SVNRDUMP_ERR(svn_utf_cstring_to_utf8(&username, opt_arg, pool));
break;
case opt_auth_password:
SVNRDUMP_ERR(svn_utf_cstring_to_utf8(&password, opt_arg, pool));
break;
case opt_auth_nocache:
no_auth_cache = TRUE;
break;
case opt_non_interactive:
non_interactive = TRUE;
break;
case opt_incremental:
opt_baton->incremental = TRUE;
break;
case opt_trust_server_cert:
trust_server_cert = TRUE;
break;
case opt_config_option:
if (!config_options)
config_options =
apr_array_make(pool, 1,
sizeof(svn_cmdline__config_argument_t*));
SVNRDUMP_ERR(svn_utf_cstring_to_utf8(&opt_arg, opt_arg, pool));
SVNRDUMP_ERR(svn_cmdline__parse_config_option(config_options,
opt_arg, pool));
}
}
if (opt_baton->help)
{
subcommand = svn_opt_get_canonical_subcommand2(svnrdump__cmd_table,
"help");
}
if (subcommand == NULL)
{
if (os->ind >= os->argc)
{
if (opt_baton->version)
{
/* Use the "help" subcommand to handle the "--version" option. */
static const svn_opt_subcommand_desc2_t pseudo_cmd =
{ "--version", help_cmd, {0}, "",
{ opt_version, /* must accept its own option */
'q', /* --quiet */
}
};
subcommand = &pseudo_cmd;
}
else
{
SVNRDUMP_ERR(help_cmd(NULL, NULL, pool));
svn_pool_destroy(pool);
exit(EXIT_FAILURE);
}
}
else
{
first_arg = os->argv[os->ind++];
subcommand = svn_opt_get_canonical_subcommand2(svnrdump__cmd_table,
first_arg);
if (subcommand == NULL)
{
const char *first_arg_utf8;
err = svn_utf_cstring_to_utf8(&first_arg_utf8, first_arg, pool);
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnrdump: ");
svn_error_clear(svn_cmdline_fprintf(stderr, pool,
_("Unknown command: '%s'\n"),
first_arg_utf8));
SVNRDUMP_ERR(help_cmd(NULL, NULL, pool));
svn_pool_destroy(pool);
exit(EXIT_FAILURE);
}
}
}
/* Check that the subcommand wasn't passed any inappropriate options. */
for (i = 0; i < received_opts->nelts; i++)
{
int opt_id = APR_ARRAY_IDX(received_opts, i, int);
/* All commands implicitly accept --help, so just skip over this
when we see it. Note that we don't want to include this option
in their "accepted options" list because it would be awfully
redundant to display it in every commands' help text. */
if (opt_id == 'h' || opt_id == '?')
continue;
if (! svn_opt_subcommand_takes_option3(subcommand, opt_id, NULL))
{
const char *optstr;
const apr_getopt_option_t *badopt =
svn_opt_get_option_from_code2(opt_id, svnrdump__options,
subcommand, pool);
svn_opt_format_option(&optstr, badopt, FALSE, pool);
if (subcommand->name[0] == '-')
SVN_INT_ERR(help_cmd(NULL, NULL, pool));
else
svn_error_clear(svn_cmdline_fprintf(
stderr, pool,
_("Subcommand '%s' doesn't accept option '%s'\n"
"Type 'svnrdump help %s' for usage.\n"),
subcommand->name, optstr, subcommand->name));
svn_pool_destroy(pool);
return EXIT_FAILURE;
}
}
if (subcommand && strcmp(subcommand->name, "--version") == 0)
{
SVNRDUMP_ERR(version(argv[0], opt_baton->quiet, pool));
svn_pool_destroy(pool);
exit(EXIT_SUCCESS);
}
if (subcommand && strcmp(subcommand->name, "help") == 0)
{
SVNRDUMP_ERR(help_cmd(os, opt_baton, pool));
svn_pool_destroy(pool);
exit(EXIT_SUCCESS);
}
/* --trust-server-cert can only be used with --non-interactive */
if (trust_server_cert && !non_interactive)
{
err = svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--trust-server-cert requires "
"--non-interactive"));
return svn_cmdline_handle_exit_error(err, pool, "svnrdump: ");
}
/* Expect one more non-option argument: the repository URL. */
if (os->ind != os->argc - 1)
{
SVNRDUMP_ERR(usage(argv[0], pool));
svn_pool_destroy(pool);
exit(EXIT_FAILURE);
}
else
{
const char *repos_url;
SVNRDUMP_ERR(svn_utf_cstring_to_utf8(&repos_url,
os->argv[os->ind], pool));
if (! svn_path_is_url(repos_url))
{
err = svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, 0,
"Target '%s' is not a URL",
repos_url);
SVNRDUMP_ERR(err);
svn_pool_destroy(pool);
exit(EXIT_FAILURE);
}
opt_baton->url = svn_uri_canonicalize(repos_url, pool);
}
SVNRDUMP_ERR(init_client_context(&(opt_baton->ctx),
non_interactive,
username,
password,
config_dir,
no_auth_cache,
trust_server_cert,
config_options,
pool));
SVNRDUMP_ERR(svn_client_open_ra_session(&(opt_baton->session),
opt_baton->url,
opt_baton->ctx, pool));
/* Have sane opt_baton->start_revision and end_revision defaults if
unspecified. */
SVNRDUMP_ERR(svn_ra_get_latest_revnum(opt_baton->session,
&latest_revision, pool));
/* Make sure any provided revisions make sense. */
SVNRDUMP_ERR(validate_and_resolve_revisions(opt_baton,
latest_revision, pool));
/* Dispatch the subcommand */
SVNRDUMP_ERR((*subcommand->cmd_func)(os, opt_baton, pool));
svn_pool_destroy(pool);
return EXIT_SUCCESS;
}
/* Opens a session */
char session_open(session_t *session)
{
svn_error_t *err;
svn_client_ctx_t *ctx;
svn_config_t *config;
svn_auth_baton_t *auth_baton;
const char *root;
const char *config_dir = NULL;
/* Make sure the URL is properly encoded */
session->encoded_url = svn_path_uri_encode(svn_path_canonicalize(session->url, session->pool), session->pool);
/* Do neccessary SVN library initialization */
if ((err = svn_fs_initialize(session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
if ((err = svn_ra_initialize(session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
if ((err = svn_config_ensure(NULL, session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
/* Setup the client context */
if ((err = svn_client_create_context(&ctx, session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
if ((err = svn_config_get_config(&(ctx->config), NULL, session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
if (session->config_dir != NULL) {
const char *path;
if ((err = svn_utf_cstring_to_utf8(&path, session->config_dir, session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
config_dir = svn_path_canonicalize(path, session->pool);
}
/* Setup auth baton */
config = apr_hash_get(ctx->config, SVN_CONFIG_CATEGORY_CONFIG, APR_HASH_KEY_STRING);
if ((err = svn_cmdline_setup_auth_baton(&auth_baton, (session->flags & SF_NON_INTERACTIVE), session->username, session->password, config_dir, (session->flags & SF_NO_AUTH_CACHE), config, NULL, NULL, session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
ctx->auth_baton = auth_baton;
/* Setup the RA session */
if ((err = svn_client_open_ra_session(&(session->ra), session->encoded_url, ctx, session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
/* Determine the root (and the prefix) of the URL */
if ((err = svn_ra_get_repos_root(session->ra, &root, session->pool))) {
utils_handle_error(err, stderr, FALSE, "ERROR: ");
svn_error_clear(err);
return 1;
}
session->root = root;
if (!strcmp(session->encoded_url, root)) {
session->prefix = apr_pstrdup(session->pool, "");
} else {
session->prefix = apr_pstrdup(session->pool, session->encoded_url + strlen(root) + 1);
}
session->prefix = session_obfuscate(session, session->pool, session->prefix);
return 0;
}
static svn_error_t *
pre_15_receiver(void *baton, svn_log_entry_t *log_entry, apr_pool_t *pool)
{
pre_15_receiver_baton_t *rb = baton;
if (log_entry->revision == SVN_INVALID_REVNUM)
return rb->receiver(rb->baton, log_entry, pool);
/* If only some revprops are requested, get them one at a time on the
second ra connection. If all are requested, get them all with
svn_ra_rev_proplist. This avoids getting unrequested revprops (which
may be arbitrarily large), but means one round-trip per requested
revprop. epg isn't entirely sure which should be optimized for. */
if (rb->revprops)
{
int i;
svn_boolean_t want_author, want_date, want_log;
want_author = want_date = want_log = FALSE;
for (i = 0; i < rb->revprops->nelts; i++)
{
const char *name = APR_ARRAY_IDX(rb->revprops, i, const char *);
svn_string_t *value;
/* If a standard revprop is requested, we know it is already in
log_entry->revprops if available. */
if (strcmp(name, SVN_PROP_REVISION_AUTHOR) == 0)
{
want_author = TRUE;
continue;
}
if (strcmp(name, SVN_PROP_REVISION_DATE) == 0)
{
want_date = TRUE;
continue;
}
if (strcmp(name, SVN_PROP_REVISION_LOG) == 0)
{
want_log = TRUE;
continue;
}
if (rb->ra_session == NULL)
SVN_ERR(svn_client_open_ra_session(&rb->ra_session,
rb->ra_session_url,
rb->ctx, rb->ra_session_pool));
SVN_ERR(svn_ra_rev_prop(rb->ra_session, log_entry->revision,
name, &value, pool));
if (log_entry->revprops == NULL)
log_entry->revprops = apr_hash_make(pool);
apr_hash_set(log_entry->revprops, (const void *)name,
APR_HASH_KEY_STRING, (const void *)value);
}
if (log_entry->revprops)
{
/* Pre-1.5 servers send the standard revprops unconditionally;
clear those the caller doesn't want. */
if (!want_author)
apr_hash_set(log_entry->revprops, SVN_PROP_REVISION_AUTHOR,
APR_HASH_KEY_STRING, NULL);
if (!want_date)
apr_hash_set(log_entry->revprops, SVN_PROP_REVISION_DATE,
APR_HASH_KEY_STRING, NULL);
if (!want_log)
apr_hash_set(log_entry->revprops, SVN_PROP_REVISION_LOG,
APR_HASH_KEY_STRING, NULL);
}
}