/* Ensure that the RA library NAME is loaded.
*
* If FUNC is non-NULL, set *FUNC to the address of the svn_ra_NAME__init
* function of the library.
*
* If COMPAT_FUNC is non-NULL, set *COMPAT_FUNC to the address of the
* svn_ra_NAME_init compatibility init function of the library.
*
* ### todo: Any RA libraries implemented from this point forward
* ### don't really need an svn_ra_NAME_init compatibility function.
* ### Currently, load_ra_module() will error if no such function is
* ### found, but it might be more friendly to simply set *COMPAT_FUNC
* ### to null (assuming COMPAT_FUNC itself is non-null).
*/
static svn_error_t *
load_ra_module(svn_ra__init_func_t *func,
svn_ra_init_func_t *compat_func,
const char *ra_name, apr_pool_t *pool)
{
if (func)
*func = NULL;
if (compat_func)
*compat_func = NULL;
#if defined(SVN_USE_DSO) && APR_HAS_DSO
{
apr_dso_handle_t *dso;
apr_dso_handle_sym_t symbol;
const char *libname;
const char *funcname;
const char *compat_funcname;
apr_status_t status;
libname = apr_psprintf(pool, "libsvn_ra_%s-%d.so.0",
ra_name, SVN_VER_MAJOR);
funcname = apr_psprintf(pool, "svn_ra_%s__init", ra_name);
compat_funcname = apr_psprintf(pool, "svn_ra_%s_init", ra_name);
/* find/load the specified library */
SVN_ERR(svn_dso_load(&dso, libname));
if (! dso)
return SVN_NO_ERROR;
/* find the initialization routines */
if (func)
{
status = apr_dso_sym(&symbol, dso, funcname);
if (status)
{
return svn_error_wrap_apr(status,
_("'%s' does not define '%s()'"),
libname, funcname);
}
*func = (svn_ra__init_func_t) symbol;
}
if (compat_func)
{
status = apr_dso_sym(&symbol, dso, compat_funcname);
if (status)
{
return svn_error_wrap_apr(status,
_("'%s' does not define '%s()'"),
libname, compat_funcname);
}
*compat_func = (svn_ra_init_func_t) symbol;
}
}
#endif /* APR_HAS_DSO */
return SVN_NO_ERROR;
}
/* Implements svn_read_fn_t */
static svn_error_t *
sock_read_cb(void *baton, char *buffer, apr_size_t *len)
{
sock_baton_t *b = baton;
apr_status_t status;
apr_interval_time_t interval;
status = apr_socket_timeout_get(b->sock, &interval);
if (status)
return svn_error_wrap_apr(status, _("Can't get socket timeout"));
/* Always block on read.
* During pipelining, we set the timeout to 0 for some write
* operations so that we can try them without blocking. If APR had
* separate timeouts for read and write, we would only set the
* write timeout, but it doesn't. So here, we revert back to blocking.
*/
apr_socket_timeout_set(b->sock, -1);
status = apr_socket_recv(b->sock, buffer, len);
apr_socket_timeout_set(b->sock, interval);
if (status && !APR_STATUS_IS_EOF(status))
return svn_error_wrap_apr(status, _("Can't read from connection"));
return SVN_NO_ERROR;
}
svn_error_t *svn_ra_neon__set_neon_body_provider(svn_ra_neon__request_t *req,
apr_file_t *body_file)
{
apr_status_t status;
apr_finfo_t finfo;
body_provider_baton_t *b = apr_palloc(req->pool, sizeof(*b));
status = apr_file_info_get(&finfo, APR_FINFO_SIZE, body_file);
if (status)
return svn_error_wrap_apr(status,
_("Can't calculate the request body size"));
b->body_file = body_file;
b->req = req;
#if defined(SVN_NEON_0_27)
ne_set_request_body_provider(req->ne_req, (ne_off_t)finfo.size,
ra_neon_body_provider, b);
#elif defined(NE_LFS)
ne_set_request_body_provider64(req->ne_req, finfo.size,
ra_neon_body_provider, b);
#else
/* Cut size to 32 bit */
ne_set_request_body_provider(req->ne_req, (size_t) finfo.size,
ra_neon_body_provider, b);
#endif
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_neon__copy_href(svn_stringbuf_t *dst, const char *src,
apr_pool_t *pool)
{
/* parse the PATH element out of the URL and store it.
### do we want to verify the rest matches the current session?
Note: mod_dav does not (currently) use an absolute URL, but simply a
server-relative path (i.e. this uri_parse is effectively a no-op).
*/
apr_uri_t uri;
apr_status_t apr_status;
/* SRC can have trailing '/' */
if (svn_path_is_url(src))
src = svn_uri_canonicalize(src, pool);
else
src = svn_urlpath__canonicalize(src, pool);
apr_status = apr_uri_parse(pool, src, &uri);
if (apr_status != APR_SUCCESS)
return svn_error_wrap_apr(apr_status,
_("Unable to parse URL '%s'"),
src);
svn_stringbuf_setempty(dst);
svn_stringbuf_appendcstr(dst, uri.path);
return SVN_NO_ERROR;
}
svn_error_t *
svn_fs_initialize(apr_pool_t *pool)
{
#if APR_HAS_THREADS
apr_status_t status;
#endif
/* Protect against multiple calls. */
if (common_pool)
return SVN_NO_ERROR;
common_pool = svn_pool_create(pool);
#if APR_HAS_THREADS
status = apr_thread_mutex_create(&common_pool_lock,
APR_THREAD_MUTEX_DEFAULT, common_pool);
if (status)
return svn_error_wrap_apr(status, _("Can't allocate FS mutex"));
#endif
/* ### This won't work if POOL is NULL and libsvn_fs is loaded as a DSO
### (via libsvn_ra_local say) since the global common_pool will live
### longer than the DSO, which gets unloaded when the pool used to
### load it is cleared, and so when the handler runs it will refer to
### a function that no longer exists. libsvn_ra_local attempts to
### work around this by explicitly calling svn_fs_initialize. */
apr_pool_cleanup_register(common_pool, NULL, uninit, apr_pool_cleanup_null);
return SVN_NO_ERROR;
}
/* Construct a cache key for the BDB environment at PATH in *KEYP.
if DBCONFIG_FILE is not NULL, return the opened file handle.
Allocate from POOL. */
static svn_error_t *
bdb_cache_key(bdb_env_key_t *keyp, apr_file_t **dbconfig_file,
const char *path, apr_pool_t *pool)
{
const char *dbcfg_file_name = svn_dirent_join(path, BDB_CONFIG_FILE, pool);
apr_file_t *dbcfg_file;
apr_status_t apr_err;
apr_finfo_t finfo;
SVN_ERR(svn_io_file_open(&dbcfg_file, dbcfg_file_name,
APR_READ, APR_OS_DEFAULT, pool));
apr_err = apr_file_info_get(&finfo, APR_FINFO_DEV | APR_FINFO_INODE,
dbcfg_file);
if (apr_err)
return svn_error_wrap_apr
(apr_err, "Can't create BDB environment cache key");
/* Make sure that any padding in the key is always cleared, so that
the key's hash deterministic. */
memset(keyp, 0, sizeof *keyp);
keyp->device = finfo.device;
keyp->inode = finfo.inode;
if (dbconfig_file)
*dbconfig_file = dbcfg_file;
else
apr_file_close(dbcfg_file);
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_drop_root(svn_wc__db_t *db,
const char *local_abspath,
apr_pool_t *scratch_pool)
{
svn_wc__db_wcroot_t *root_wcroot = svn_hash_gets(db->dir_data, local_abspath);
apr_hash_index_t *hi;
apr_status_t result;
if (!root_wcroot)
return SVN_NO_ERROR;
if (strcmp(root_wcroot->abspath, local_abspath) != 0)
return svn_error_createf(SVN_ERR_WC_NOT_WORKING_COPY, NULL,
_("'%s' is not a working copy root"),
svn_dirent_local_style(local_abspath,
scratch_pool));
for (hi = apr_hash_first(scratch_pool, db->dir_data);
hi;
hi = apr_hash_next(hi))
{
svn_wc__db_wcroot_t *wcroot = apr_hash_this_val(hi);
if (wcroot == root_wcroot)
svn_hash_sets(db->dir_data, apr_hash_this_key(hi), NULL);
}
result = apr_pool_cleanup_run(db->state_pool, root_wcroot, close_wcroot);
if (result != APR_SUCCESS)
return svn_error_wrap_apr(result, NULL);
return SVN_NO_ERROR;
}
/* Use the visual editor to edit files. This requires that the file name itself
be shell-safe, although the path to reach that file need not be shell-safe.
*/
svn_error_t *
svn_cl__edit_file_externally(const char *path,
const char *editor_cmd,
apr_hash_t *config,
apr_pool_t *pool)
{
const char *editor, *cmd, *base_dir, *file_name, *base_dir_apr;
char *old_cwd;
int sys_err;
apr_status_t apr_err;
svn_dirent_split(&base_dir, &file_name, path, pool);
SVN_ERR(find_editor_binary(&editor, editor_cmd, config));
apr_err = apr_filepath_get(&old_cwd, APR_FILEPATH_NATIVE, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, _("Can't get working directory"));
/* APR doesn't like "" directories */
if (base_dir[0] == '\0')
base_dir_apr = ".";
else
SVN_ERR(svn_path_cstring_from_utf8(&base_dir_apr, base_dir, pool));
apr_err = apr_filepath_set(base_dir_apr, pool);
if (apr_err)
return svn_error_wrap_apr
(apr_err, _("Can't change working directory to '%s'"), base_dir);
cmd = apr_psprintf(pool, "%s %s", editor, file_name);
sys_err = system(cmd);
apr_err = apr_filepath_set(old_cwd, pool);
if (apr_err)
svn_handle_error2(svn_error_wrap_apr
(apr_err, _("Can't restore working directory")),
stderr, TRUE /* fatal */, "svn: ");
if (sys_err)
/* Extracting any meaning from sys_err is platform specific, so just
use the raw value. */
return svn_error_createf(SVN_ERR_EXTERNAL_PROGRAM, NULL,
_("system('%s') returned %d"), cmd, sys_err);
return SVN_NO_ERROR;
}
svn_error_t *
svn_cache__make_memcache_from_config(svn_memcache_t **memcache_p,
svn_config_t *config,
apr_pool_t *pool)
{
int server_count;
apr_pool_t *subpool = svn_pool_create(pool);
server_count =
svn_config_enumerate2(config,
SVN_CACHE_CONFIG_CATEGORY_MEMCACHED_SERVERS,
nop_enumerator, NULL, subpool);
if (server_count == 0)
{
*memcache_p = NULL;
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
if (server_count > APR_INT16_MAX)
return svn_error_create(SVN_ERR_TOO_MANY_MEMCACHED_SERVERS, NULL, NULL);
#ifdef SVN_HAVE_MEMCACHE
{
struct ams_baton b;
svn_memcache_t *memcache = apr_pcalloc(pool, sizeof(*memcache));
apr_status_t apr_err = apr_memcache_create(pool,
(apr_uint16_t)server_count,
0, /* flags */
&(memcache->c));
if (apr_err != APR_SUCCESS)
return svn_error_wrap_apr(apr_err,
_("Unknown error creating apr_memcache_t"));
b.memcache = memcache->c;
b.memcache_pool = pool;
b.err = SVN_NO_ERROR;
svn_config_enumerate2(config,
SVN_CACHE_CONFIG_CATEGORY_MEMCACHED_SERVERS,
add_memcache_server, &b,
subpool);
if (b.err)
return b.err;
*memcache_p = memcache;
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
#else /* ! SVN_HAVE_MEMCACHE */
{
return svn_error_create(SVN_ERR_NO_APR_MEMCACHE, NULL, NULL);
}
#endif /* SVN_HAVE_MEMCACHE */
}
/* Implements svn_write_fn_t */
static svn_error_t *
file_write_cb(void *baton, const char *buffer, apr_size_t *len)
{
file_baton_t *b = baton;
apr_status_t status = apr_file_write(b->out_file, buffer, len);
if (status)
return svn_error_wrap_apr(status, _("Can't write to connection"));
return SVN_NO_ERROR;
}
/* Implements svn_write_fn_t */
static svn_error_t *
sock_write_cb(void *baton, const char *buffer, apr_size_t *len)
{
sock_baton_t *b = baton;
apr_status_t status = apr_socket_send(b->sock, buffer, len);
if (status)
return svn_error_wrap_apr(status, _("Can't write to connection"));
return SVN_NO_ERROR;
}
svn_error_t *
OperationContext::openTunnel(svn_stream_t **request, svn_stream_t **response,
svn_ra_close_tunnel_func_t *close_func,
void **close_baton,
void *tunnel_baton,
const char *tunnel_name, const char *user,
const char *hostname, int port,
svn_cancel_func_t cancel_func, void *cancel_baton,
apr_pool_t *pool)
{
TunnelContext *tc = new TunnelContext(pool);
if (tc->status)
{
delete tc;
return svn_error_trace(
svn_error_wrap_apr(tc->status, _("Could not open tunnel streams")));
}
*close_func = closeTunnel;
*close_baton = tc;
*request = svn_stream_from_aprfile2(tc->request_out, FALSE, pool);
*response = svn_stream_from_aprfile2(tc->response_in, FALSE, pool);
JNIEnv *env = JNIUtil::getEnv();
jobject jrequest = create_RequestChannel(env, tc->request_in);
SVN_JNI_CATCH(, SVN_ERR_BASE);
jobject jresponse = create_ResponseChannel(env, tc->response_out);
SVN_JNI_CATCH(, SVN_ERR_BASE);
jstring jtunnel_name = JNIUtil::makeJString(tunnel_name);
SVN_JNI_CATCH(, SVN_ERR_BASE);
jstring juser = JNIUtil::makeJString(user);
SVN_JNI_CATCH(, SVN_ERR_BASE);
jstring jhostname = JNIUtil::makeJString(hostname);
SVN_JNI_CATCH(, SVN_ERR_BASE);
static jmethodID mid = 0;
if (0 == mid)
{
jclass cls = env->FindClass(JAVAHL_CLASS("/callback/TunnelAgent"));
SVN_JNI_CATCH(, SVN_ERR_BASE);
SVN_JNI_CATCH(
mid = env->GetMethodID(
cls, "openTunnel",
"(Ljava/nio/channels/ReadableByteChannel;"
"Ljava/nio/channels/WritableByteChannel;"
"Ljava/lang/String;"
"Ljava/lang/String;"
"Ljava/lang/String;I)"
JAVAHL_ARG("/callback/TunnelAgent$CloseTunnelCallback;")),
SVN_ERR_BASE);
}
svn_error_t *
svn_sqlite__close(svn_sqlite__db_t *db)
{
apr_status_t result = apr_pool_cleanup_run(db->state_pool, db, close_apr);
if (result == APR_SUCCESS)
return SVN_NO_ERROR;
return svn_error_wrap_apr(result, NULL);
}
static svn_error_t *
release_fs_mutex(void)
{
#if APR_HAS_THREADS
apr_status_t status;
status = apr_thread_mutex_unlock(common_pool_lock);
if (status)
return svn_error_wrap_apr(status, _("Can't ungrab FS mutex"));
#endif
return SVN_NO_ERROR;
}
/* Implements svn_read_fn_t */
static svn_error_t *
file_read_cb(void *baton, char *buffer, apr_size_t *len)
{
file_baton_t *b = baton;
apr_status_t status = apr_file_read(b->in_file, buffer, len);
if (status && !APR_STATUS_IS_EOF(status))
return svn_error_wrap_apr(status, _("Can't read from connection"));
if (*len == 0)
return svn_error_create(SVN_ERR_RA_SVN_CONNECTION_CLOSED, NULL, NULL);
return SVN_NO_ERROR;
}
svn_error_t *
svn_stream_for_stderr(svn_stream_t **err, apr_pool_t *pool)
{
apr_file_t *stderr_file;
apr_status_t apr_err;
apr_err = apr_file_open_stderr(&stderr_file, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, "Can't open stderr");
*err = svn_stream_from_aprfile2(stderr_file, TRUE, pool);
return SVN_NO_ERROR;
}
/* Don't call this function directly! Use svn_atomic__init_once(). */
static svn_error_t *
crypto_init(void *baton, apr_pool_t *any_pool)
{
/* NOTE: this function will locate the topmost ancestor of ANY_POOL
for its cleanup handlers. We don't have to worry about ANY_POOL
being cleared. */
apr_status_t apr_err = apr_crypto_init(any_pool);
if (apr_err)
return svn_error_wrap_apr(apr_err,
_("Failed to initialize cryptography "
"subsystem"));
return SVN_NO_ERROR;
}
/* Set RAND_BYTES to a block of bytes containing random data RAND_LEN
long and allocated from RESULT_POOL. */
static svn_error_t *
get_random_bytes(const unsigned char **rand_bytes,
svn_crypto__ctx_t *ctx,
apr_size_t rand_len,
apr_pool_t *result_pool)
{
apr_status_t apr_err;
unsigned char *bytes;
bytes = apr_palloc(result_pool, rand_len);
apr_err = apr_generate_random_bytes(bytes, rand_len);
if (apr_err != APR_SUCCESS)
return svn_error_wrap_apr(apr_err, _("Error obtaining random data"));
*rand_bytes = bytes;
return SVN_NO_ERROR;
}
/* Wait for the next client connection to come in from SOCK. Allocate
* the connection in a root pool from CONNECTION_POOLS and assign PARAMS.
* Return the connection object in *CONNECTION.
*
* Use HANDLING_MODE for proper internal cleanup.
*/
static svn_error_t *
accept_connection(connection_t **connection,
apr_socket_t *sock,
serve_params_t *params,
enum connection_handling_mode handling_mode,
apr_pool_t *pool)
{
apr_status_t status;
/* Non-standard pool handling. The main thread never blocks to join
* the connection threads so it cannot clean up after each one. So
* separate pools that can be cleared at thread exit are used. */
apr_pool_t *connection_pool = svn_pool_create(pool);
*connection = apr_pcalloc(connection_pool, sizeof(**connection));
(*connection)->pool = connection_pool;
(*connection)->params = params;
(*connection)->ref_count = 1;
do
{
#ifdef WIN32
if (winservice_is_stopping())
exit(0);
#endif
status = apr_socket_accept(&(*connection)->usock, sock,
connection_pool);
if (handling_mode == connection_mode_fork)
{
apr_proc_t proc;
/* Collect any zombie child processes. */
while (apr_proc_wait_all_procs(&proc, NULL, NULL, APR_NOWAIT,
connection_pool) == APR_CHILD_DONE)
;
}
}
while (APR_STATUS_IS_EINTR(status)
|| APR_STATUS_IS_ECONNABORTED(status)
|| APR_STATUS_IS_ECONNRESET(status));
return status
? svn_error_wrap_apr(status, _("Can't accept client connection"))
: SVN_NO_ERROR;
}
static svn_error_t *
load_module(fs_init_func_t *initfunc, const char *name, apr_pool_t *pool)
{
*initfunc = NULL;
#if defined(SVN_USE_DSO) && APR_HAS_DSO
{
apr_dso_handle_t *dso;
apr_dso_handle_sym_t symbol;
const char *libname;
const char *funcname;
apr_status_t status;
const char *p;
/* Demand a simple alphanumeric name so that the generated DSO
name is sensible. */
for (p = name; *p; ++p)
if (!svn_ctype_isalnum(*p))
return svn_error_createf(SVN_ERR_FS_UNKNOWN_FS_TYPE, NULL,
_("Invalid name for FS type '%s'"),
name);
libname = apr_psprintf(pool, "libsvn_fs_%s-%d.so.%d",
name, SVN_VER_MAJOR, SVN_SOVERSION);
funcname = apr_psprintf(pool, "svn_fs_%s__init", name);
/* Find/load the specified library. If we get an error, assume
the library doesn't exist. The library will be unloaded when
pool is destroyed. */
SVN_ERR(svn_dso_load(&dso, libname));
if (! dso)
return SVN_NO_ERROR;
/* find the initialization routine */
status = apr_dso_sym(&symbol, dso, funcname);
if (status)
return svn_error_wrap_apr(status, _("'%s' does not define '%s()'"),
libname, funcname);
*initfunc = (fs_init_func_t) symbol;
}
#endif /* APR_HAS_DSO */
return SVN_NO_ERROR;
}
svn_error_t *
svn_delta__get_debug_editor(const svn_delta_editor_t **editor,
void **edit_baton,
const svn_delta_editor_t *wrapped_editor,
void *wrapped_edit_baton,
apr_pool_t *pool)
{
svn_delta_editor_t *tree_editor = svn_delta_default_editor(pool);
struct edit_baton *eb = apr_palloc(pool, sizeof(*eb));
apr_file_t *errfp;
svn_stream_t *out;
apr_status_t apr_err = apr_file_open_stderr(&errfp, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, "Problem opening stderr");
out = svn_stream_from_aprfile2(errfp, TRUE, pool);
tree_editor->set_target_revision = set_target_revision;
tree_editor->open_root = open_root;
tree_editor->delete_entry = delete_entry;
tree_editor->add_directory = add_directory;
tree_editor->open_directory = open_directory;
tree_editor->change_dir_prop = change_dir_prop;
tree_editor->close_directory = close_directory;
tree_editor->absent_directory = absent_directory;
tree_editor->add_file = add_file;
tree_editor->open_file = open_file;
tree_editor->apply_textdelta = apply_textdelta;
tree_editor->change_file_prop = change_file_prop;
tree_editor->close_file = close_file;
tree_editor->absent_file = absent_file;
tree_editor->close_edit = close_edit;
eb->wrapped_editor = wrapped_editor;
eb->wrapped_edit_baton = wrapped_edit_baton;
eb->out = out;
eb->indent_level = 0;
*editor = tree_editor;
*edit_baton = eb;
return SVN_NO_ERROR;
}
/* Core functionality of our getter functions: fetch DATA from the memcached
* given by CACHE_VOID and identified by KEY. Indicate success in FOUND and
* use a tempoary sub-pool of POOL for allocations.
*/
static svn_error_t *
memcache_internal_get(char **data,
apr_size_t *size,
svn_boolean_t *found,
void *cache_void,
const void *key,
apr_pool_t *pool)
{
memcache_t *cache = cache_void;
apr_status_t apr_err;
const char *mc_key;
apr_pool_t *subpool;
if (key == NULL)
{
*found = FALSE;
return SVN_NO_ERROR;
}
subpool = svn_pool_create(pool);
SVN_ERR(build_key(&mc_key, cache, key, subpool));
apr_err = apr_memcache_getp(cache->memcache,
pool,
mc_key,
data,
size,
NULL /* ignore flags */);
if (apr_err == APR_NOTFOUND)
{
*found = FALSE;
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
else if (apr_err != APR_SUCCESS || !*data)
return svn_error_wrap_apr(apr_err,
_("Unknown memcached error while reading"));
*found = TRUE;
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_wc__db_close_many_wcroots(apr_hash_t *roots,
apr_pool_t *state_pool,
apr_pool_t *scratch_pool)
{
apr_hash_index_t *hi;
for (hi = apr_hash_first(scratch_pool, roots); hi; hi = apr_hash_next(hi))
{
svn_wc__db_wcroot_t *wcroot = apr_hash_this_val(hi);
apr_status_t result;
result = apr_pool_cleanup_run(state_pool, wcroot, close_wcroot);
if (result != APR_SUCCESS)
return svn_error_wrap_apr(result, NULL);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_cl__error_checked_fputs(const char *string, FILE* stream)
{
/* On POSIX systems, errno will be set on an error in fputs, but this might
not be the case on other platforms. We reset errno and only
use it if it was set by the below fputs call. Else, we just return
a generic error. */
errno = 0;
if (fputs(string, stream) == EOF)
{
if (apr_get_os_error()) /* is errno on POSIX */
return svn_error_wrap_apr(apr_get_os_error(), _("Write error"));
else
return svn_error_create(SVN_ERR_IO_WRITE_ERROR, NULL, NULL);
}
return SVN_NO_ERROR;
}
/* send a response to the client for this baton */
static svn_error_t *
send_response(const dav_svn_repos *repos,
svn_fs_root_t *root,
const char *path,
svn_boolean_t is_dir,
ap_filter_t *output,
apr_bucket_brigade *bb,
apr_pool_t *pool)
{
const char *href;
const char *vsn_url;
apr_status_t status;
svn_revnum_t rev_to_use;
href = dav_svn__build_uri(repos, DAV_SVN__BUILD_URI_PUBLIC,
SVN_IGNORED_REVNUM, path, 0 /* add_href */, pool);
rev_to_use = dav_svn__get_safe_cr(root, path, pool);
vsn_url = dav_svn__build_uri(repos, DAV_SVN__BUILD_URI_VERSION,
rev_to_use, path, 0 /* add_href */, pool);
status = ap_fputstrs(output, bb,
"<D:response>" DEBUG_CR
"<D:href>",
apr_xml_quote_string(pool, href, 1),
"</D:href>" DEBUG_CR
"<D:propstat><D:prop>" DEBUG_CR,
is_dir
? "<D:resourcetype><D:collection/></D:resourcetype>"
: "<D:resourcetype/>",
DEBUG_CR,
"<D:checked-in><D:href>",
apr_xml_quote_string(pool, vsn_url, 1),
"</D:href></D:checked-in>" DEBUG_CR
"</D:prop>" DEBUG_CR
"<D:status>HTTP/1.1 200 OK</D:status>" DEBUG_CR
"</D:propstat>" DEBUG_CR
"</D:response>" DEBUG_CR,
NULL);
if (status != APR_SUCCESS)
return svn_error_wrap_apr(status, "Can't write response to output");
return SVN_NO_ERROR;
}
/* Generate a Subversion error which describes the state reflected by
APR_ERR and any crypto errors registered with CTX. */
static svn_error_t *
crypto_error_create(svn_crypto__ctx_t *ctx,
apr_status_t apr_err,
const char *msg)
{
const apu_err_t *apu_err;
apr_status_t rv = apr_crypto_error(&apu_err, ctx->crypto);
svn_error_t *child;
/* Ugh. The APIs are a bit slippery, so be wary. */
if (apr_err == APR_SUCCESS)
apr_err = APR_EGENERAL;
if (rv == APR_SUCCESS)
child = err_from_apu_err(apr_err, apu_err);
else
child = svn_error_wrap_apr(rv, _("Fetching error from APR"));
return svn_error_create(apr_err, child, msg);
}
/* Convert UTF8, a UTF-8 encoded string, to UCS2, a UCS-2 encoded
string, using POOL for temporary allocations. */
static svn_error_t *
utf8_to_ucs2(WCHAR **ucs2, const char *utf8, apr_pool_t *pool)
{
apr_size_t inbytes, outwords, outlength;
apr_status_t apr_err;
inbytes = lstrlenA(utf8);
outwords = outlength = inbytes + 1; /* Include terminating null. */
*ucs2 = apr_palloc(pool, outwords * sizeof(WCHAR));
apr_err = apr_conv_utf8_to_ucs2(utf8, &inbytes, *ucs2, &outwords);
if (!apr_err && (inbytes > 0 || outwords == 0))
apr_err = APR_INCOMPLETE;
if (apr_err)
return svn_error_wrap_apr(apr_err, "Can't convert config path to UCS-2");
/* Note that apr_conv_utf8_to_ucs2 does _not_ terminate the
outgoing buffer. */
(*ucs2)[outlength - outwords] = L'\0';
return SVN_NO_ERROR;
}
/* Core functionality of our setter functions: store LENGH bytes of DATA
* to be identified by KEY in the memcached given by CACHE_VOID. Use POOL
* for temporary allocations.
*/
static svn_error_t *
memcache_internal_set(void *cache_void,
const void *key,
const char *data,
apr_size_t len,
apr_pool_t *scratch_pool)
{
memcache_t *cache = cache_void;
const char *mc_key;
apr_status_t apr_err;
SVN_ERR(build_key(&mc_key, cache, key, scratch_pool));
apr_err = apr_memcache_set(cache->memcache, mc_key, (char *)data, len, 0, 0);
/* ### Maybe write failures should be ignored (but logged)? */
if (apr_err != APR_SUCCESS)
return svn_error_wrap_apr(apr_err,
_("Unknown memcached error while writing"));
return SVN_NO_ERROR;
}
static svn_error_t *initialize(void *baton, apr_pool_t *pool)
{
int result;
apr_status_t status;
status = svn_ra_svn__sasl_common_init(pool);
if (status)
return svn_error_wrap_apr(status,
_("Could not initialize the SASL library"));
/* The second parameter tells SASL to look for a configuration file
named subversion.conf. */
result = sasl_server_init(callbacks, SVN_RA_SVN_SASL_NAME);
if (result != SASL_OK)
{
svn_error_t *err = svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
sasl_errstring(result, NULL, NULL));
return svn_error_quick_wrap(err,
_("Could not initialize the SASL library"));
}
return SVN_NO_ERROR;
}
/*** Public interfaces. ***/
svn_error_t *
svn_ra__get_debug_reporter(const svn_ra_reporter3_t **reporter,
void **report_baton,
const svn_ra_reporter3_t *wrapped_reporter,
void *wrapped_report_baton,
apr_pool_t *pool)
{
svn_ra_reporter3_t *tree_reporter;
struct report_baton *rb;
apr_file_t *errfp;
svn_stream_t *out;
apr_status_t apr_err = apr_file_open_stderr(&errfp, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, "Problem opening stderr");
out = svn_stream_from_aprfile2(errfp, TRUE, pool);
/* ### svn_delta_default_editor() */
tree_reporter = apr_palloc(pool, sizeof(*tree_reporter));
rb = apr_palloc(pool, sizeof(*rb));
tree_reporter->set_path = set_path;
tree_reporter->delete_path = delete_path;
tree_reporter->link_path = link_path;
tree_reporter->finish_report = finish_report;
tree_reporter->abort_report = abort_report;
rb->wrapped_reporter = wrapped_reporter;
rb->wrapped_report_baton = wrapped_report_baton;
rb->out = out;
*reporter = tree_reporter;
*report_baton = rb;
return SVN_NO_ERROR;
}
