static void *mod_mapcache_merge_server_conf(apr_pool_t *p, void *base_, void *vhost_)
{
mapcache_server_cfg *base = (mapcache_server_cfg*)base_;
mapcache_server_cfg *vhost = (mapcache_server_cfg*)vhost_;
mapcache_server_cfg *cfg = apr_pcalloc(p,sizeof(mapcache_server_cfg));
if (base->aliases && vhost->aliases) {
cfg->aliases = apr_hash_overlay(p, vhost->aliases,base->aliases);
} else if (vhost->aliases) {
cfg->aliases = apr_hash_copy(p,vhost->aliases);
} else if (base->aliases) {
cfg->aliases = apr_hash_copy(p,base->aliases);
}
return vhost;
}
static void *compile_merge_config(apr_pool_t *pool, void *config1, void *config2) {
compile_config_t *base = (compile_config_t*) config1;
compile_config_t *overrides = (compile_config_t*) config2;
compile_config_t *config;
config = (compile_config_t*) apr_pcalloc(pool, sizeof (compile_config_t));
COMPILE_MERGE_FLAG(enabled);
COMPILE_MERGE_FLAG(use_path_info);
if (base->extension_commands && overrides->extension_commands) {
config->extension_commands = apr_hash_merge(pool, overrides->extension_commands, base->extension_commands, compile_overlay_extension_commands, NULL);
} else {
if (base->extension_commands == NULL) {
config->extension_commands = overrides->extension_commands;
} else {
config->extension_commands = base->extension_commands;
}
if (config->extension_commands && overrides->removed_commands) {
config->extension_commands = apr_hash_copy(pool, config->extension_commands);
}
}
if (config->extension_commands) {
if (overrides->removed_commands) {
compile_remove_extension_commands(pool, overrides->removed_commands, config->extension_commands);
}
}
config->removed_commands = NULL;
return (void*) config;
}
apr_hash_t *
svn_fs_config(svn_fs_t *fs, apr_pool_t *pool)
{
if (fs->config)
return apr_hash_copy(pool, fs->config);
return NULL;
}
apr_hash_t *
svn_prop__patch(const apr_hash_t *original_props,
const apr_array_header_t *prop_changes,
apr_pool_t *pool)
{
apr_hash_t *props = apr_hash_copy(pool, original_props);
int i;
for (i = 0; i < prop_changes->nelts; i++)
{
const svn_prop_t *p = &APR_ARRAY_IDX(prop_changes, i, svn_prop_t);
svn_hash_sets(props, p->name, p->value);
}
return props;
}
service_manager_t *clone_service_manager(service_manager_t *sm)
{
apr_ssize_t klen;
service_manager_t *clone;
apr_hash_index_t *his;
apr_hash_t *section, *clone_section;
char *key;
//** Make an empty SM
clone = create_service_manager(sm);
//** Now cycle through all the tables and copy them
apr_thread_mutex_lock(sm->lock);
for (his = apr_hash_first(NULL, sm->table); his != NULL; his = apr_hash_next(his)) {
apr_hash_this(his, (const void **)&key, &klen, (void **)§ion);
clone_section = apr_hash_copy(clone->pool, section);
apr_hash_set(clone->table, apr_pstrdup(clone->pool, key), APR_HASH_KEY_STRING, clone_section);
}
apr_thread_mutex_unlock(sm->lock);
return(clone);
}
static svn_error_t *
svn_ra_local__get_commit_editor(svn_ra_session_t *session,
const svn_delta_editor_t **editor,
void **edit_baton,
apr_hash_t *revprop_table,
svn_commit_callback2_t callback,
void *callback_baton,
apr_hash_t *lock_tokens,
svn_boolean_t keep_locks,
apr_pool_t *pool)
{
svn_ra_local__session_baton_t *sess = session->priv;
struct deltify_etc_baton *db = apr_palloc(pool, sizeof(*db));
apr_hash_index_t *hi;
svn_fs_access_t *fs_access;
db->fs = sess->fs;
db->repos = sess->repos;
db->fs_path = sess->fs_path->data;
if (! keep_locks)
db->lock_tokens = lock_tokens;
else
db->lock_tokens = NULL;
db->pool = pool;
db->callback = callback;
db->callback_baton = callback_baton;
SVN_ERR(get_username(session, pool));
/* If there are lock tokens to add, do so. */
if (lock_tokens)
{
SVN_ERR(svn_fs_get_access(&fs_access, sess->fs));
/* If there is no access context, the filesystem will scream if a
lock is needed. */
if (fs_access)
{
for (hi = apr_hash_first(pool, lock_tokens); hi;
hi = apr_hash_next(hi))
{
void *val;
const char *path, *token;
const void *key;
apr_hash_this(hi, &key, NULL, &val);
path = svn_path_join(sess->fs_path->data, (const char *)key,
pool);
token = val;
SVN_ERR(svn_fs_access_add_lock_token2(fs_access, path, token));
}
}
}
/* Copy the revprops table so we can add the username. */
revprop_table = apr_hash_copy(pool, revprop_table);
apr_hash_set(revprop_table, SVN_PROP_REVISION_AUTHOR, APR_HASH_KEY_STRING,
svn_string_create(sess->username, pool));
/* Get the repos commit-editor */
return svn_repos_get_commit_editor5
(editor, edit_baton, sess->repos, NULL,
svn_path_uri_decode(sess->repos_url, pool), sess->fs_path->data,
revprop_table, deltify_etc, db, NULL, NULL, pool);
}
/* Implements svn_ra__vtable_t.dup_session */
static svn_error_t *
ra_serf_dup_session(svn_ra_session_t *new_session,
svn_ra_session_t *old_session,
const char *new_session_url,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_ra_serf__session_t *old_sess = old_session->priv;
svn_ra_serf__session_t *new_sess;
apr_status_t status;
new_sess = apr_pmemdup(result_pool, old_sess, sizeof(*new_sess));
new_sess->pool = result_pool;
if (new_sess->config)
SVN_ERR(svn_config_copy_config(&new_sess->config, new_sess->config,
result_pool));
/* max_connections */
/* using_ssl */
/* using_compression */
/* http10 */
/* using_chunked_requests */
/* detect_chunking */
if (new_sess->useragent)
new_sess->useragent = apr_pstrdup(result_pool, new_sess->useragent);
if (new_sess->vcc_url)
new_sess->vcc_url = apr_pstrdup(result_pool, new_sess->vcc_url);
new_sess->auth_state = NULL;
new_sess->auth_attempts = 0;
/* Callback functions to get info from WC */
/* wc_callbacks */
/* wc_callback_baton */
/* progress_func */
/* progress_baton */
/* cancel_func */
/* cancel_baton */
/* shim_callbacks */
new_sess->pending_error = NULL;
/* authn_types */
/* Keys and values are static */
if (new_sess->capabilities)
new_sess->capabilities = apr_hash_copy(result_pool, new_sess->capabilities);
if (new_sess->activity_collection_url)
{
new_sess->activity_collection_url
= apr_pstrdup(result_pool, new_sess->activity_collection_url);
}
/* using_proxy */
if (new_sess->proxy_username)
{
new_sess->proxy_username
= apr_pstrdup(result_pool, new_sess->proxy_username);
}
if (new_sess->proxy_password)
{
new_sess->proxy_username
= apr_pstrdup(result_pool, new_sess->proxy_password);
}
new_sess->proxy_auth_attempts = 0;
/* trust_default_ca */
if (new_sess->ssl_authorities)
{
new_sess->ssl_authorities = apr_pstrdup(result_pool,
new_sess->ssl_authorities);
}
if (new_sess->uuid)
new_sess->uuid = apr_pstrdup(result_pool, new_sess->uuid);
/* timeout */
/* supports_deadprop_count */
if (new_sess->me_resource)
new_sess->me_resource = apr_pstrdup(result_pool, new_sess->me_resource);
if (new_sess->rev_stub)
new_sess->rev_stub = apr_pstrdup(result_pool, new_sess->rev_stub);
if (new_sess->txn_stub)
new_sess->txn_stub = apr_pstrdup(result_pool, new_sess->txn_stub);
if (new_sess->txn_root_stub)
new_sess->txn_root_stub = apr_pstrdup(result_pool,
new_sess->txn_root_stub);
if (new_sess->vtxn_stub)
new_sess->vtxn_stub = apr_pstrdup(result_pool, new_sess->vtxn_stub);
if (new_sess->vtxn_root_stub)
new_sess->vtxn_root_stub = apr_pstrdup(result_pool,
new_sess->vtxn_root_stub);
/* Keys and values are static */
if (new_sess->supported_posts)
new_sess->supported_posts = apr_hash_copy(result_pool,
new_sess->supported_posts);
/* ### Can we copy this? */
SVN_ERR(svn_ra_serf__blncache_create(&new_sess->blncache,
new_sess->pool));
if (new_sess->server_allows_bulk)
new_sess->server_allows_bulk = apr_pstrdup(result_pool,
new_sess->server_allows_bulk);
new_sess->repos_root_str = apr_pstrdup(result_pool,
new_sess->repos_root_str);
SVN_ERR(svn_ra_serf__uri_parse(&new_sess->repos_root,
new_sess->repos_root_str,
result_pool));
new_sess->session_url_str = apr_pstrdup(result_pool, new_session_url);
SVN_ERR(svn_ra_serf__uri_parse(&new_sess->session_url,
new_sess->session_url_str,
result_pool));
/* svn_boolean_t supports_inline_props */
/* supports_rev_rsrc_replay */
new_sess->context = serf_context_create(result_pool);
SVN_ERR(load_config(new_sess, old_sess->config, result_pool));
new_sess->conns[0] = apr_pcalloc(result_pool,
sizeof(*new_sess->conns[0]));
new_sess->conns[0]->bkt_alloc =
serf_bucket_allocator_create(result_pool, NULL, NULL);
new_sess->conns[0]->session = new_sess;
new_sess->conns[0]->last_status_code = -1;
/* go ahead and tell serf about the connection. */
status =
serf_connection_create2(&new_sess->conns[0]->conn,
new_sess->context,
new_sess->session_url,
svn_ra_serf__conn_setup, new_sess->conns[0],
svn_ra_serf__conn_closed, new_sess->conns[0],
result_pool);
if (status)
return svn_ra_serf__wrap_err(status, NULL);
/* Set the progress callback. */
serf_context_set_progress_cb(new_sess->context, svn_ra_serf__progress,
new_sess);
new_sess->num_conns = 1;
new_sess->cur_conn = 0;
new_session->priv = new_sess;
return SVN_NO_ERROR;
}