int
main(int argc, const char *argv[])
{
apr_pool_t *pool;
int exit_code = EXIT_SUCCESS;
svn_error_t *err;
/* Initialize the app. */
if (svn_cmdline_init("svnraisetreeconflict", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create our top-level pool. Use a separate mutexless allocator,
* given this application is single threaded.
*/
pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE));
err = sub_main(&exit_code, argc, argv, pool);
/* Flush stdout and report if it fails. It would be flushed on exit anyway
but this makes sure that output is not silently lost if it fails. */
err = svn_error_compose_create(err, svn_cmdline_fflush(stdout));
if (err)
{
exit_code = EXIT_FAILURE;
svn_cmdline_handle_exit_error(err, NULL, "svnraisetreeconflict: ");
}
svn_pool_destroy(pool);
return exit_code;
}
static apr_pool_t *
init(const char *application)
{
apr_allocator_t *allocator;
apr_pool_t *pool;
svn_error_t *err;
const svn_version_checklist_t checklist[] = {
{"svn_client", svn_client_version},
{"svn_subr", svn_subr_version},
{"svn_ra", svn_ra_version},
{NULL, NULL}
};
SVN_VERSION_DEFINE(my_version);
if (svn_cmdline_init(application, stderr)
|| apr_allocator_create(&allocator))
exit(EXIT_FAILURE);
err = svn_ver_check_list(&my_version, checklist);
if (err)
handle_error(err, NULL);
apr_allocator_max_free_set(allocator, SVN_ALLOCATOR_RECOMMENDED_MAX_FREE);
pool = svn_pool_create_ex(NULL, allocator);
apr_allocator_owner_set(allocator, pool);
return pool;
}
int
main(int argc, const char *argv[])
{
apr_pool_t *pool;
int exit_code = EXIT_SUCCESS;
svn_error_t *err;
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init(argv[0], stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
pool = svn_pool_create(NULL);
err = sub_main(&exit_code, argc, argv, pool);
/* Flush stdout and report if it fails. It would be flushed on exit anyway
but this makes sure that output is not silently lost if it fails. */
err = svn_error_compose_create(err, svn_cmdline_fflush(stdout));
if (err)
{
if (exit_code == 0)
exit_code = EXIT_FAILURE;
svn_cmdline_handle_exit_error(err, NULL, "svnauthz: ");
}
svn_pool_destroy(pool);
return exit_code;
}
int
main(int argc, const char *argv[])
{
apr_pool_t *pool;
int exit_code = EXIT_SUCCESS;
svn_error_t *err;
const char *path;
const char *cmd;
if (argc < 2 || argc > 4)
{
fprintf(stderr, "USAGE: entries-dump [--entries|--subdirs|--tree-dump] DIR_PATH\n");
exit(1);
}
if (svn_cmdline_init("entries-dump", stderr) != EXIT_SUCCESS)
{
return EXIT_FAILURE;
}
/* Create our top-level pool. Use a separate mutexless allocator,
* given this application is single threaded.
*/
pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE));
path = svn_dirent_internal_style(argv[argc-1], pool);
if (argc > 2)
cmd = argv[1];
else
cmd = NULL;
if (!cmd || !strcmp(cmd, "--entries"))
err = entries_dump(path, NULL, pool);
else if (!strcmp(cmd, "--subdirs"))
err = directory_dump(path, pool);
else if (!strcmp(cmd, "--tree-dump"))
err = tree_dump(path, pool);
else
err = svn_error_createf(SVN_ERR_INCORRECT_PARAMS, NULL,
"Invalid command '%s'",
cmd);
if (err)
{
svn_handle_error2(err, stderr, FALSE, "entries-dump: ");
svn_error_clear(err);
exit_code = EXIT_FAILURE;
}
/* Clean up, and get outta here */
svn_pool_destroy(pool);
apr_terminate();
return exit_code;
}
SvnClientImpl::SvnClientImpl() :
_isActive(true)
{
// Initialize the app. Send all error messages to nothing
if (svn_cmdline_init("minimal_client", NULL) != EXIT_SUCCESS)
{
throw std::runtime_error("Could not initialise SVN commandline.");
}
// Create our main pool
_pool = svn_pool_create(NULL);
/* Initialize the FS library. */
svn_error_t* err = svn_fs_initialize(_pool);
if (err)
{
throw std::runtime_error("Could not initialise SVN filesystem library.");
}
/* Make sure the ~/.subversion run-time config files exist */
err = svn_config_ensure(NULL, _pool);
if (err)
{
throw std::runtime_error("Could not initialise SVN configuration.");
}
// Initialize and allocate the client_ctx object.
if ((err = svn_client_create_context(&_context, _pool)))
{
throw std::runtime_error("Could not create SVN context.");
}
// Load the run-time config file into a hash
if ((err = svn_config_get_config (&(_context->config), NULL, _pool)))
{
throw std::runtime_error("Could not load SVN config.");
}
#ifdef WIN32
// Set the working copy administrative directory name.
if (getenv("SVN_ASP_DOT_NET_HACK"))
{
err = svn_wc_set_adm_dir("_svn", _pool);
if (err)
{
throw std::runtime_error("Could not set SVN admin directory.");
}
}
#endif
}
/* Fonction d'initialisation SVN / APR */
void svn_init(){
if (svn_cmdline_init ("svn_support", stderr) != EXIT_SUCCESS)
return;
pool = svn_pool_create(NULL);
ctx = initialize_context();
/*err = svn_fs_initialize(pool);
if (err) {
svn_handle_error2 (err, stderr, FALSE, "svn_init: ");
return;
}*/
}
bool setAppSettings()
{
QCoreApplication::setOrganizationName("qsvn");
QCoreApplication::setOrganizationDomain("bokicsoft.com");
QCoreApplication::setApplicationName("qsvn");
if (svn_cmdline_init("qsvn", stderr) != EXIT_SUCCESS)
{
return false;
}
return true;
}
SvnInit::SvnInit() {
svn_cmdline_init("svnqt",0);
//qDebug("svn_cmdline_init done");
QString BasePath=QDir::homePath();
QDir d;
if (!d.exists(BasePath)) {
d.mkdir(BasePath);
}
BasePath=BasePath+'/'+".svnqt";
if (!d.exists(BasePath)) {
d.mkdir(BasePath);
}
}
static int
init_function (svn_client_ctx_t **ctx, apr_pool_t **pool, lua_State *L) {
apr_allocator_t *allocator;
svn_auth_baton_t *ab;
svn_config_t *cfg;
svn_error_t *err;
if (svn_cmdline_init("svn", stderr) != EXIT_SUCCESS) {
return send_error (L, "Error initializing svn\n");
}
if (apr_allocator_create(&allocator)) {
return send_error (L, "Error creating allocator\n");
}
apr_allocator_max_free_set(allocator, SVN_ALLOCATOR_RECOMMENDED_MAX_FREE);
*pool = svn_pool_create_ex(NULL, allocator);
apr_allocator_owner_set(allocator, *pool);
err = svn_ra_initialize(*pool);
IF_ERROR_RETURN (err, *pool, L);
err = svn_client_create_context (ctx, *pool);
IF_ERROR_RETURN (err, *pool, L);
err = svn_config_get_config(&((*ctx)->config), NULL, *pool);
IF_ERROR_RETURN (err, *pool, L);
cfg = apr_hash_get((*ctx)->config, SVN_CONFIG_CATEGORY_CONFIG,
APR_HASH_KEY_STRING);
err = svn_cmdline_setup_auth_baton(&ab,
FALSE,
NULL,
NULL,
NULL,
FALSE,
cfg,
(*ctx)->cancel_func,
(*ctx)->cancel_baton,
*pool);
IF_ERROR_RETURN (err, *pool, L);
(*ctx)->auth_baton = ab;
return 0;
}
ClientP Client::getobject(const ContextP &context)
{
static bool s_initialized = false;
if (!s_initialized) {
svn_cmdline_init("svnqt", 0);
QString basePath = QDir::homePath();
QDir d;
if (!d.exists(basePath)) {
d.mkpath(basePath);
}
basePath = basePath + QLatin1String("/.svnqt");
if (!d.exists(basePath)) {
d.mkdir(basePath);
}
}
return ClientP(new Client_impl(context));
}
int
main(int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err = SVN_NO_ERROR;
const char *repos_path;
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init(argv[0], stderr) == EXIT_FAILURE)
return EXIT_FAILURE;
pool = svn_pool_create(NULL);
if (argc <= 1)
{
usage_maybe_with_err(argv[0], "Not enough arguments.");
goto cleanup;
}
/* Convert argv[1] into a UTF8, internal-format, canonicalized path. */
if ((err = svn_utf_cstring_to_utf8(&repos_path, argv[1], pool)))
goto cleanup;
repos_path = svn_dirent_internal_style(repos_path, pool);
repos_path = svn_dirent_canonicalize(repos_path, pool);
if ((err = build_index(repos_path, pool)))
goto cleanup;
cleanup:
svn_pool_destroy(pool);
if (err)
{
svn_handle_error2(err, stderr, FALSE,
"svn-populate-node-origins-index: ");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int
main(int argc, const char *argv[])
{
apr_pool_t *pool;
int exit_code = EXIT_SUCCESS;
svn_error_t *err;
/* Initialize the app. */
if (svn_cmdline_init("svnserve", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create our top-level pool. */
pool = apr_allocator_owner_get(svn_pool_create_allocator(TRUE));
err = sub_main(&exit_code, argc, argv, pool);
/* Flush stdout and report if it fails. It would be flushed on exit anyway
but this makes sure that output is not silently lost if it fails. */
err = svn_error_compose_create(err, svn_cmdline_fflush(stdout));
if (err)
{
exit_code = EXIT_FAILURE;
svn_cmdline_handle_exit_error(err, NULL, "svnserve: ");
}
#if APR_HAS_THREADS
/* Explicitly wait for all threads to exit. As we found out with similar
code in our C test framework, the memory pool cleanup below cannot be
trusted to do the right thing. */
if (threads)
apr_thread_pool_destroy(threads);
#endif
/* this will also close the server's socket */
svn_pool_destroy(pool);
return exit_code;
}
int main(int argc, char **argv)
{
apr_pool_t *pool;
int exit_code = EXIT_SUCCESS;
svn_error_t *err;
const char *filename;
if (argc == 2)
filename = argv[1];
else
filename = "-";
if (svn_cmdline_init("afl-x509", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE));
err = parse(filename, pool);
if (err)
exit_code = EXIT_FAILURE;
svn_error_clear(err);
svn_pool_destroy(pool);
return exit_code;
}
int
main (int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err;
svn_opt_revision_t revision;
apr_hash_t *dirents;
apr_hash_index_t *hi;
svn_client_ctx_t *ctx;
const char *URL;
if (argc <= 1)
{
printf ("Usage: %s URL\n", argv[0]);
return EXIT_FAILURE;
}
else
URL = argv[1];
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init ("minimal_client", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create top-level memory pool. Be sure to read the HACKING file to
understand how to properly use/free subpools. */
pool = svn_pool_create (NULL);
/* Initialize the FS library. */
err = svn_fs_initialize (pool);
if (err)
{
/* For functions deeper in the stack, we usually use the
SVN_ERR() exception-throwing macro (see svn_error.h). At the
top level, we catch & print the error with svn_handle_error2(). */
svn_handle_error2 (err, stderr, FALSE, "minimal_client: ");
return EXIT_FAILURE;
}
/* Make sure the ~/.subversion run-time config files exist */
err = svn_config_ensure (NULL, pool);
if (err)
{
svn_handle_error2 (err, stderr, FALSE, "minimal_client: ");
return EXIT_FAILURE;
}
/* All clients need to fill out a client_ctx object. */
{
/* Initialize and allocate the client_ctx object. */
if ((err = svn_client_create_context (&ctx, pool)))
{
svn_handle_error2 (err, stderr, FALSE, "minimal_client: ");
return EXIT_FAILURE;
}
/* Load the run-time config file into a hash */
if ((err = svn_config_get_config (&(ctx->config), NULL, pool)))
{
svn_handle_error2 (err, stderr, FALSE, "minimal_client: ");
return EXIT_FAILURE;
}
#ifdef WIN32
/* Set the working copy administrative directory name. */
if (getenv ("SVN_ASP_DOT_NET_HACK"))
{
err = svn_wc_set_adm_dir ("_svn", pool);
if (err)
{
svn_handle_error2 (err, stderr, FALSE, "minimal_client: ");
return EXIT_FAILURE;
}
}
#endif
/* Depending on what your client does, you'll want to read about
(and implement) the various callback function types below. */
/* A func (& context) which receives event signals during
checkouts, updates, commits, etc. */
/* ctx->notify_func = my_notification_func;
ctx->notify_baton = NULL; */
/* A func (& context) which can receive log messages */
/* ctx->log_msg_func = my_log_msg_receiver_func;
ctx->log_msg_baton = NULL; */
/* A func (& context) which checks whether the user cancelled */
/* ctx->cancel_func = my_cancel_checking_func;
ctx->cancel_baton = NULL; */
/* Make the client_ctx capable of authenticating users */
{
/* There are many different kinds of authentication back-end
"providers". See svn_auth.h for a full overview.
If you want to get the auth behavior of the 'svn' program,
you can use svn_cmdline_setup_auth_baton, which will give
you the exact set of auth providers it uses. This program
doesn't use it because it's only appropriate for a command
line program, and this is supposed to be a general purpose
example. */
svn_auth_provider_object_t *provider;
apr_array_header_t *providers
= apr_array_make (pool, 4, sizeof (svn_auth_provider_object_t *));
svn_auth_get_simple_prompt_provider (&provider,
my_simple_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
svn_auth_get_username_prompt_provider (&provider,
my_username_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
/* Register the auth-providers into the context's auth_baton. */
svn_auth_open (&ctx->auth_baton, providers, pool);
}
} /* end of client_ctx setup */
/* Now do the real work. */
/* Set revision to always be the HEAD revision. It could, however,
be set to a specific revision number, date, or other values. */
revision.kind = svn_opt_revision_head;
/* Main call into libsvn_client does all the work. */
err = svn_client_ls (&dirents,
URL, &revision,
FALSE, /* no recursion */
ctx, pool);
if (err)
{
svn_handle_error2 (err, stderr, FALSE, "minimal_client: ");
return EXIT_FAILURE;
}
/* Print the dir entries in the hash. */
for (hi = apr_hash_first (pool, dirents); hi; hi = apr_hash_next (hi))
{
const char *entryname;
svn_dirent_t *val;
apr_hash_this (hi, (void *) &entryname, NULL, (void *) &val);
printf (" %s\n", entryname);
/* 'val' is actually an svn_dirent_t structure; a more complex
program would mine it for extra printable information. */
}
return EXIT_SUCCESS;
}
int
main (int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err;
const char *URL;
svn_ra_session_t *session;
svn_ra_callbacks2_t *cbtable;
svn_revnum_t rev;
apr_hash_t *cfg_hash;
svn_auth_baton_t *auth_baton;
if (argc <= 1)
{
printf ("Usage: %s URL\n", argv[0]);
printf (" Print HEAD revision of URL's repository.\n");
return EXIT_FAILURE;
}
else
URL = argv[1];
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init ("headrev", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create top-level memory pool. Be sure to read the HACKING file to
understand how to properly use/free subpools. */
pool = svn_pool_create (NULL);
/* Initialize the FS library. */
err = svn_fs_initialize (pool);
if (err) goto hit_error;
/* Make sure the ~/.subversion run-time config files exist, and load. */
err = svn_config_ensure (NULL, pool);
if (err) goto hit_error;
err = svn_config_get_config (&cfg_hash, NULL, pool);
if (err) goto hit_error;
/* Build an authentication baton. */
{
/* There are many different kinds of authentication back-end
"providers". See svn_auth.h for a full overview. */
svn_auth_provider_object_t *provider;
apr_array_header_t *providers
= apr_array_make (pool, 4, sizeof (svn_auth_provider_object_t *));
svn_client_get_simple_prompt_provider (&provider,
my_simple_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
svn_client_get_username_prompt_provider (&provider,
my_username_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
/* Register the auth-providers into the context's auth_baton. */
svn_auth_open (&auth_baton, providers, pool);
}
/* Create a table of callbacks for the RA session, mostly nonexistent. */
cbtable = apr_pcalloc (pool, sizeof(*cbtable));
cbtable->auth_baton = auth_baton;
cbtable->open_tmp_file = open_tmp_file;
/* Now do the real work. */
err = svn_ra_open2(&session, URL, cbtable, NULL, cfg_hash, pool);
if (err) goto hit_error;
err = svn_ra_get_latest_revnum(session, &rev, pool);
if (err) goto hit_error;
printf ("The latest revision is %ld.\n", rev);
return EXIT_SUCCESS;
hit_error:
svn_handle_error2 (err, stderr, FALSE, "headrev: ");
return EXIT_FAILURE;
}
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;
}
/*
* Why is this not an svn subcommand? I have this vague idea that it could
* be run as part of the build process, with the output embedded in the svn
* program. Obviously we don't want to have to run svn when building svn.
*/
int
main(int argc, const char *argv[])
{
const char *wc_path, *trail_url;
apr_allocator_t *allocator;
apr_pool_t *pool;
int wc_format;
svn_wc_revision_status_t *res;
svn_boolean_t no_newline = FALSE, committed = FALSE;
svn_error_t *err;
apr_getopt_t *os;
const apr_getopt_option_t options[] =
{
{"no-newline", 'n', 0, N_("do not output the trailing newline")},
{"committed", 'c', 0, N_("last changed rather than current revisions")},
{"help", 'h', 0, N_("display this help")},
{"version", SVNVERSION_OPT_VERSION, 0,
N_("show program version information")},
{0, 0, 0, 0}
};
/* Initialize the app. */
if (svn_cmdline_init("svnversion", 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);
/* Check library versions */
err = check_lib_versions();
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
#if defined(WIN32) || defined(__CYGWIN__)
/* Set the working copy administrative directory name. */
if (getenv("SVN_ASP_DOT_NET_HACK"))
{
err = svn_wc_set_adm_dir("_svn", pool);
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
}
#endif
err = svn_cmdline__getopt_init(&os, argc, argv, pool);
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
os->interleave = 1;
while (1)
{
int opt;
const char *arg;
apr_status_t status = apr_getopt_long(os, options, &opt, &arg);
if (APR_STATUS_IS_EOF(status))
break;
if (status != APR_SUCCESS)
{
usage(pool);
return EXIT_FAILURE;
}
switch (opt)
{
case 'n':
no_newline = TRUE;
break;
case 'c':
committed = TRUE;
break;
case 'h':
help(options, pool);
break;
case SVNVERSION_OPT_VERSION:
SVN_INT_ERR(version(pool));
exit(0);
break;
default:
usage(pool);
return EXIT_FAILURE;
}
}
if (os->ind > argc || os->ind < argc - 2)
{
usage(pool);
return EXIT_FAILURE;
}
SVN_INT_ERR(svn_utf_cstring_to_utf8
(&wc_path, (os->ind < argc) ? os->argv[os->ind] : ".",
pool));
wc_path = svn_path_internal_style(wc_path, pool);
if (os->ind+1 < argc)
SVN_INT_ERR(svn_utf_cstring_to_utf8
(&trail_url, os->argv[os->ind+1], pool));
else
trail_url = NULL;
SVN_INT_ERR(svn_wc_check_wc(wc_path, &wc_format, pool));
if (! wc_format)
{
svn_node_kind_t kind;
SVN_INT_ERR(svn_io_check_path(wc_path, &kind, pool));
if (kind == svn_node_dir)
{
SVN_INT_ERR(svn_cmdline_printf(pool, _("exported%s"),
no_newline ? "" : "\n"));
svn_pool_destroy(pool);
return EXIT_SUCCESS;
}
else
{
svn_error_clear
(svn_cmdline_fprintf(stderr, pool,
_("'%s' not versioned, and not exported\n"),
wc_path));
svn_pool_destroy(pool);
return EXIT_FAILURE;
}
}
SVN_INT_ERR(svn_wc_revision_status(&res, wc_path, trail_url, committed,
NULL, NULL, pool));
/* Build compact '123[:456]M?S?' string. */
SVN_INT_ERR(svn_cmdline_printf(pool, "%ld", res->min_rev));
if (res->min_rev != res->max_rev)
SVN_INT_ERR(svn_cmdline_printf(pool, ":%ld", res->max_rev));
if (res->modified)
SVN_INT_ERR(svn_cmdline_fputs("M", stdout, pool));
if (res->switched)
SVN_INT_ERR(svn_cmdline_fputs("S", stdout, pool));
if (res->sparse_checkout)
SVN_INT_ERR(svn_cmdline_fputs("P", stdout, pool));
if (! no_newline)
SVN_INT_ERR(svn_cmdline_fputs("\n", stdout, pool));
svn_pool_destroy(pool);
/* Flush stdout to make sure that the user will see any printing errors. */
SVN_INT_ERR(svn_cmdline_fflush(stdout));
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
apr_pool_t *pool;
svn_error_t *err;
apr_array_header_t *targets;
apr_array_header_t *condensed_targets;
const char *common_path = 0;
const char *common_path2 = 0;
int i;
if (argc < 2) {
fprintf(stderr, "USAGE: %s <list of entries to be compared>\n", argv[0]);
return EXIT_FAILURE;
}
/* Initialize the app. */
if (svn_cmdline_init("target-test", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create our top-level pool. */
pool = svn_pool_create(NULL);
/* Create the target array */
targets = apr_array_make(pool, argc - 1, sizeof(const char *));
for (i = 1; i < argc; i++)
{
const char *path_utf8;
#ifndef AS400_UTF8
err = svn_utf_cstring_to_utf8(&path_utf8, argv[i], pool);
#else
/* Even when compiled with UTF support in V5R4, argv is still
* encoded in ebcdic. */
err = svn_utf_cstring_to_utf8_ex2(&path_utf8, argv[i],
(const char *)0, pool);
#endif
if (err != SVN_NO_ERROR)
svn_handle_error2(err, stderr, TRUE, "target-test: ");
APR_ARRAY_PUSH(targets, const char *) =
svn_path_internal_style(path_utf8, pool);
}
/* Call the function */
err = svn_path_condense_targets(&common_path, &condensed_targets, targets,
TRUE, pool);
if (err != SVN_NO_ERROR)
svn_handle_error2(err, stderr, TRUE, "target-test: ");
/* Display the results */
{
const char *common_path_stdout;
err = svn_utf_cstring_from_utf8(&common_path_stdout, common_path, pool);
if (err != SVN_NO_ERROR)
svn_handle_error2(err, stderr, TRUE, "target-test: ");
printf("%s: ", common_path_stdout);
}
for (i = 0; i < condensed_targets->nelts; i++)
{
const char * target = APR_ARRAY_IDX(condensed_targets, i, const char*);
if (target)
{
const char *target_stdout;
err = svn_utf_cstring_from_utf8(&target_stdout, target, pool);
if (err != SVN_NO_ERROR)
svn_handle_error2(err, stderr, TRUE, "target-test: ");
printf("%s, ", target_stdout);
}
else
printf("NULL, ");
}
printf("\n");
/* Now ensure it works without the pbasename */
err = svn_path_condense_targets(&common_path2, NULL, targets, TRUE, pool);
if (err != SVN_NO_ERROR)
svn_handle_error2(err, stderr, TRUE, "target-test: ");
if (strcmp(common_path, common_path2) != 0)
{
printf("Common path without getting targets does not match common path "
"with targets\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/*
* Why is this not an svn subcommand? I have this vague idea that it could
* be run as part of the build process, with the output embedded in the svn
* program. Obviously we don't want to have to run svn when building svn.
*/
int
main(int argc, const char *argv[])
{
const char *wc_path, *trail_url;
const char *local_abspath;
apr_pool_t *pool;
svn_wc_revision_status_t *res;
svn_boolean_t no_newline = FALSE, committed = FALSE;
svn_error_t *err;
apr_getopt_t *os;
svn_wc_context_t *wc_ctx;
svn_boolean_t quiet = FALSE;
svn_boolean_t is_version = FALSE;
const apr_getopt_option_t options[] =
{
{"no-newline", 'n', 0, N_("do not output the trailing newline")},
{"committed", 'c', 0, N_("last changed rather than current revisions")},
{"help", 'h', 0, N_("display this help")},
{"version", SVNVERSION_OPT_VERSION, 0,
N_("show program version information")},
{"quiet", 'q', 0,
N_("no progress (only errors) to stderr")},
{0, 0, 0, 0}
};
/* Initialize the app. */
if (svn_cmdline_init("svnversion", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create our top-level pool. Use a separate mutexless allocator,
* given this application is single threaded.
*/
pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE));
/* Check library versions */
err = check_lib_versions();
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
#if defined(WIN32) || defined(__CYGWIN__)
/* Set the working copy administrative directory name. */
if (getenv("SVN_ASP_DOT_NET_HACK"))
{
err = svn_wc_set_adm_dir("_svn", pool);
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
}
#endif
err = svn_cmdline__getopt_init(&os, argc, argv, pool);
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svnversion: ");
os->interleave = 1;
while (1)
{
int opt;
const char *arg;
apr_status_t status = apr_getopt_long(os, options, &opt, &arg);
if (APR_STATUS_IS_EOF(status))
break;
if (status != APR_SUCCESS)
usage(pool); /* this will exit() */
switch (opt)
{
case 'n':
no_newline = TRUE;
break;
case 'c':
committed = TRUE;
break;
case 'q':
quiet = TRUE;
break;
case 'h':
help(options, pool);
break;
case SVNVERSION_OPT_VERSION:
is_version = TRUE;
break;
default:
usage(pool); /* this will exit() */
}
}
if (is_version)
{
SVN_INT_ERR(version(quiet, pool));
exit(0);
}
if (os->ind > argc || os->ind < argc - 2)
usage(pool); /* this will exit() */
SVN_INT_ERR(svn_utf_cstring_to_utf8(&wc_path,
(os->ind < argc) ? os->argv[os->ind]
: ".",
pool));
SVN_INT_ERR(svn_opt__arg_canonicalize_path(&wc_path, wc_path, pool));
SVN_INT_ERR(svn_dirent_get_absolute(&local_abspath, wc_path, pool));
SVN_INT_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
if (os->ind+1 < argc)
SVN_INT_ERR(svn_utf_cstring_to_utf8(&trail_url, os->argv[os->ind+1],
pool));
else
trail_url = NULL;
err = svn_wc_revision_status2(&res, wc_ctx, local_abspath, trail_url,
committed, NULL, NULL, pool, pool);
if (err && (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND
|| err->apr_err == SVN_ERR_WC_NOT_WORKING_COPY))
{
svn_node_kind_t kind;
svn_boolean_t special;
svn_error_clear(err);
SVN_INT_ERR(svn_io_check_special_path(local_abspath, &kind, &special,
pool));
if (special)
SVN_INT_ERR(svn_cmdline_printf(pool, _("Unversioned symlink%s"),
no_newline ? "" : "\n"));
else if (kind == svn_node_dir)
SVN_INT_ERR(svn_cmdline_printf(pool, _("Unversioned directory%s"),
no_newline ? "" : "\n"));
else if (kind == svn_node_file)
SVN_INT_ERR(svn_cmdline_printf(pool, _("Unversioned file%s"),
no_newline ? "" : "\n"));
else
{
SVN_INT_ERR(svn_cmdline_fprintf(stderr, pool,
kind == svn_node_none
? _("'%s' doesn't exist\n")
: _("'%s' is of unknown type\n"),
svn_dirent_local_style(local_abspath,
pool)));
svn_pool_destroy(pool);
return EXIT_FAILURE;
}
svn_pool_destroy(pool);
return EXIT_SUCCESS;
}
SVN_INT_ERR(err);
if (! SVN_IS_VALID_REVNUM(res->min_rev))
{
/* Local uncommitted modifications, no revision info was found. */
SVN_INT_ERR(svn_cmdline_printf(pool, _("Uncommitted local addition, "
"copy or move%s"),
no_newline ? "" : "\n"));
svn_pool_destroy(pool);
return EXIT_SUCCESS;
}
/* Build compact '123[:456]M?S?' string. */
SVN_INT_ERR(svn_cmdline_printf(pool, "%ld", res->min_rev));
if (res->min_rev != res->max_rev)
SVN_INT_ERR(svn_cmdline_printf(pool, ":%ld", res->max_rev));
if (res->modified)
SVN_INT_ERR(svn_cmdline_fputs("M", stdout, pool));
if (res->switched)
SVN_INT_ERR(svn_cmdline_fputs("S", stdout, pool));
if (res->sparse_checkout)
SVN_INT_ERR(svn_cmdline_fputs("P", stdout, pool));
if (! no_newline)
SVN_INT_ERR(svn_cmdline_fputs("\n", stdout, pool));
svn_pool_destroy(pool);
/* Flush stdout to make sure that the user will see any printing errors. */
SVN_INT_ERR(svn_cmdline_fflush(stdout));
return EXIT_SUCCESS;
}
static int cmd_isvn_clone(int argc, const char **cargv, const char *prefix)
{
svn_revnum_t latest_rev = SVN_INVALID_REVNUM;
struct isvn_client_ctx *first_client;
char *dir, *key, **argv;
const char *repo_name;
svn_error_t *err;
git_repository_init_options initopts;
git_config *config;
int rc;
argv = __DECONST(cargv, char **);
argc = isvn_parse_opts(argc, argv, isvn_clone_options,
isvn_clone_usage);
if (argc < 1)
isvn_usage(isvn_clone_usage, isvn_clone_options,
"You must specify a repository to clone.");
else if (argc < 2)
isvn_usage(isvn_clone_usage, isvn_clone_options,
"You must specify a destination directory.");
else if (argc > 2)
isvn_usage(isvn_clone_usage, isvn_clone_options,
"Too many arguments.");
if (!option_origin)
option_origin = "origin";
option_cloning = true;
if (option_maxrev < 0)
isvn_usage(isvn_clone_usage, isvn_clone_options,
"Maxrev cannot be negative");
repo_name = argv[0];
if (argc == 2)
dir = xstrdup(argv[1]);
else
dir = guess_dir_name(repo_name);
initopts = (git_repository_init_options) GIT_REPOSITORY_INIT_OPTIONS_INIT;
initopts.flags = GIT_REPOSITORY_INIT_MKDIR |
GIT_REPOSITORY_INIT_NO_REINIT |
GIT_REPOSITORY_INIT_MKPATH;
rc = git_repository_init_ext(&g_git_repo, dir, &initopts);
if (rc < 0)
die("Error creating git repository: %d", rc);
rc = git_repository_config(&config, g_git_repo);
if (rc)
die("git_repository_config: %d", rc);
xasprintf(&key, "remote.%s.url", option_origin);
rc = git_config_set_string(config, key, repo_name);
if (rc)
die("git_config_set_string: %d", rc);
g_svn_url = xstrdup(repo_name);
free(key);
/* Initialize APR / libsvn */
if (svn_cmdline_init("git-isvn", stderr) != EXIT_SUCCESS)
die("svn_cmdline_init");
first_client = get_svn_ctx();
if (first_client == NULL)
die("Could not connect to SVN server.");
err = svn_ra_get_latest_revnum(first_client->svn_session, &latest_rev,
first_client->svn_pool);
assert_noerr(err, "svn_ra_get_latest_revnum");
if (option_verbosity >= 2)
printf("Maximum SVN repository revision: %ju\n",
(uintmax_t)latest_rev);
if (option_maxrev == 0 || option_maxrev > latest_rev)
option_maxrev = latest_rev;
isvn_fetch(first_client);
/* Branch 'master' from remote trunk and checkout. */
checkout(g_git_repo);
git_config_free(config);
git_repository_free(g_git_repo);
g_git_repo = NULL;
free(dir);
return 0;
}
int
main(int argc, const char *argv[])
{
const char *repos_path;
apr_pool_t *pool;
svn_boolean_t prop = FALSE, data = FALSE;
svn_boolean_t quiet = FALSE;
svn_error_t *err;
apr_getopt_t *os;
const apr_getopt_option_t options[] =
{
{"data", OPT_DATA, 0, N_("display data reps stats")},
{"prop", OPT_PROP, 0, N_("display prop reps stats")},
{"both", OPT_BOTH, 0, N_("display combined (data+prop) reps stats")},
{"quiet", 'q', 0, N_("no progress (only errors) to stderr")},
{"help", 'h', 0, N_("display this help")},
{"version", OPT_VERSION, 0,
N_("show program version information")},
{0, 0, 0, 0}
};
/* Initialize the app. */
if (svn_cmdline_init("svn-rep-sharing-stats", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create our top-level pool. Use a separate mutexless allocator,
* given this application is single threaded.
*/
pool = apr_allocator_owner_get(svn_pool_create_allocator(FALSE));
/* Check library versions */
err = check_lib_versions();
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svn-rep-sharing-stats: ");
err = svn_cmdline__getopt_init(&os, argc, argv, pool);
if (err)
return svn_cmdline_handle_exit_error(err, pool, "svn-rep-sharing-stats: ");
SVN_INT_ERR(check_experimental());
os->interleave = 1;
while (1)
{
int opt;
const char *arg;
apr_status_t status = apr_getopt_long(os, options, &opt, &arg);
if (APR_STATUS_IS_EOF(status))
break;
if (status != APR_SUCCESS)
{
usage(pool);
return EXIT_FAILURE;
}
switch (opt)
{
case OPT_DATA:
data = TRUE;
break;
/* It seems we don't actually rep-share props yet. */
case OPT_PROP:
prop = TRUE;
break;
case OPT_BOTH:
data = TRUE;
prop = TRUE;
break;
case 'q':
quiet = TRUE;
break;
case 'h':
help(options, pool);
break;
case OPT_VERSION:
SVN_INT_ERR(version(pool));
exit(0);
break;
default:
usage(pool);
return EXIT_FAILURE;
}
}
/* Exactly 1 non-option argument,
* and at least one of "--data"/"--prop"/"--both".
*/
if (os->ind + 1 != argc || (!data && !prop))
{
usage(pool);
return EXIT_FAILURE;
}
/* Grab REPOS_PATH from argv. */
SVN_INT_ERR(svn_utf_cstring_to_utf8(&repos_path, os->argv[os->ind], pool));
repos_path = svn_dirent_internal_style(repos_path, pool);
set_up_cancellation();
/* Do something. */
SVN_INT_ERR(process(repos_path, prop, data, quiet, pool));
/* We're done. */
svn_pool_destroy(pool);
/* Flush stdout to make sure that the user will see any printing errors. */
SVN_INT_ERR(svn_cmdline_fflush(stdout));
return EXIT_SUCCESS;
}
int
main (int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err;
apr_hash_t *dirents;
const char *upload_file, *URL;
const char *parent_URL, *basename;
svn_ra_plugin_t *ra_lib;
void *session, *ra_baton;
svn_revnum_t rev;
const svn_delta_editor_t *editor;
void *edit_baton;
svn_dirent_t *dirent;
svn_ra_callbacks_t *cbtable;
apr_hash_t *cfg_hash;
svn_auth_baton_t *auth_baton;
if (argc <= 2)
{
printf ("Usage: %s PATH URL\n", argv[0]);
printf (" Uploads file at PATH to Subversion repository URL.\n");
return EXIT_FAILURE;
}
upload_file = argv[1];
URL = argv[2];
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init ("minimal_client", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create top-level memory pool. Be sure to read the HACKING file to
understand how to properly use/free subpools. */
pool = svn_pool_create (NULL);
/* Initialize the FS library. */
err = svn_fs_initialize (pool);
if (err) goto hit_error;
/* Make sure the ~/.subversion run-time config files exist, and load. */
err = svn_config_ensure (NULL, pool);
if (err) goto hit_error;
err = svn_config_get_config (&cfg_hash, NULL, pool);
if (err) goto hit_error;
/* Build an authentication baton. */
{
/* There are many different kinds of authentication back-end
"providers". See svn_auth.h for a full overview. */
svn_auth_provider_object_t *provider;
apr_array_header_t *providers
= apr_array_make (pool, 4, sizeof (svn_auth_provider_object_t *));
svn_client_get_simple_prompt_provider (&provider,
my_simple_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
svn_client_get_username_prompt_provider (&provider,
my_username_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
/* Register the auth-providers into the context's auth_baton. */
svn_auth_open (&auth_baton, providers, pool);
}
/* Create a table of callbacks for the RA session, mostly nonexistent. */
cbtable = apr_pcalloc (pool, sizeof(*cbtable));
cbtable->auth_baton = auth_baton;
cbtable->open_tmp_file = open_tmp_file;
/* Now do the real work. */
/* Open an RA session to the parent URL, fetch current HEAD rev and
"lock" onto that revnum for the remainder of the session. */
svn_path_split (URL, &parent_URL, &basename, pool);
err = svn_ra_init_ra_libs (&ra_baton, pool);
if (err) goto hit_error;
err = svn_ra_get_ra_library (&ra_lib, ra_baton, parent_URL, pool);
if (err) goto hit_error;
err = ra_lib->open (&session, parent_URL, cbtable, NULL, cfg_hash, pool);
if (err) goto hit_error;
err = ra_lib->get_latest_revnum (session, &rev, pool);
if (err) goto hit_error;
/* Examine contents of parent dir in the rev. */
err = ra_lib->get_dir (session, "", rev, &dirents, NULL, NULL, pool);
if (err) goto hit_error;
/* Sanity checks. Don't let the user shoot himself *too* much. */
dirent = apr_hash_get (dirents, basename, APR_HASH_KEY_STRING);
if (dirent && dirent->kind == svn_node_dir)
{
printf ("Sorry, a directory already exists at that URL.\n");
return EXIT_FAILURE;
}
if (dirent && dirent->kind == svn_node_file)
{
char answer[5];
printf ("\n*** WARNING ***\n\n");
printf ("You're about to overwrite r%ld of this file.\n", rev);
printf ("It was last changed by user '%s',\n",
dirent->last_author ? dirent->last_author : "?");
printf ("on %s.\n", svn_time_to_human_cstring (dirent->time, pool));
printf ("\nSomebody *might* have just changed the file seconds ago,\n"
"and your upload would be overwriting their changes!\n\n");
err = prompt_and_read_line("Are you SURE you want to upload? [y/n]",
answer, sizeof(answer));
if (err) goto hit_error;
if (apr_strnatcasecmp (answer, "y"))
{
printf ("Operation aborted.\n");
return EXIT_SUCCESS;
}
}
/* Fetch a commit editor (it's anchored on the parent URL, because
the session is too.) */
/* ### someday add an option for a user-written commit message? */
err = ra_lib->get_commit_editor (session, &editor, &edit_baton,
"File upload from 'svnput' program.",
my_commit_callback, NULL, pool);
if (err) goto hit_error;
/* Drive the editor */
{
void *root_baton, *file_baton, *handler_baton;
svn_txdelta_window_handler_t handler;
svn_stream_t *contents;
apr_file_t *f = NULL;
err = editor->open_root (edit_baton, rev, pool, &root_baton);
if (err) goto hit_error;
if (! dirent)
{
err = editor->add_file (basename, root_baton, NULL, SVN_INVALID_REVNUM,
pool, &file_baton);
}
else
{
err = editor->open_file (basename, root_baton, rev, pool,
&file_baton);
}
if (err) goto hit_error;
err = editor->apply_textdelta (file_baton, NULL, pool,
&handler, &handler_baton);
if (err) goto hit_error;
err = svn_io_file_open (&f, upload_file, APR_READ, APR_OS_DEFAULT, pool);
if (err) goto hit_error;
contents = svn_stream_from_aprfile (f, pool);
err = svn_txdelta_send_stream (contents, handler, handler_baton,
NULL, pool);
if (err) goto hit_error;
err = svn_io_file_close (f, pool);
if (err) goto hit_error;
err = editor->close_file (file_baton, NULL, pool);
if (err) goto hit_error;
err = editor->close_edit (edit_baton, pool);
if (err) goto hit_error;
}
return EXIT_SUCCESS;
hit_error:
svn_handle_error2 (err, stderr, FALSE, "svnput: ");
return EXIT_FAILURE;
}
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;
}
}
int
main (int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err;
apr_hash_t *locks;
apr_hash_index_t *hi;
const char *URL;
svn_ra_session_t *session;
svn_ra_callbacks_t *cbtable;
apr_hash_t *cfg_hash;
svn_auth_baton_t *auth_baton;
if (argc <= 1)
{
printf ("Usage: %s URL\n", argv[0]);
printf (" Print all locks at or below URL.\n");
return EXIT_FAILURE;
}
URL = argv[1];
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init ("ra_test", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create top-level memory pool. Be sure to read the HACKING file to
understand how to properly use/free subpools. */
pool = svn_pool_create (NULL);
/* Initialize the FS library. */
err = svn_fs_initialize (pool);
if (err) goto hit_error;
/* Make sure the ~/.subversion run-time config files exist, and load. */
err = svn_config_ensure (NULL, pool);
if (err) goto hit_error;
err = svn_config_get_config (&cfg_hash, NULL, pool);
if (err) goto hit_error;
/* Build an authentication baton. */
{
/* There are many different kinds of authentication back-end
"providers". See svn_auth.h for a full overview. */
svn_auth_provider_object_t *provider;
apr_array_header_t *providers
= apr_array_make (pool, 4, sizeof (svn_auth_provider_object_t *));
svn_client_get_simple_prompt_provider (&provider,
my_simple_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
svn_client_get_username_prompt_provider (&provider,
my_username_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
/* Register the auth-providers into the context's auth_baton. */
svn_auth_open (&auth_baton, providers, pool);
}
/* Create a table of callbacks for the RA session, mostly nonexistent. */
cbtable = apr_pcalloc (pool, sizeof(*cbtable));
cbtable->auth_baton = auth_baton;
cbtable->open_tmp_file = open_tmp_file;
/* Now do the real work. */
err = svn_ra_open (&session, URL, cbtable, NULL, cfg_hash, pool);
if (err) goto hit_error;
err = svn_ra_get_locks (session, &locks, "", pool);
if (err) goto hit_error;
err = svn_cmdline_printf (pool, "\n");
if (err) goto hit_error;
for (hi = apr_hash_first (pool, locks); hi; hi = apr_hash_next (hi))
{
const void *key;
void *val;
const char *path, *cr_date, *exp_date;
svn_lock_t *lock;
apr_hash_this (hi, &key, NULL, &val);
path = key;
lock = val;
cr_date = svn_time_to_human_cstring (lock->creation_date, pool);
if (lock->expiration_date)
exp_date = svn_time_to_human_cstring (lock->expiration_date, pool);
else
exp_date = "never";
err = svn_cmdline_printf (pool, "%s\n", path);
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" UUID Token: %s\n", lock->token);
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" Owner: %s\n", lock->owner);
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" Comment: %s\n",
lock->comment ? lock->comment : "none");
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" Created: %s\n", cr_date);
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" Expires: %s\n\n", exp_date);
if (err) goto hit_error;
}
return EXIT_SUCCESS;
hit_error:
svn_handle_error2 (err, stderr, FALSE, "getlocks_test: ");
return EXIT_FAILURE;
}