void
Client_impl::url2Revision(const QString &revstring,
Revision &start, Revision &end)
{
Pool pool;
int n = svn_opt_parse_revision(start, end, revstring.toUtf8(), pool);
if (n < 0) {
start = Revision::UNDEFINED;
end = Revision::UNDEFINED;
}
}
int
svn_opt_parse_revision_to_range(apr_array_header_t *opt_ranges,
const char *arg,
apr_pool_t *pool)
{
svn_opt_revision_range_t *range = apr_palloc(pool, sizeof(*range));
range->start.kind = svn_opt_revision_unspecified;
range->end.kind = svn_opt_revision_unspecified;
if (svn_opt_parse_revision(&(range->start), &(range->end),
arg, pool) == -1)
return -1;
APR_ARRAY_PUSH(opt_ranges, svn_opt_revision_range_t *) = range;
return 0;
}
void
Revision::assign(const QString &revstring)
{
m_revision.kind = svn_opt_revision_unspecified;
if (revstring.isEmpty()) {
return;
}
if (revstring == QLatin1String("WORKING")) {
m_revision.kind = WORKING;
} else if (revstring == QLatin1String("BASE")) {
m_revision.kind = BASE;
} else if (revstring == QLatin1String("START")) {
m_revision.kind = Revision::START;
m_revision.value.number = 0;
} else if (revstring == QLatin1String("PREV")) {
m_revision.kind = Revision::PREV;
} else if (!revstring.isNull()) {
Pool pool;
svn_opt_revision_t endrev;
svn_opt_parse_revision(&m_revision, &endrev, revstring.toUtf8(), 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;
}
svn_error_t *
svn_opt_parse_path(svn_opt_revision_t *rev,
const char **truepath,
const char *path /* UTF-8! */,
apr_pool_t *pool)
{
const char *peg_rev;
SVN_ERR(svn_opt__split_arg_at_peg_revision(truepath, &peg_rev, path, pool));
/* Parse the peg revision, if one was found */
if (strlen(peg_rev))
{
int ret;
svn_opt_revision_t start_revision, end_revision;
end_revision.kind = svn_opt_revision_unspecified;
if (peg_rev[1] == '\0') /* looking at empty peg revision */
{
ret = 0;
start_revision.kind = svn_opt_revision_unspecified;
start_revision.value.number = 0;
}
else /* looking at non-empty peg revision */
{
const char *rev_str = &peg_rev[1];
/* URLs get treated differently from wc paths. */
if (svn_path_is_url(path))
{
/* URLs are URI-encoded, so we look for dates with
URI-encoded delimeters. */
size_t rev_len = strlen(rev_str);
if (rev_len > 6
&& rev_str[0] == '%'
&& rev_str[1] == '7'
&& (rev_str[2] == 'B'
|| rev_str[2] == 'b')
&& rev_str[rev_len-3] == '%'
&& rev_str[rev_len-2] == '7'
&& (rev_str[rev_len-1] == 'D'
|| rev_str[rev_len-1] == 'd'))
{
rev_str = svn_path_uri_decode(rev_str, pool);
}
}
ret = svn_opt_parse_revision(&start_revision,
&end_revision,
rev_str, pool);
}
if (ret || end_revision.kind != svn_opt_revision_unspecified)
{
/* If an svn+ssh URL was used and it contains only one @,
* provide an error message that presents a possible solution
* to the parsing error (issue #2349). */
if (strncmp(path, "svn+ssh://", 10) == 0)
{
const char *at;
at = strchr(path, '@');
if (at && strrchr(path, '@') == at)
return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Syntax error parsing peg revision "
"'%s'; did you mean '%s@'?"),
&peg_rev[1], path);
}
return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Syntax error parsing peg revision '%s'"),
&peg_rev[1]);
}
rev->kind = start_revision.kind;
rev->value = start_revision.value;
}
else
{
/* Didn't find a peg revision. */
rev->kind = svn_opt_revision_unspecified;
}
return SVN_NO_ERROR;
}
int
main (int argc, const char * const *argv)
{
svn_error_t *err;
apr_status_t apr_err;
apr_allocator_t *allocator;
apr_pool_t *pool;
const svn_opt_subcommand_desc_t *subcommand = NULL;
struct svnindex_opt_state opt_state;
apr_getopt_t *os;
int opt_id;
apr_array_header_t *received_opts;
int i;
/* Initialize the app. */
if (svn_cmdline_init ("svnindex", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create our top-level pool. Use a seperate 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);
received_opts = apr_array_make (pool, SVN_OPT_MAX_OPTIONS, sizeof (int));
/* Check library versions */
err = check_lib_versions ();
if (err)
return svn_cmdline_handle_exit_error (err, pool, "svnindex: ");
/* Initialize the FS library. */
err = svn_fs_initialize (pool);
if (err)
return svn_cmdline_handle_exit_error (err, pool, "svnindex: ");
if (argc <= 1)
{
subcommand_help (NULL, NULL, pool);
svn_pool_destroy (pool);
return EXIT_FAILURE;
}
/* Initialize opt_state. */
memset (&opt_state, 0, sizeof (opt_state));
opt_state.start_revision.kind = svn_opt_revision_unspecified;
opt_state.end_revision.kind = svn_opt_revision_unspecified;
/* Parse options. */
apr_getopt_init (&os, pool, argc, argv);
os->interleave = 1;
while (1)
{
const char *opt_arg;
const char *utf8_opt_arg;
/* Parse the next option. */
apr_err = apr_getopt_long (os, options_table, &opt_id, &opt_arg);
if (APR_STATUS_IS_EOF (apr_err))
break;
else if (apr_err)
{
subcommand_help (NULL, NULL, pool);
svn_pool_destroy (pool);
return EXIT_FAILURE;
}
/* Stash the option code in an array before parsing it. */
APR_ARRAY_PUSH (received_opts, int) = opt_id;
switch (opt_id) {
case 'r':
{
if (opt_state.start_revision.kind != svn_opt_revision_unspecified)
{
err = svn_error_create
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Multiple revision arguments encountered; "
"try '-r M:N' instead of '-r M -r N'"));
return svn_cmdline_handle_exit_error (err, pool, "svnindex: ");
}
if (svn_opt_parse_revision (&(opt_state.start_revision),
&(opt_state.end_revision),
opt_arg, pool) != 0)
{
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, "svnindex: ");
}
}
break;
case 'q':
opt_state.quiet = TRUE;
break;
case 'h':
case '?':
opt_state.help = TRUE;
break;
case svnindex__version:
opt_state.version = TRUE;
opt_state.help = TRUE;
break;
case svnindex__db:
err = svn_utf_cstring_to_utf8 (&opt_state.db, opt_arg,
pool);
if (err)
return svn_cmdline_handle_exit_error (err, pool, "svnindex: ");
break;
case 'v':
opt_state.verbose = TRUE;
break;
default:
{
subcommand_help (NULL, NULL, pool);
svn_pool_destroy (pool);
return EXIT_FAILURE;
}
} /* close `switch' */
} /* close `while' */
/* If the user asked for help, then the rest of the arguments are
the names of subcommands to get help on (if any), or else they're
just typos/mistakes. Whatever the case, the subcommand to
actually run is subcommand_help(). */
if (opt_state.help)
subcommand = svn_opt_get_canonical_subcommand (cmd_table, "help");
/* If we're not running the `help' subcommand, then look for a
subcommand in the first argument. */
if (subcommand == NULL)
{
if (os->ind >= os->argc)
{
svn_error_clear
(svn_cmdline_fprintf (stderr, pool,
_("subcommand argument required\n")));
subcommand_help (NULL, NULL, pool);
svn_pool_destroy (pool);
return EXIT_FAILURE;
}
else
{
const char *first_arg = os->argv[os->ind++];
subcommand = svn_opt_get_canonical_subcommand (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, "svnindex: ");
svn_error_clear
(svn_cmdline_fprintf (stderr, pool,
_("Unknown command: '%s'\n"),
first_arg_utf8));
subcommand_help (NULL, NULL, pool);
svn_pool_destroy (pool);
return EXIT_FAILURE;
}
}
}
/* If there's a second argument, it's probably the repository.
Every subcommand except `help' requires one, so we parse it out
here and store it in opt_state. */
if (subcommand->cmd_func != subcommand_help)
{
err = parse_local_repos_path (os,
&(opt_state.repository_path),
pool);
if(err)
{
svn_handle_error2 (err, stderr, FALSE, "svnindex: ");
svn_opt_subcommand_help (subcommand->name, cmd_table,
options_table, pool);
svn_error_clear (err);
svn_pool_destroy (pool);
return EXIT_FAILURE;
}
}
/* Check that the subcommand wasn't passed any inappropriate options. */
for (i = 0; i < received_opts->nelts; i++)
{
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_option (subcommand, opt_id))
{
const char *optstr;
const apr_getopt_option_t *badopt =
svn_opt_get_option_from_code (opt_id, options_table);
svn_opt_format_option (&optstr, badopt, FALSE, pool);
svn_error_clear
(svn_cmdline_fprintf
(stderr, pool, _("subcommand '%s' doesn't accept option '%s'\n"
"Type 'svnindex help %s' for usage.\n"),
subcommand->name, optstr, subcommand->name));
svn_pool_destroy (pool);
return EXIT_FAILURE;
}
}
/* Set up our cancellation support. */
setup_cancellation_signals (signal_handler);
#ifdef SIGPIPE
/* Disable SIGPIPE generation for the platforms that have it. */
apr_signal(SIGPIPE, SIG_IGN);
#endif
/* Run the subcommand. */
err = (*subcommand->cmd_func) (os, &opt_state, pool);
if (err)
{
if (err->apr_err == SVN_ERR_CL_ARG_PARSING_ERROR)
{
svn_handle_error2 (err, stderr, FALSE, "svnindex: ");
svn_opt_subcommand_help (subcommand->name, cmd_table,
options_table, pool);
}
else
svn_handle_error2 (err, stderr, FALSE, "svnindex: ");
svn_error_clear (err);
svn_pool_destroy (pool);
return EXIT_FAILURE;
}
else
{
svn_pool_destroy (pool);
/* Ensure that everything is written to stdout, so the user will
see any print errors. */
err = svn_cmdline_fflush (stdout);
if (err) {
svn_handle_error2 (err, stderr, FALSE, "svnindex: ");
svn_error_clear (err);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
}
svn_error_t *
svn_opt_parse_path(svn_opt_revision_t *rev,
const char **truepath,
const char *path /* UTF-8! */,
apr_pool_t *pool)
{
const char *peg_rev;
SVN_ERR(svn_opt__split_arg_at_peg_revision(truepath, &peg_rev, path, pool));
/* Parse the peg revision, if one was found */
if (strlen(peg_rev))
{
int ret;
svn_opt_revision_t start_revision, end_revision;
end_revision.kind = svn_opt_revision_unspecified;
if (peg_rev[1] == '\0') /* looking at empty peg revision */
{
ret = 0;
start_revision.kind = svn_opt_revision_unspecified;
}
else /* looking at non-empty peg revision */
{
const char *rev_str = &peg_rev[1];
/* URLs get treated differently from wc paths. */
if (svn_path_is_url(path))
{
/* URLs are URI-encoded, so we look for dates with
URI-encoded delimeters. */
int rev_len = strlen(rev_str);
if (rev_len > 6
&& rev_str[0] == '%'
&& rev_str[1] == '7'
&& (rev_str[2] == 'B'
|| rev_str[2] == 'b')
&& rev_str[rev_len-3] == '%'
&& rev_str[rev_len-2] == '7'
&& (rev_str[rev_len-1] == 'D'
|| rev_str[rev_len-1] == 'd'))
{
rev_str = svn_path_uri_decode(rev_str, pool);
}
}
ret = svn_opt_parse_revision(&start_revision,
&end_revision,
rev_str, pool);
}
if (ret || end_revision.kind != svn_opt_revision_unspecified)
return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Syntax error parsing revision '%s'"),
&peg_rev[1]);
rev->kind = start_revision.kind;
rev->value = start_revision.value;
}
else
{
/* Didn't find a peg revision. */
rev->kind = svn_opt_revision_unspecified;
}
return SVN_NO_ERROR;
}
