/* Iterate through CFG, passing BATON to CALLBACK for every (SECTION, OPTION) pair. Stop if CALLBACK returns TRUE. Allocate from POOL. */ static void for_each_option(svn_config_t *cfg, void *baton, apr_pool_t *pool, svn_boolean_t callback(void *same_baton, cfg_section_t *section, cfg_option_t *option)) { apr_hash_index_t *sec_ndx; for (sec_ndx = apr_hash_first(pool, cfg->sections); sec_ndx != NULL; sec_ndx = apr_hash_next(sec_ndx)) { void *sec_ptr; cfg_section_t *sec; apr_hash_index_t *opt_ndx; apr_hash_this(sec_ndx, NULL, NULL, &sec_ptr); sec = sec_ptr; for (opt_ndx = apr_hash_first(pool, sec->options); opt_ndx != NULL; opt_ndx = apr_hash_next(opt_ndx)) { void *opt_ptr; cfg_option_t *opt; apr_hash_this(opt_ndx, NULL, NULL, &opt_ptr); opt = opt_ptr; if (callback(baton, sec, opt)) return; } } }
static void mrcp_server_on_terminate_complete(apt_task_t *task) { apt_consumer_task_t *consumer_task = apt_task_object_get(task); mrcp_server_t *server = apt_consumer_task_object_get(consumer_task); mrcp_resource_engine_t *resource_engine; apr_dso_handle_t *plugin; apr_hash_index_t *it; void *val; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Close Resource Engines"); it=apr_hash_first(server->pool,server->resource_engine_table); for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&val); resource_engine = val; if(resource_engine) { mrcp_resource_engine_close(resource_engine); } } apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Unload Plugins"); it=apr_hash_first(server->pool,server->plugin_table); for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&val); plugin = val; if(plugin) { apr_dso_unload(plugin); } } apt_log(APT_LOG_MARK,APT_PRIO_INFO,"On Server Task Terminate"); }
svn_error_t * svn_config_dup(svn_config_t **cfgp, const svn_config_t *src, apr_pool_t *pool) { apr_hash_index_t *sectidx; apr_hash_index_t *optidx; *cfgp = 0; SVN_ERR(svn_config_create2(cfgp, FALSE, FALSE, pool)); (*cfgp)->x_values = src->x_values; (*cfgp)->section_names_case_sensitive = src->section_names_case_sensitive; (*cfgp)->option_names_case_sensitive = src->option_names_case_sensitive; for (sectidx = apr_hash_first(pool, src->sections); sectidx != NULL; sectidx = apr_hash_next(sectidx)) { const void *sectkey; void *sectval; apr_ssize_t sectkeyLength; cfg_section_t * srcsect; cfg_section_t * destsec; apr_hash_this(sectidx, §key, §keyLength, §val); srcsect = sectval; destsec = svn_config_addsection(*cfgp, srcsect->name); for (optidx = apr_hash_first(pool, srcsect->options); optidx != NULL; optidx = apr_hash_next(optidx)) { const void *optkey; void *optval; apr_ssize_t optkeyLength; cfg_option_t *srcopt; cfg_option_t *destopt; apr_hash_this(optidx, &optkey, &optkeyLength, &optval); srcopt = optval; svn_config_create_option(&destopt, srcopt->name, srcopt->value, (*cfgp)->option_names_case_sensitive, pool); destopt->value = apr_pstrdup(pool, srcopt->value); destopt->x_value = apr_pstrdup(pool, srcopt->x_value); destopt->expanded = srcopt->expanded; apr_hash_set(destsec->options, apr_pstrdup(pool, (const char*)optkey), optkeyLength, destopt); } } return SVN_NO_ERROR; }
/** * Initialise the encryption as per the current config. * * Returns APR_SUCCESS if successful. */ static apr_status_t crypt_init(request_rec *r, const apr_crypto_t *f, apr_crypto_block_key_type_e **cipher, session_crypto_dir_conf * dconf) { apr_status_t res; apr_hash_t *ciphers; res = apr_crypto_get_block_key_types(&ciphers, f); if (APR_SUCCESS != res) { ap_log_rerror(APLOG_MARK, APLOG_ERR, res, r, APLOGNO(01823) "no ciphers returned by APR. " "session encryption not possible"); return res; } *cipher = apr_hash_get(ciphers, dconf->cipher, APR_HASH_KEY_STRING); if (!(*cipher)) { apr_hash_index_t *hi; const void *key; apr_ssize_t klen; int sum = 0; int offset = 0; char *options = NULL; for (hi = apr_hash_first(r->pool, ciphers); hi; hi = apr_hash_next(hi)) { apr_hash_this(hi, NULL, &klen, NULL); sum += klen + 2; } for (hi = apr_hash_first(r->pool, ciphers); hi; hi = apr_hash_next(hi)) { apr_hash_this(hi, &key, &klen, NULL); if (!options) { options = apr_palloc(r->pool, sum + 1); } else { options[offset++] = ','; options[offset++] = ' '; } strncpy(options + offset, key, klen); offset += klen; } options[offset] = 0; ap_log_rerror(APLOG_MARK, APLOG_ERR, res, r, APLOGNO(01824) "cipher '%s' not recognised by crypto driver. " "session encryption not possible, options: %s", dconf->cipher, options); return APR_EGENERAL; } return APR_SUCCESS; }
/** Get available profiles */ MRCP_DECLARE(apt_bool_t) mrcp_client_profiles_get(const mrcp_client_t *client, mrcp_profile_t *profiles[], apr_size_t *count, const char *tag) { apr_hash_index_t *it; void *val; mrcp_profile_t *profile; apr_size_t i = 0; apt_bool_t status = TRUE; if(!profiles || !count) { return FALSE; } for(it = apr_hash_first(client->pool, client->profile_table); it; it = apr_hash_next(it)) { apr_hash_this(it, NULL, NULL, &val); if(!val) continue; if(i >= *count) { status = FALSE; break; } profile = val; if(!tag || (profile->tag && strcasecmp(tag,profile->tag) == 0)) { profiles[i] = profile; i++; } } *count = i; return status; }
/** Close connection */ static apt_bool_t rtsp_server_connection_close(rtsp_server_t *server, rtsp_server_connection_t *rtsp_connection) { apr_size_t remaining_sessions = 0; if(!rtsp_connection || !rtsp_connection->sock) { return FALSE; } apt_log(RTSP_LOG_MARK,APT_PRIO_INFO,"Close RTSP Connection %s",rtsp_connection->id); apt_poller_task_descriptor_remove(server->task,&rtsp_connection->sock_pfd); apr_socket_close(rtsp_connection->sock); rtsp_connection->sock = NULL; APR_RING_REMOVE(rtsp_connection,link); remaining_sessions = apr_hash_count(rtsp_connection->session_table); if(remaining_sessions) { rtsp_server_session_t *session; void *val; apr_hash_index_t *it; apt_log(RTSP_LOG_MARK,APT_PRIO_NOTICE,"Terminate Remaining RTSP Sessions [%"APR_SIZE_T_FMT"]", remaining_sessions); it = apr_hash_first(rtsp_connection->pool,rtsp_connection->session_table); for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&val); session = val; if(session && session->terminating == FALSE) { rtsp_server_session_terminate_request(server,session); } } } else { rtsp_server_connection_destroy(rtsp_connection); } return TRUE; }
apr_status_t lottery_stone_assembler( apr_hash_t * res_subhash, apr_pool_t * res_pool) { apr_status_t rv = 0; apr_hash_index_t * hi = NULL; apr_hash_t * group_hash = NULL; apr_int32_t * group_id = NULL; apr_ssize_t group_id_len = 0; lottery_stone_prob_hash = apr_hash_make(res_pool); // 遍历整个哈希表,为每个抽奖组建立快速ROLL值表 for (hi = apr_hash_first(NULL, res_subhash); hi != NULL; hi = apr_hash_next(hi)) { group_hash = NULL; apr_hash_this(hi, (const void **)&group_id, &group_id_len, (void **)&group_hash); if (group_hash != NULL) { lottery_stone_group_assembler( *group_id, group_hash, lottery_stone_prob_hash, res_pool); } } return APR_SUCCESS; }
static int mapcache_hook_intercept(request_rec *r) { mapcache_server_cfg *sconfig = ap_get_module_config(r->server->module_config, &mapcache_module); apr_hash_index_t *entry; if (!sconfig->aliases) return DECLINED; if (r->uri[0] != '/' && r->uri[0]) return DECLINED; entry = apr_hash_first(r->pool,sconfig->aliases); /* loop through the entries to find one where the alias matches */ while (entry) { int l = 0; const char *alias; apr_ssize_t aliaslen; mapcache_cfg *c; apr_hash_this(entry,(const void**)&alias,&aliaslen,(void**)&c); if((l=mapcache_alias_matches(r->uri, c->endpoint))>0) { r->handler = "mapcache"; r->filename = c->configFile; r->path_info = &(r->uri[l]); return OK; } entry = apr_hash_next(entry); } return DECLINED; }
static void mrcp_client_on_start_complete(apt_task_t *task) { apt_consumer_task_t *consumer_task = apt_task_object_get(task); mrcp_client_t *client = apt_consumer_task_object_get(consumer_task); void *val; mrcp_application_t *application; mrcp_app_message_t *app_message; apr_hash_index_t *it; apt_log(APT_PRIO_INFO,"On Client Task Start"); it = apr_hash_first(client->pool,client->app_table); for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&val); application = val; if(!application) continue; /* raise one-time ready event */ app_message = apr_palloc(client->pool,sizeof(mrcp_app_message_t)); app_message->message_type = MRCP_APP_MESSAGE_TYPE_SIGNALING; app_message->sig_message.message_type = MRCP_SIG_MESSAGE_TYPE_EVENT; app_message->sig_message.event_id = MRCP_SIG_EVENT_READY; app_message->sig_message.status = MRCP_SIG_STATUS_CODE_SUCCESS; app_message->application = application; application->handler(app_message); } }
char* cfgm_serializeMessage(apr_pool_t* p, cfgm_wire_message* msg){ apr_hash_index_t *hi; char* name=NULL,*value=NULL; char* ret=NULL; apr_pool_t* subp=NULL; if(msg==NULL) return NULL; if(apr_pool_create(&subp,p)!=APR_SUCCESS){ return NULL; } ret=apr_pstrcat(subp,"<message type=\"",msg->type,"\"",NULL); if(msg->header!=NULL){ if(msg->header->nodeName!=NULL){ ret=apr_pstrcat(subp,ret," node=\"",msg->header->nodeName,"\"",NULL); } if(msg->header->componentId!=NULL){ ret=apr_pstrcat(subp,ret," com=\"",msg->header->componentId,"\"",NULL); } if(msg->header->version!=NULL){ ret=apr_pstrcat(subp,ret," ver=\"",msg->header->version,"\"",NULL); } } ret=apr_pstrcat(subp,ret,">\n",NULL); for (hi = apr_hash_first(subp, msg->params); hi; hi = apr_hash_next(hi)) { apr_hash_this(hi,(const void**)&name, NULL, (void**)&value); ret=apr_pstrcat(subp,ret,"\t<param name=\"",name,"\"><![CDATA[",value,"]]></param>\n",NULL); } //make last concat to non temporary memory pool ret=apr_pstrcat(p,ret,"</message>",NULL); //destroy temporary memeory pool apr_pool_destroy(subp); return ret; }
int svn_config_enumerate(svn_config_t *cfg, const char *section, svn_config_enumerator_t callback, void *baton) { cfg_section_t *sec; apr_hash_index_t *opt_ndx; int count; apr_pool_t *subpool; find_option(cfg, section, NULL, &sec); if (sec == NULL) return 0; subpool = svn_pool_create(cfg->pool); count = 0; for (opt_ndx = apr_hash_first(subpool, sec->options); opt_ndx != NULL; opt_ndx = apr_hash_next(opt_ndx)) { void *opt_ptr; cfg_option_t *opt; const char *temp_value; apr_hash_this(opt_ndx, NULL, NULL, &opt_ptr); opt = opt_ptr; ++count; make_string_from_option(&temp_value, cfg, sec, opt, NULL); if (!callback(opt->name, temp_value, baton)) break; } svn_pool_destroy(subpool); return count; }
cst_voice* flite_voices_best_match_get(flite_voices_t *voices, mrcp_message_t *message) { cst_voice *voice = NULL; const char *voice_name = NULL; mrcp_synth_header_t *synth_header = mrcp_resource_header_get(message); if(synth_header) { if(mrcp_resource_header_property_check(message,SYNTHESIZER_HEADER_VOICE_NAME) == TRUE) { voice_name = synth_header->voice_param.name.buf; } } if(voice_name) { /* get voice by name */ flite_voice_t *flite_voice; flite_voice = apr_hash_get(voices->table,voice_name,APR_HASH_KEY_STRING); if(flite_voice) { voice = flite_voice->self; } } if(!voice) { /* still no voice found, get the default one */ flite_voice_t *flite_voice = NULL; void *val; apr_hash_index_t *it = apr_hash_first(voices->pool,voices->table); apr_hash_this(it,NULL,NULL,&val); if(val) { flite_voice = val; voice = flite_voice->self; } } return voice; }
void *svn__apr_hash_index_val(const apr_hash_index_t *hi) { void *val; apr_hash_this((apr_hash_index_t *)hi, NULL, NULL, &val); return val; }
apr_ssize_t svn__apr_hash_index_klen(const apr_hash_index_t *hi) { apr_ssize_t klen; apr_hash_this((apr_hash_index_t *)hi, NULL, &klen, NULL); return klen; }
const void *svn__apr_hash_index_key(const apr_hash_index_t *hi) { const void *key; apr_hash_this((apr_hash_index_t *)hi, &key, NULL, NULL); return key; }
/* Return all rev (and packed rev) files sorted by revision number. * Allocate the result in POOL. */ static apr_array_header_t * get_rev_files(apr_pool_t *pool) { apr_hash_index_t *hi; apr_array_header_t *result = apr_array_make(pool, apr_hash_count(files), sizeof(file_stats_t *)); /* select all files that have a rev number */ for (hi = apr_hash_first(pool, files); hi; hi = apr_hash_next(hi)) { const char *name = NULL; apr_ssize_t len = 0; file_stats_t *file = NULL; apr_hash_this(hi, (const void **)&name, &len, (void**)&file); if (file->rev_num >= 0) APR_ARRAY_PUSH(result, file_stats_t *) = file; } /* sort them */ qsort(result->elts, result->nelts, result->elt_size, (int (*)(const void *, const void *))compare_files); /* return the result */ return result; }
void nx_config_cache_free() { nx_ctx_t *ctx; nx_cc_item_t *item = NULL; apr_hash_index_t *idx; const char *key; apr_ssize_t keylen; ctx = nx_ctx_get(); CHECKERR(apr_thread_mutex_lock(ctx->config_cache_mutex)); for ( idx = apr_hash_first(NULL, ctx->config_cache); idx != NULL; idx = apr_hash_next(idx) ) { apr_hash_this(idx, (const void **) &key, &keylen, (void **) &item); apr_hash_set(ctx->config_cache, item->key, APR_HASH_KEY_STRING, NULL); _free_item(item); } if ( ctx->ccfile != NULL ) { apr_file_close(ctx->ccfile); ctx->ccfile = NULL; } CHECKERR(apr_thread_mutex_unlock(ctx->config_cache_mutex)); }
int svn_config_enumerate_sections(svn_config_t *cfg, svn_config_section_enumerator_t callback, void *baton) { apr_hash_index_t *sec_ndx; int count = 0; apr_pool_t *subpool = svn_pool_create(cfg->x_pool); for (sec_ndx = apr_hash_first(subpool, cfg->sections); sec_ndx != NULL; sec_ndx = apr_hash_next(sec_ndx)) { void *sec_ptr; cfg_section_t *sec; apr_hash_this(sec_ndx, NULL, NULL, &sec_ptr); sec = sec_ptr; ++count; if (!callback(sec->name, baton)) break; } svn_pool_destroy(subpool); return count; }
int svn_config_enumerate_sections2(svn_config_t *cfg, svn_config_section_enumerator2_t callback, void *baton, apr_pool_t *pool) { apr_hash_index_t *sec_ndx; apr_pool_t *iteration_pool; int count = 0; iteration_pool = svn_pool_create(pool); for (sec_ndx = apr_hash_first(pool, cfg->sections); sec_ndx != NULL; sec_ndx = apr_hash_next(sec_ndx)) { void *sec_ptr; cfg_section_t *sec; apr_hash_this(sec_ndx, NULL, NULL, &sec_ptr); sec = sec_ptr; ++count; svn_pool_clear(iteration_pool); if (!callback(sec->name, baton, iteration_pool)) break; } svn_pool_destroy(iteration_pool); return count; }
flite_voices_t* flite_voices_load(apr_pool_t *pool) { flite_voice_t *voice; apr_hash_index_t *it; void *val; flite_voices_t *voices = apr_palloc(pool,sizeof(flite_voices_t)); voices->pool = pool; voices->table = apr_hash_make(pool); /* init voices */ flite_voices_init(voices,pool); /* register voices */ it = apr_hash_first(pool,voices->table); /* walk through the voices and register them */ for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&val); voice = val; if(voice) { voice->self = voice->register_voice(); } } return voices; }
/** * Flushes the cache. * The cache can still be used as normal after a flush. */ void auth_vas_cache_flush(auth_vas_cache *cache) { apr_hash_index_t *index; for (index = apr_hash_first(cache->pool, cache->table); index; index = apr_hash_next(index)) { const void *key; apr_ssize_t keylength; auth_vas_cache_item *item; /* We know the key is a string, but we might as well just keep this * generic and use whatever the hash table says the key length is. */ apr_hash_this(index, &key, &keylength, (void**)&item); /* Remove item from cache */ apr_hash_set(cache->table, key, keylength, NULL); /* Remove the cache's reference to the item */ if (cache->unref_item_cb) cache->unref_item_cb(item->item); free(item); } cache->youngest = NULL; cache->oldest = NULL; /* APR 1.2 doesn't allow us to destroy cache->pool. * If we do, it tries to destroy it again later and crashes. */ }
static void get_name(dav_db *db, dav_prop_name *pname) { if (db->hi == NULL) { pname->ns = pname->name = NULL; } else { const void *name; apr_hash_this(db->hi, &name, NULL, NULL); #define PREFIX_LEN (sizeof(SVN_PROP_PREFIX) - 1) if (strncmp(name, SVN_PROP_PREFIX, PREFIX_LEN) == 0) #undef PREFIX_LEN { pname->ns = SVN_DAV_PROP_NS_SVN; pname->name = (const char *)name + 4; } else { pname->ns = SVN_DAV_PROP_NS_CUSTOM; pname->name = name; } } }
CContentInstance* CContentFieldSvnPresentProps::getInstance(const char* pchPath) { CSvnPool oPool; apr_hash_t* pProps = getParent().getPropsForPath(pchPath, oPool); if (!pProps) { return new CContentInstanceEmpty(*this, pchPath); } svn_stringbuf_t* pBuf = svn_stringbuf_create("", oPool); svn_stringbuf_ensure(pBuf, apr_hash_count(pProps) * 16); for (apr_hash_index_t* pIdx = apr_hash_first(oPool, pProps); pIdx; pIdx = apr_hash_next(pIdx)) { const char* pchPropName; int iSize = 0; apr_hash_this(pIdx, reinterpret_cast<const void**>(&pchPropName), &iSize, NULL); svn_stringbuf_appendcstr(pBuf, pchPropName); svn_stringbuf_appendcstr(pBuf, " "); } svn_stringbuf_chop(pBuf, 1); return new CContentInstanceString(*this, pchPath, pBuf->data, pBuf->len); }
std::string Property::getValue(const char * name) { Pool pool; Revision revision; apr_hash_t *props; svn_client_propget(&props, name, m_path.c_str(), revision, false, // recurse *m_context, pool); apr_hash_index_t *hi; hi = apr_hash_first(pool, props); if (!hi) { return ""; } const void *key; void *val; const svn_string_t *propval; apr_hash_this(hi, &key, NULL, &val); propval = (const svn_string_t *)val; return propval->data; }
/* ### FIXME: Consider somehow sharing code with ### libsvn_repos/load-fs-vtable.c:prefix_mergeinfo_paths() */ static svn_error_t * prefix_mergeinfo_paths(svn_string_t **mergeinfo_val, const svn_string_t *mergeinfo_orig, const char *parent_dir, apr_pool_t *pool) { apr_hash_t *prefixed_mergeinfo, *mergeinfo; apr_hash_index_t *hi; void *rangelist; SVN_ERR(svn_mergeinfo_parse(&mergeinfo, mergeinfo_orig->data, pool)); prefixed_mergeinfo = apr_hash_make(pool); for (hi = apr_hash_first(pool, mergeinfo); hi; hi = apr_hash_next(hi)) { const void *key; const char *path, *merge_source; apr_hash_this(hi, &key, NULL, &rangelist); merge_source = svn_relpath_canonicalize(key, pool); /* The svn:mergeinfo property syntax demands a repos abspath */ path = svn_fspath__canonicalize(svn_relpath_join(parent_dir, merge_source, pool), pool); svn_hash_sets(prefixed_mergeinfo, path, rangelist); } return svn_mergeinfo_to_string(mergeinfo_val, prefixed_mergeinfo, pool); }
/* Set *HANDLE to an open filehandle for a temporary file (i.e., automatically deleted when closed), into which the LOCK_TOKENS have been written out in the format described in the pre-commit hook template. LOCK_TOKENS is as returned by svn_fs__access_get_lock_tokens(). Allocate *HANDLE in POOL, and use POOL for temporary allocations. */ static svn_error_t * lock_token_content(apr_file_t **handle, apr_hash_t *lock_tokens, apr_pool_t *pool) { svn_stringbuf_t *lock_str = svn_stringbuf_create("LOCK-TOKENS:\n", pool); apr_hash_index_t *hi; for (hi = apr_hash_first(pool, lock_tokens); hi; hi = apr_hash_next(hi)) { void *val; const char *path, *token; apr_hash_this(hi, (void *)&token, NULL, &val); path = val; svn_stringbuf_appendstr(lock_str, svn_stringbuf_createf(pool, "%s|%s\n", svn_path_uri_autoescape(path, pool), token)); } svn_stringbuf_appendcstr(lock_str, "\n"); return create_temp_file(handle, svn_stringbuf__morph_into_string(lock_str), pool); }
/** * \private \memberof mapcache_cache_sqlite */ static void _mapcache_cache_mbtiles_configuration_post_config(mapcache_context *ctx, mapcache_cache *cache, mapcache_cfg *cfg) { /* check that only one tileset/grid references this cache, as mbtiles does not support multiple tilesets/grids per cache */ int nrefs = 0; apr_hash_index_t *tileseti = apr_hash_first(ctx->pool,cfg->tilesets); while(tileseti) { mapcache_tileset *tileset; const void *key; apr_ssize_t keylen; apr_hash_this(tileseti,&key,&keylen,(void**)&tileset); if(tileset->cache == cache) { nrefs++; if(nrefs>1) { ctx->set_error(ctx,500,"mbtiles cache %s is referenced by more than 1 tileset, which is not supported",cache->name); return; } if(tileset->grid_links->nelts > 1) { ctx->set_error(ctx,500,"mbtiles cache %s is referenced by tileset %s which has more than 1 grid, which is not supported",cache->name,tileset->name); return; } } tileseti = apr_hash_next(tileseti); } }
static svn_error_t * close_directory(void *dir_baton, apr_pool_t *pool) { struct dir_baton *db = dir_baton; struct edit_baton *eb = db->edit_baton; apr_hash_index_t *hi; apr_pool_t *subpool = svn_pool_create(pool); for (hi = apr_hash_first(pool, db->deleted_entries); hi; hi = apr_hash_next(hi)) { const void *key; const char *path; apr_hash_this(hi, &key, NULL, NULL); path = key; svn_pool_clear(subpool); /* By sending 'svn_node_unknown', the Node-kind: header simply won't be written out. No big deal at all, really. The loader shouldn't care. */ SVN_ERR(dump_node(eb, path, svn_node_unknown, svn_node_action_delete, FALSE, NULL, SVN_INVALID_REVNUM, subpool)); } svn_pool_destroy(subpool); return SVN_NO_ERROR; }
svn_error_t * svn_config_copy_config(apr_hash_t **cfg_hash, apr_hash_t *src_hash, apr_pool_t *pool) { apr_hash_index_t *cidx; *cfg_hash = apr_hash_make(pool); for (cidx = apr_hash_first(pool, src_hash); cidx != NULL; cidx = apr_hash_next(cidx)) { const void *ckey; void *cval; apr_ssize_t ckeyLength; svn_config_t * srcconfig; svn_config_t * destconfig; apr_hash_this(cidx, &ckey, &ckeyLength, &cval); srcconfig = cval; SVN_ERR(svn_config_dup(&destconfig, srcconfig, pool)); apr_hash_set(*cfg_hash, apr_pstrdup(pool, (const char*)ckey), ckeyLength, destconfig); } return SVN_NO_ERROR; }
/* RTSP connection disconnected */ static apt_bool_t rtsp_server_on_disconnect(apt_net_server_task_t *task, apt_net_server_connection_t *connection) { apr_size_t remaining_sessions = 0; rtsp_server_t *server = apt_net_server_task_object_get(task); rtsp_server_connection_t *rtsp_connection = connection->obj; apt_list_elem_remove(server->connection_list,rtsp_connection->it); rtsp_connection->it = NULL; if(apt_list_is_empty(server->connection_list) == TRUE) { apr_pool_clear(server->sub_pool); server->connection_list = NULL; } remaining_sessions = apr_hash_count(rtsp_connection->session_table); if(remaining_sessions) { rtsp_server_session_t *session; void *val; apr_hash_index_t *it; apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Terminate Remaining RTSP Sessions [%d]",remaining_sessions); it = apr_hash_first(connection->pool,rtsp_connection->session_table); for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&val); session = val; if(session && session->terminating == FALSE) { rtsp_server_session_terminate_request(server,session); } } } else { apt_net_server_connection_destroy(connection); } return TRUE; }