static void overlay_same(abts_case *tc, void *data) { apr_hash_t *base = NULL; apr_hash_t *result = NULL; int count; char str[8196]; base = apr_hash_make(p); ABTS_PTR_NOTNULL(tc, base); apr_hash_set(base, "base1", APR_HASH_KEY_STRING, "value1"); apr_hash_set(base, "base2", APR_HASH_KEY_STRING, "value2"); apr_hash_set(base, "base3", APR_HASH_KEY_STRING, "value3"); apr_hash_set(base, "base4", APR_HASH_KEY_STRING, "value4"); apr_hash_set(base, "base5", APR_HASH_KEY_STRING, "value5"); result = apr_hash_overlay(p, base, base); count = apr_hash_count(result); ABTS_INT_EQUAL(tc, 5, count); dump_hash(p, result, str); /* I don't know why these are out of order, but they are. I would probably * consider this a bug, but others should comment. */ ABTS_STR_EQUAL(tc, "Key base5 (5) Value value5\n" "Key base1 (5) Value value1\n" "Key base2 (5) Value value2\n" "Key base3 (5) Value value3\n" "Key base4 (5) Value value4\n" "#entries 5\n", str); }
unsigned int kahanaStockNumberOfItems( kStock_t *s, const char *key ) { unsigned int nitem = 0; if( s ) { if( key && key[0] != '\0' ) { apr_pool_t *p = NULL; apr_status_t rc = apr_pool_create( &p, NULL ); if( rc == APR_SUCCESS ) { apr_hash_index_t *idx = NULL; const char *ikey; for( idx = apr_hash_first( p, s->items ); idx; idx = apr_hash_next( idx ) ) { apr_hash_this( idx, (const void**)&ikey, NULL, NULL ); if( kahanaStrCmpHead( ikey, key ) ){ nitem++; } } apr_pool_destroy( p ); } } else { nitem = apr_hash_count( s->items ); } } return nitem; }
static apr_status_t lcn_multi_reader_document( lcn_index_reader_t *index_reader, lcn_document_t **document, unsigned int n, apr_pool_t *pool ) { apr_status_t s; do { lcn_document_t *doc; unsigned int i = lcn_multi_reader_index( index_reader, n ); lcn_multi_reader_t *multi_reader = (lcn_multi_reader_t*) index_reader; LCNCE( lcn_index_reader_document( multi_reader->sub_readers[i], &doc, n - multi_reader->starts[i], pool ) ); if ( index_reader->fs_fields && (0 != apr_hash_count( index_reader->fs_fields ))) { LCNCE( lcn_index_reader_add_fs_fields( index_reader, doc, n, pool )); } doc->index_pos = n; *document = doc; } while(0); return s; }
/* Finally terminate RTSP session */ static apt_bool_t rtsp_server_session_do_terminate(rtsp_server_t *server, rtsp_server_session_t *session) { rtsp_server_connection_t *rtsp_connection = session->connection; if(session->active_request) { rtsp_message_t *response = rtsp_response_create(session->active_request, RTSP_STATUS_CODE_OK,RTSP_REASON_PHRASE_OK,session->active_request->pool); if(response) { if(session->id.buf) { response->header.session_id = session->id; rtsp_header_property_add(&response->header,RTSP_HEADER_FIELD_SESSION_ID,response->pool); } if(rtsp_connection) { rtsp_server_message_send(server,rtsp_connection,response); } } } apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Remove RTSP Session "APT_SID_FMT,session->id.buf); apr_hash_set(rtsp_connection->session_table,session->id.buf,session->id.length,NULL); rtsp_server_session_destroy(session); if(rtsp_connection && !rtsp_connection->it) { if(apr_hash_count(rtsp_connection->session_table) == 0) { rtsp_server_connection_destroy(rtsp_connection); } } return TRUE; }
static apt_bool_t mrcp_client_message_handler(mrcp_connection_t *connection, mrcp_message_t *message, apt_message_status_e status) { if(status == APT_MESSAGE_STATUS_COMPLETE) { /* message is completely parsed */ mrcp_control_channel_t *channel; apt_str_t identifier; apt_id_resource_generate(&message->channel_id.session_id,&message->channel_id.resource_name,'@',&identifier,message->pool); channel = mrcp_connection_channel_find(connection,&identifier); if(channel) { mrcp_connection_agent_t *agent = connection->agent; if(message->start_line.message_type == MRCP_MESSAGE_TYPE_RESPONSE) { if(!channel->active_request || channel->active_request->start_line.request_id != message->start_line.request_id) { apt_obj_log(APT_LOG_MARK,APT_PRIO_WARNING,channel->log_obj,"Unexpected MRCP Response " APT_SIDRES_FMT" [%d]", MRCP_MESSAGE_SIDRES(message), message->start_line.request_id); return FALSE; } if(channel->request_timer) { apt_timer_kill(channel->request_timer); } channel->active_request = NULL; } mrcp_connection_message_receive(agent->vtable,channel,message); } else { apt_log(APT_LOG_MARK,APT_PRIO_WARNING,"Failed to Find Channel " APT_SIDRES_FMT" in Connection %s [%d]", MRCP_MESSAGE_SIDRES(message), connection->id, apr_hash_count(connection->channel_table)); } } return TRUE; }
git_wc_status2_t * GitStatus::GetNextFileStatus(CTGitPath& /*retPath*/) { static git_wc_status2 st; st.text_status = git_wc_status_none; /*if (m_fileCache.m_pFileIter) { switch(m_fileCache.m_pFileIter->nStatus) { case WGFS_Normal: st.text_status = git_wc_status_normal; break; case WGFS_Modified: st.text_status = git_wc_status_modified; break; case WGFS_Deleted: st.text_status = git_wc_status_deleted; break; } m_fileCache.m_pFileIter = m_fileCache.m_pFileIter->pNext; }*/ return &st; #if 0 const sort_item* item; if ((m_statushashindex+1) >= apr_hash_count(m_statushash)) return NULL; m_statushashindex++; item = &APR_ARRAY_IDX (m_statusarray, m_statushashindex, const sort_item); retPath.SetFromGit((const char*)item->key); return (git_wc_status2_t *) item->value; #endif return 0; }
static apt_bool_t mrcp_server_agent_channel_remove(mrcp_connection_agent_t *agent, mrcp_control_channel_t *channel) { mrcp_connection_t *connection = channel->connection; mrcp_connection_channel_remove(connection,channel); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Remove Control Channel <%s> [%d]", channel->identifier.buf, apr_hash_count(connection->channel_table)); if(!connection->access_count) { if(connection == agent->null_connection) { if(apt_list_is_empty(agent->connection_list) == TRUE) { apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Destroy Pending Connection"); mrcp_connection_destroy(agent->null_connection); agent->null_connection = NULL; agent->connection_list = NULL; } } else if(!connection->sock) { mrcp_connection_remove(agent,connection); /* set connection to be destroyed on channel destroy */ apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Mark Connection for Late Destroy"); channel->connection = connection; channel->removed = TRUE; } } /* send response */ return mrcp_control_channel_remove_respond(agent->vtable,channel,TRUE); }
static apt_bool_t mrcp_server_agent_channel_add(mrcp_connection_agent_t *agent, mrcp_control_channel_t *channel, mrcp_control_descriptor_t *offer) { mrcp_control_descriptor_t *answer = mrcp_control_answer_create(offer,channel->pool); apt_id_resource_generate(&offer->session_id,&offer->resource_name,'@',&channel->identifier,channel->pool); if(offer->port) { answer->port = agent->sockaddr->port; } if(offer->connection_type == MRCP_CONNECTION_TYPE_EXISTING) { if(agent->force_new_connection == TRUE) { /* force client to establish new connection */ answer->connection_type = MRCP_CONNECTION_TYPE_NEW; } else { mrcp_connection_t *connection = NULL; /* try to find any existing connection */ connection = mrcp_connection_find(agent,&offer->ip); if(!connection) { /* no existing conection found, force the new one */ answer->connection_type = MRCP_CONNECTION_TYPE_NEW; } } } if(!agent->null_connection) { apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Create Pending Connection"); agent->null_connection = mrcp_connection_create(); agent->connection_list = apt_list_create(agent->null_connection->pool); } mrcp_connection_channel_add(agent->null_connection,channel); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Add Control Channel <%s> to Pending Connection [%d]", channel->identifier.buf, apr_hash_count(agent->null_connection->channel_table)); /* send response */ return mrcp_control_channel_add_respond(agent->vtable,channel,answer,TRUE); }
static void overlay_empty(abts_case *tc, void *data) { apr_hash_t *base = NULL; apr_hash_t *overlay = NULL; apr_hash_t *result = NULL; int count; char str[8196]; base = apr_hash_make(p); overlay = apr_hash_make(p); ABTS_PTR_NOTNULL(tc, base); ABTS_PTR_NOTNULL(tc, overlay); apr_hash_set(base, "key1", APR_HASH_KEY_STRING, "value1"); apr_hash_set(base, "key2", APR_HASH_KEY_STRING, "value2"); apr_hash_set(base, "key3", APR_HASH_KEY_STRING, "value3"); apr_hash_set(base, "key4", APR_HASH_KEY_STRING, "value4"); apr_hash_set(base, "key5", APR_HASH_KEY_STRING, "value5"); result = apr_hash_overlay(p, overlay, base); count = apr_hash_count(result); ABTS_INT_EQUAL(tc, 5, count); dump_hash(p, result, str); ABTS_STR_EQUAL(tc, "Key key1 (4) Value value1\n" "Key key2 (4) Value value2\n" "Key key3 (4) Value value3\n" "Key key4 (4) Value value4\n" "Key key5 (4) Value value5\n" "#entries 5\n", str); }
/** Return TRUE to proceed with the next message in the stream (if any) */ static apt_bool_t rtsp_client_message_handler(rtsp_client_connection_t *rtsp_connection, rtsp_message_t *message, apt_message_status_e status) { if(status != APT_MESSAGE_STATUS_COMPLETE) { /* message is not completely parsed, nothing to do */ return TRUE; } /* process parsed message */ if(message->start_line.message_type == RTSP_MESSAGE_TYPE_RESPONSE) { rtsp_message_t *request; rtsp_client_session_t *session; /* at first, pop in-progress request/session */ if(rtsp_client_request_pop(rtsp_connection,message,&request,&session) == FALSE) { apt_log(RTSP_LOG_MARK,APT_PRIO_WARNING,"Unexpected RTSP Response Received CSeq:%"APR_SIZE_T_FMT, message->header.cseq); return TRUE; } /* next, process session response */ rtsp_client_session_response_process(rtsp_connection->client,session,request,message); /* process session pending requests */ if(rtsp_client_session_pending_requests_process(rtsp_connection->client,session) == FALSE) { /* no in-progress request, check the termination state now */ if(session->term_state != TERMINATION_STATE_NONE) { if(session->term_state == TERMINATION_STATE_REQUESTED) { rtsp_client_session_resources_teardown(rtsp_connection->client,session); } /* respond if no resources left */ if(apr_hash_count(session->resource_table) == 0) { rtsp_client_session_terminate_respond(rtsp_connection->client,session); if(apr_hash_count(rtsp_connection->handle_table) == 0) { rtsp_client_connection_destroy(rtsp_connection); /* return FALSE to indicate connection has been destroyed */ return FALSE; } } } } } else if(message->start_line.message_type == RTSP_MESSAGE_TYPE_REQUEST) { rtsp_client_session_event_process(rtsp_connection->client,rtsp_connection,message); } return TRUE; }
svn_error_t * svn_wc__expand_keywords(apr_hash_t **keywords, svn_wc__db_t *db, const char *local_abspath, const char *wri_abspath, const char *keyword_list, svn_boolean_t for_normalization, apr_pool_t *result_pool, apr_pool_t *scratch_pool) { svn_revnum_t changed_rev; apr_time_t changed_date; const char *changed_author; const char *url; const char *repos_root_url; if (! for_normalization) { const char *repos_relpath; SVN_ERR(svn_wc__db_read_info(NULL, NULL, NULL, &repos_relpath, &repos_root_url, NULL, &changed_rev, &changed_date, &changed_author, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, db, local_abspath, scratch_pool, scratch_pool)); if (repos_relpath) url = svn_path_url_add_component2(repos_root_url, repos_relpath, scratch_pool); else SVN_ERR(svn_wc__db_read_url(&url, db, local_abspath, scratch_pool, scratch_pool)); } else { url = ""; changed_rev = SVN_INVALID_REVNUM; changed_date = 0; changed_author = ""; repos_root_url = ""; } SVN_ERR(svn_subst_build_keywords3(keywords, keyword_list, apr_psprintf(scratch_pool, "%ld", changed_rev), url, repos_root_url, changed_date, changed_author, result_pool)); if (apr_hash_count(*keywords) == 0) *keywords = NULL; return SVN_NO_ERROR; }
static void hash_count_0(abts_case *tc, void *data) { apr_hash_t *h = NULL; int count; h = apr_hash_make(p); ABTS_PTR_NOTNULL(tc, h); count = apr_hash_count(h); ABTS_INT_EQUAL(tc, 0, count); }
/* Process incoming RTSP response */ static apt_bool_t rtsp_client_session_response_process(rtsp_client_t *client, rtsp_client_session_t *session, rtsp_message_t *request, rtsp_message_t *response) { const char *resource_name; if(request->start_line.common.request_line.method_id == RTSP_METHOD_SETUP && response->start_line.common.status_line.status_code == RTSP_STATUS_CODE_OK) { if(apr_hash_count(session->resource_table) == 0) { if(rtsp_header_property_check(&response->header,RTSP_HEADER_FIELD_SESSION_ID) == TRUE) { session->id = response->header.session_id; apt_log(RTSP_LOG_MARK,APT_PRIO_INFO,"Add RTSP Session " APT_PTRSID_FMT, session, session->id.buf); apr_hash_set(session->connection->session_table,session->id.buf,session->id.length,session); } } /* add resource */ resource_name = request->start_line.common.request_line.resource_name; apr_hash_set(session->resource_table,resource_name,APR_HASH_KEY_STRING,request); } else if(request->start_line.common.request_line.method_id == RTSP_METHOD_TEARDOWN) { /* remove resource */ resource_name = request->start_line.common.request_line.resource_name; apr_hash_set(session->resource_table,resource_name,APR_HASH_KEY_STRING,NULL); if(apr_hash_count(session->resource_table) == 0) { if(session->connection) { apt_log(RTSP_LOG_MARK,APT_PRIO_INFO,"Remove RTSP Session " APT_PTRSID_FMT, session, session->id.buf); apr_hash_set(session->connection->session_table,session->id.buf,session->id.length,NULL); } } } if(session->term_state != TERMINATION_STATE_INPROGRESS) { client->vtable->on_session_response(client,session,request,response); } return TRUE; }
/* * verify the signature on a JWT */ apr_byte_t apr_jws_verify(apr_pool_t *pool, apr_jwt_t *jwt, apr_hash_t *keys, apr_jwt_error_t *err) { apr_byte_t rc = FALSE; apr_jwk_t *jwk = NULL; apr_hash_index_t *hi; if (jwt->header.kid != NULL) { jwk = apr_hash_get(keys, jwt->header.kid, APR_HASH_KEY_STRING); if (jwk != NULL) { rc = apr_jws_verify_with_jwk(pool, jwt, jwk, err); } else { apr_jwt_error(err, "could not find key with kid: %s", jwt->header.kid); rc = FALSE; } } else { for (hi = apr_hash_first(pool, keys); hi; hi = apr_hash_next(hi)) { apr_hash_this(hi, NULL, NULL, (void **) &jwk); rc = apr_jws_verify_with_jwk(pool, jwt, jwk, err); if (rc == TRUE) break; } if (rc == FALSE) apr_jwt_error(err, "could not verify signature against any of the (%d) provided keys%s", apr_hash_count(keys), apr_hash_count(keys) > 0 ? "" : apr_psprintf(pool, "; you have probably provided no or incorrect keys/key-types for algorithm: %s", jwt->header.alg)); } return rc; }
/* Call RECEIVER for the given PATH and PROP_HASH. * * If PROP_HASH is null or has zero count, do nothing. */ static svn_error_t* call_receiver(const char *path, apr_hash_t *prop_hash, svn_proplist_receiver_t receiver, void *receiver_baton, apr_pool_t *pool) { if (prop_hash && apr_hash_count(prop_hash)) SVN_ERR(receiver(receiver_baton, path, prop_hash, pool)); return SVN_NO_ERROR; }
static svn_error_t * test_parse_property_and_text_diff(apr_pool_t *pool) { svn_patch_file_t *patch_file; svn_patch_t *patch; svn_prop_patch_t *prop_patch; svn_diff_hunk_t *hunk; apr_array_header_t *hunks; SVN_ERR(create_patch_file(&patch_file, property_and_text_unidiff, pool)); SVN_ERR(svn_diff_parse_next_patch(&patch, patch_file, FALSE, /* reverse */ FALSE, /* ignore_whitespace */ pool, pool)); SVN_TEST_ASSERT(patch); SVN_TEST_STRING_ASSERT(patch->old_filename, "iota"); SVN_TEST_STRING_ASSERT(patch->new_filename, "iota"); SVN_TEST_ASSERT(patch->hunks->nelts == 1); SVN_TEST_ASSERT(apr_hash_count(patch->prop_patches) == 1); /* Check contents of text hunk */ hunk = APR_ARRAY_IDX(patch->hunks, 0, svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "This is the file 'iota'." NL, pool)); SVN_ERR(check_content(hunk, FALSE, "This is the file 'iota'." NL "some more bytes to 'iota'" NL, pool)); /* Check the added property */ prop_patch = apr_hash_get(patch->prop_patches, "prop_add", APR_HASH_KEY_STRING); SVN_TEST_ASSERT(prop_patch->operation == svn_diff_op_added); hunks = prop_patch->hunks; SVN_TEST_ASSERT(hunks->nelts == 1); hunk = APR_ARRAY_IDX(hunks, 0 , svn_diff_hunk_t *); SVN_ERR(check_content(hunk, TRUE, "", pool)); SVN_ERR(check_content(hunk, FALSE, "value" NL, pool)); SVN_ERR(svn_diff_close_patch_file(patch_file, pool)); return SVN_NO_ERROR; }
static void hash_count_1(abts_case *tc, void *data) { apr_hash_t *h = NULL; int count; h = apr_hash_make(p); ABTS_PTR_NOTNULL(tc, h); apr_hash_set(h, "key", APR_HASH_KEY_STRING, "value"); count = apr_hash_count(h); ABTS_INT_EQUAL(tc, 1, count); }
/* Respond to session termination request */ static apt_bool_t rtsp_client_session_terminate_respond(rtsp_client_t *client, rtsp_client_session_t *session) { rtsp_client_connection_t *rtsp_connection = session->connection; apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Remove RTSP Handle "APT_PTR_FMT,session); apr_hash_set(rtsp_connection->handle_table,session,sizeof(session),NULL); session->term_state = TERMINATION_STATE_NONE; client->vtable->on_session_terminate_response(client,session); if(apr_hash_count(rtsp_connection->handle_table) == 0) { rtsp_client_connection_destroy(client,rtsp_connection); } return TRUE; }
static mrcp_control_channel_t* mrcp_connection_channel_associate(mrcp_connection_agent_t *agent, mrcp_connection_t *connection, const mrcp_message_t *message) { apt_str_t identifier; mrcp_control_channel_t *channel; if(!connection || !message) { return NULL; } apt_id_resource_generate(&message->channel_id.session_id,&message->channel_id.resource_name,'@',&identifier,connection->pool); channel = mrcp_connection_channel_find(connection,&identifier); if(!channel) { channel = apr_hash_get(agent->pending_channel_table,identifier.buf,identifier.length); if(channel) { apr_hash_set(agent->pending_channel_table,identifier.buf,identifier.length,NULL); mrcp_connection_channel_add(connection,channel); apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Assign Control Channel <%s> to Connection %s [%d] -> [%d]", channel->identifier.buf, connection->id, apr_hash_count(agent->pending_channel_table), apr_hash_count(connection->channel_table)); } } return channel; }
svn_boolean_t svn_fs__prop_lists_equal(apr_hash_t *a, apr_hash_t *b, apr_pool_t *pool) { apr_hash_index_t *hi; /* Quick checks and special cases. */ if (a == b) return TRUE; if (a == NULL) return apr_hash_count(b) == 0; if (b == NULL) return apr_hash_count(a) == 0; if (apr_hash_count(a) != apr_hash_count(b)) return FALSE; /* Compare prop by prop. */ for (hi = apr_hash_first(pool, a); hi; hi = apr_hash_next(hi)) { const char *key; apr_ssize_t klen; svn_string_t *val_a, *val_b; apr_hash_this(hi, (const void **)&key, &klen, (void **)&val_a); val_b = apr_hash_get(b, key, klen); if (!val_b || !svn_string_compare(val_a, val_b)) return FALSE; } /* No difference found. */ return TRUE; }
/* * decrypt a JWT and return the plaintext */ static uint8_t *oidc_jwe_decrypt_impl(apr_pool_t *pool, cjose_jwe_t *jwe, apr_hash_t *keys, size_t *content_len, oidc_jose_error_t *err) { uint8_t *decrypted = NULL; oidc_jwk_t *jwk = NULL; apr_hash_index_t *hi; cjose_err cjose_err; cjose_header_t *hdr = cjose_jwe_get_protected(jwe); const char *kid = cjose_header_get(hdr, CJOSE_HDR_KID, &cjose_err); const char *alg = cjose_header_get(hdr, CJOSE_HDR_ALG, &cjose_err); if (kid != NULL) { jwk = apr_hash_get(keys, kid, APR_HASH_KEY_STRING); if (jwk != NULL) { decrypted = cjose_jwe_decrypt(jwe, jwk->cjose_jwk, content_len, &cjose_err); if (decrypted == NULL) oidc_jose_error(err, "encrypted JWT could not be decrypted with kid %s: %s", kid, oidc_cjose_e2s(pool, cjose_err)); } else { oidc_jose_error(err, "could not find key with kid: %s", kid); } } else { for (hi = apr_hash_first(pool, keys); hi; hi = apr_hash_next(hi)) { apr_hash_this(hi, NULL, NULL, (void **) &jwk); if (jwk->kty == oidc_alg2kty(alg)) { decrypted = cjose_jwe_decrypt(jwe, jwk->cjose_jwk, content_len, &cjose_err); if (decrypted != NULL) break; } } if (decrypted == NULL) oidc_jose_error(err, "encrypted JWT could not be decrypted with any of the %d keys: error for last tried key is: %s", apr_hash_count(keys), oidc_cjose_e2s(pool, cjose_err)); } return decrypted; }
static apt_bool_t mrcp_connection_remove(mrcp_connection_agent_t *agent, mrcp_connection_t *connection) { if(connection->it) { apt_list_elem_remove(agent->connection_list,connection->it); connection->it = NULL; } if(agent->null_connection) { if(apt_list_is_empty(agent->connection_list) == TRUE && apr_hash_count(agent->null_connection->channel_table) == 0) { apt_log(APT_LOG_MARK,APT_PRIO_DEBUG,"Destroy Pending Connection"); mrcp_connection_destroy(agent->null_connection); agent->null_connection = NULL; agent->connection_list = NULL; } } return TRUE; }
svn_error_t * svn_hash_keys(apr_array_header_t **array, apr_hash_t *hash, apr_pool_t *pool) { apr_hash_index_t *hi; *array = apr_array_make(pool, apr_hash_count(hash), sizeof(const char *)); for (hi = apr_hash_first(pool, hash); hi; hi = apr_hash_next(hi)) { APR_ARRAY_PUSH(*array, const char *) = svn__apr_hash_index_key(hi); } return SVN_NO_ERROR; }
void auth_vas_cache_set_max_size(auth_vas_cache *cache, unsigned int new_size) { unsigned int num_items; if (new_size < 1) /* Some dolt will try it */ new_size = 1; num_items = apr_hash_count(cache->table); while (num_items > new_size) { auth_vas_cache_remove_items_from(cache, cache->oldest); --num_items; } cache->max_size = new_size; }
void UmcFramework::ProcessShowSessions() { UmcSession* pSession; void* pVal; printf("%d Session(s)\n", apr_hash_count(m_pSessionTable)); apr_hash_index_t* it = apr_hash_first(m_pPool,m_pSessionTable); for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&pVal); pSession = (UmcSession*) pVal; if(pSession) { printf("[%s] - %s\n", pSession->GetId(), pSession->GetScenario()->GetName()); } } }
void UmcFramework::ProcessShowScenarios() { UmcScenario* pScenario; void* pVal; printf("%d Scenario(s)\n", apr_hash_count(m_pScenarioTable)); apr_hash_index_t* it = apr_hash_first(m_pPool,m_pScenarioTable); for(; it; it = apr_hash_next(it)) { apr_hash_this(it,NULL,NULL,&pVal); pScenario = (UmcScenario*) pVal; if(pScenario) { printf("[%s]\n", pScenario->GetName()); } } }
void svn_ra_serf__merge_lock_token_list(apr_hash_t *lock_tokens, const char *parent, serf_bucket_t *body, serf_bucket_alloc_t *alloc, apr_pool_t *pool) { apr_hash_index_t *hi; if (!lock_tokens || apr_hash_count(lock_tokens) == 0) return; svn_ra_serf__add_open_tag_buckets(body, alloc, "S:lock-token-list", "xmlns:S", SVN_XML_NAMESPACE, SVN_VA_NULL); for (hi = apr_hash_first(pool, lock_tokens); hi; hi = apr_hash_next(hi)) { const void *key; apr_ssize_t klen; void *val; svn_string_t path; apr_hash_this(hi, &key, &klen, &val); path.data = key; path.len = klen; if (parent && !svn_relpath_skip_ancestor(parent, key)) continue; svn_ra_serf__add_open_tag_buckets(body, alloc, "S:lock", SVN_VA_NULL); svn_ra_serf__add_open_tag_buckets(body, alloc, "lock-path", SVN_VA_NULL); svn_ra_serf__add_cdata_len_buckets(body, alloc, path.data, path.len); svn_ra_serf__add_close_tag_buckets(body, alloc, "lock-path"); svn_ra_serf__add_tag_buckets(body, "lock-token", val, alloc); svn_ra_serf__add_close_tag_buckets(body, alloc, "S:lock"); } svn_ra_serf__add_close_tag_buckets(body, alloc, "S:lock-token-list"); }
static void hash_count_5(abts_case *tc, void *data) { apr_hash_t *h = NULL; int count; h = apr_hash_make(p); ABTS_PTR_NOTNULL(tc, h); apr_hash_set(h, "key1", APR_HASH_KEY_STRING, "value1"); apr_hash_set(h, "key2", APR_HASH_KEY_STRING, "value2"); apr_hash_set(h, "key3", APR_HASH_KEY_STRING, "value3"); apr_hash_set(h, "key4", APR_HASH_KEY_STRING, "value4"); apr_hash_set(h, "key5", APR_HASH_KEY_STRING, "value5"); count = apr_hash_count(h); ABTS_INT_EQUAL(tc, 5, count); }
static dav_error *dav_acl_patch_validate(const dav_resource * resource, const apr_xml_elem * elem, int operation, void **context, int *defer_to_dead) { apr_pool_t *pool = resource->pool; dav_repos_resource *db_r = resource->info->db_r; dav_repos_db *db = resource->info->db; request_rec *rec = resource->info->rec; dav_elem_private *priv = elem->priv; dav_error *err = NULL; TRACE(); if (priv->propid == DAV_PROPID_group_member_set) { *defer_to_dead = 0; if (db_r->resourcetype!=dav_repos_GROUP || operation!=DAV_PROP_OP_SET) return dav_new_error(pool, HTTP_FORBIDDEN, 0, "Not a set operation on a group"); apr_xml_elem *href_elem = dav_find_child(elem, "href"); apr_hash_t *new_members = apr_hash_make(pool); apr_array_header_t *to_remove = NULL; while (href_elem && !err) { const char *prin_uri = dav_xml_get_cdata(href_elem, pool, 1); const char *prin_name = get_name_from_principal_URL(rec, prin_uri); if (prin_name == NULL) err = dav_new_error (pool, HTTP_CONFLICT, 0, "Not a DAV:principal-URL"); else apr_hash_set(new_members, prin_name, APR_HASH_KEY_STRING, ""); href_elem = href_elem->next; } if (err) return err; if (apr_hash_count(new_members)) err = dbms_calculate_group_changes(db, db_r, new_members,&to_remove); else err = dbms_get_group_members(db, db_r, &to_remove); if (err) return err; apr_hash_set(new_members, "-to-remove-", APR_HASH_KEY_STRING, to_remove); *context = new_members; } return err; }
static void hash_clear(abts_case *tc, void *data) { apr_hash_t *h; int i, *e; h = apr_hash_make(p); ABTS_PTR_NOTNULL(tc, h); for (i = 1; i <= 10; i++) { e = apr_palloc(p, sizeof(int)); *e = i; apr_hash_set(h, e, sizeof(*e), e); } apr_hash_clear(h); i = apr_hash_count(h); ABTS_INT_EQUAL(tc, 0, i); }