static svn_error_t *
construct_auth_baton(svn_auth_baton_t **auth_baton_p,
apr_pool_t *pool)
{
apr_array_header_t *providers;
svn_auth_provider_object_t *simple_provider;
svn_auth_baton_t *auth_baton;
/* A bit of dancing just to pass jrandom:rayjandom. */
providers = apr_array_make(pool, 2, sizeof(svn_auth_provider_object_t *)),
svn_auth_get_simple_prompt_provider(&simple_provider,
aborting_simple_prompt_func, NULL,
0, pool);
APR_ARRAY_PUSH(providers, svn_auth_provider_object_t *) = simple_provider;
svn_auth_get_username_prompt_provider(&simple_provider,
aborting_username_prompt_func, NULL,
0, pool);
APR_ARRAY_PUSH(providers, svn_auth_provider_object_t *) = simple_provider;
svn_auth_open(&auth_baton, providers, pool);
svn_auth_set_parameter(auth_baton,
SVN_AUTH_PARAM_DEFAULT_USERNAME, "jrandom");
svn_auth_set_parameter(auth_baton,
SVN_AUTH_PARAM_DEFAULT_PASSWORD, "rayjandom");
*auth_baton_p = auth_baton;
return SVN_NO_ERROR;
}
void QSvn::init()
{
svn_error_t *err = nullptr;
pool = svn_pool_create(nullptr);
err = svn_fs_initialize(pool);
if (err)
{
emit error(tr("Error calling svn_fs_initialize."));
return;
}
err = svn_config_ensure(nullptr, pool);
if (err)
{
emit error(tr("Error calling svn_config_ensure."));
return;
}
err = svn_client_create_context(&ctx, pool);
if (err)
{
emit error(tr("Error calling svn_client_create_context."));
return;
}
err = svn_config_get_config(&(ctx->config), nullptr, pool);
if (err)
{
emit error(tr("Error calling svn_config_get_config."));
return;
}
ctx->log_msg_func3 = log_msg_func3;
ctx->log_msg_baton3 = nullptr;
ctx->notify_func2 = notify_func2;
ctx->notify_baton2 = this;
ctx->notify_func = nullptr;
ctx->notify_baton = this;
ctx->conflict_func = nullptr;
ctx->conflict_baton = this;
ctx->conflict_func2 = conflict_func2;
ctx->conflict_baton2 = this;
ctx->cancel_func = cancel_func;
ctx->cancel_baton = this;
ctx->progress_func = progress_func;
ctx->progress_baton = this;
ctx->client_name = "qsvn";
svn_auth_provider_object_t *provider;
apr_array_header_t *providers = apr_array_make (pool, 3, sizeof (svn_auth_provider_object_t *));
svn_auth_get_platform_specific_client_providers (&providers, nullptr, pool);
svn_auth_get_simple_prompt_provider (&provider,
&svn_login_callback,
this, /* baton */
3, /* 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);
}
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;
}
