static svn_error_t *
make_and_open_local_repos(svn_ra_session_t **session,
const char *repos_name,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
svn_repos_t *repos;
const char *url;
svn_ra_callbacks2_t *cbtable;
SVN_ERR(svn_ra_create_callbacks(&cbtable, pool));
SVN_ERR(svn_test__create_repos(&repos, repos_name, opts, pool));
SVN_ERR(svn_ra_initialize(pool));
SVN_ERR(current_directory_url(&url, repos_name, pool));
SVN_ERR(svn_ra_open3(session,
url,
NULL,
cbtable,
NULL,
NULL,
pool));
return SVN_NO_ERROR;
}
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;
}
static svn_error_t *
make_and_open_repos(svn_ra_session_t **session,
const char *repos_name,
const svn_test_opts_t *opts,
apr_pool_t *pool)
{
const char *url;
svn_ra_callbacks2_t *cbtable;
SVN_ERR(svn_ra_create_callbacks(&cbtable, pool));
SVN_ERR(svn_test__init_auth_baton(&cbtable->auth_baton, pool));
SVN_ERR(svn_test__create_repos2(NULL, &url, NULL, repos_name, opts,
pool, pool));
SVN_ERR(svn_ra_initialize(pool));
SVN_ERR(svn_ra_open4(session, NULL, url, NULL, cbtable, NULL, NULL, pool));
return SVN_NO_ERROR;
}
/* Initialize the RA layer, and set *CTX to a new client context baton
* allocated from POOL. Use CONFIG_DIR and pass USERNAME, PASSWORD,
* CONFIG_DIR and NO_AUTH_CACHE to initialize the authorization baton.
* CONFIG_OPTIONS (if not NULL) is a list of configuration overrides.
*/
static svn_error_t *
init_client_context(svn_client_ctx_t **ctx_p,
svn_boolean_t non_interactive,
const char *username,
const char *password,
const char *config_dir,
svn_boolean_t no_auth_cache,
svn_boolean_t trust_server_cert,
apr_array_header_t *config_options,
apr_pool_t *pool)
{
svn_client_ctx_t *ctx = NULL;
svn_config_t *cfg_config;
SVN_ERR(svn_ra_initialize(pool));
SVN_ERR(svn_config_ensure(config_dir, pool));
SVN_ERR(svn_client_create_context(&ctx, pool));
SVN_ERR(svn_config_get_config(&(ctx->config), config_dir, pool));
if (config_options)
SVN_ERR(svn_cmdline__apply_config_options(ctx->config, config_options,
"svnrdump: ", "--config-option"));
cfg_config = apr_hash_get(ctx->config, SVN_CONFIG_CATEGORY_CONFIG,
APR_HASH_KEY_STRING);
/* Set up our cancellation support. */
ctx->cancel_func = check_cancel;
/* Default authentication providers for non-interactive use */
SVN_ERR(svn_cmdline_create_auth_baton(&(ctx->auth_baton), non_interactive,
username, password, config_dir,
no_auth_cache, trust_server_cert,
cfg_config, ctx->cancel_func,
ctx->cancel_baton, pool));
*ctx_p = ctx;
return SVN_NO_ERROR;
}
/* 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;
}
/**
* Initialize the environment for all requests.
* @param env the JNI environment for this request
*/
bool JNIUtil::JNIGlobalInit(JNIEnv *env)
{
// This method has to be run only once during the run a program.
static bool run = false;
svn_error_t *err;
if (run) // already run
return true;
run = true;
// Do not run this part more than one time. This leaves a small
// time window when two threads create their first SVNClient and
// SVNAdmin at the same time, but I do not see a better option
// without APR already initialized
if (g_inInit)
return false;
g_inInit = true;
g_initEnv = env;
apr_status_t status;
/* Initialize the APR subsystem, and register an atexit() function
* to Uninitialize that subsystem at program exit. */
status = apr_initialize();
if (status)
{
if (stderr)
{
char buf[1024];
apr_strerror(status, buf, sizeof(buf) - 1);
fprintf(stderr,
"%s: error: cannot initialize APR: %s\n",
"svnjavahl", buf);
}
return FALSE;
}
/* This has to happen before any pools are created. */
if ((err = svn_dso_initialize2()))
{
if (stderr && err->message)
fprintf(stderr, "%s", err->message);
svn_error_clear(err);
return FALSE;
}
if (0 > atexit(apr_terminate))
{
if (stderr)
fprintf(stderr,
"%s: error: atexit registration failed\n",
"svnjavahl");
return FALSE;
}
/* Create our top-level pool. */
g_pool = svn_pool_create(NULL);
apr_allocator_t* allocator = apr_pool_allocator_get(g_pool);
if (allocator)
{
/* Keep a maximum of 1 free block, to release memory back to the JVM
(and other modules). */
apr_allocator_max_free_set(allocator, 1);
}
svn_utf_initialize2(FALSE, g_pool); /* Optimize character conversions */
svn_fs_initialize(g_pool); /* Avoid some theoretical issues */
svn_ra_initialize(g_pool);
/* We shouldn't fill the JVMs memory with FS cache data unless explictly
requested. */
{
svn_cache_config_t settings = *svn_cache_config_get();
settings.cache_size = 0;
settings.file_handle_count = 0;
settings.single_threaded = FALSE;
svn_cache_config_set(&settings);
}
#ifdef ENABLE_NLS
#ifdef WIN32
{
WCHAR ucs2_path[MAX_PATH];
char *utf8_path;
const char *internal_path;
apr_pool_t *pool;
apr_status_t apr_err;
apr_size_t inwords, outbytes;
unsigned int outlength;
pool = svn_pool_create(g_pool);
/* get dll name - our locale info will be in '../share/locale' */
inwords = sizeof(ucs2_path) / sizeof(ucs2_path[0]);
HINSTANCE moduleHandle = GetModuleHandle("libsvnjavahl-1");
GetModuleFileNameW(moduleHandle, ucs2_path, inwords);
inwords = lstrlenW(ucs2_path);
outbytes = outlength = 3 * (inwords + 1);
utf8_path = reinterpret_cast<char *>(apr_palloc(pool, outlength));
apr_err = apr_conv_ucs2_to_utf8((const apr_wchar_t *) ucs2_path,
&inwords, utf8_path, &outbytes);
if (!apr_err && (inwords > 0 || outbytes == 0))
apr_err = APR_INCOMPLETE;
if (apr_err)
{
if (stderr)
fprintf(stderr, "Can't convert module path to UTF-8");
return FALSE;
}
utf8_path[outlength - outbytes] = '\0';
internal_path = svn_dirent_internal_style(utf8_path, pool);
/* get base path name */
internal_path = svn_dirent_dirname(internal_path, pool);
internal_path = svn_dirent_join(internal_path, SVN_LOCALE_RELATIVE_PATH,
pool);
bindtextdomain(PACKAGE_NAME, internal_path);
svn_pool_destroy(pool);
}
#else
bindtextdomain(PACKAGE_NAME, SVN_LOCALE_DIR);
#endif
#endif
#if defined(WIN32) || defined(__CYGWIN__)
/* See http://svn.apache.org/repos/asf/subversion/trunk/notes/asp-dot-net-hack.txt */
/* ### This code really only needs to be invoked by consumers of
### the libsvn_wc library, which basically means SVNClient. */
if (getenv("SVN_ASP_DOT_NET_HACK"))
{
err = svn_wc_set_adm_dir("_svn", g_pool);
if (err)
{
if (stderr)
{
fprintf(stderr,
"%s: error: SVN_ASP_DOT_NET_HACK failed: %s\n",
"svnjavahl", err->message);
}
svn_error_clear(err);
return FALSE;
}
}
#endif
svn_error_set_malfunction_handler(svn_error_raise_on_malfunction);
// Build all mutexes.
g_finalizedObjectsMutex = new JNIMutex(g_pool);
if (isExceptionThrown())
return false;
g_logMutex = new JNIMutex(g_pool);
if (isExceptionThrown())
return false;
// initialized the thread local storage
if (!JNIThreadData::initThreadData())
return false;
setEnv(env);
if (isExceptionThrown())
return false;
g_initEnv = NULL;
g_inInit = false;
return true;
}
