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; }