static int hash_test_with_key(pj_pool_t *pool, unsigned char key)
{
pj_hash_table_t *ht;
unsigned value = 0x12345;
pj_hash_iterator_t it_buf, *it;
unsigned *entry;
ht = pj_hash_create(pool, HASH_COUNT);
if (!ht)
return -10;
pj_hash_set(pool, ht, &key, sizeof(key), 0, &value);
entry = (unsigned*) pj_hash_get(ht, &key, sizeof(key), NULL);
if (!entry)
return -20;
if (*entry != value)
return -30;
if (pj_hash_count(ht) != 1)
return -30;
it = pj_hash_first(ht, &it_buf);
if (it == NULL)
return -40;
entry = (unsigned*) pj_hash_this(ht, it);
if (!entry)
return -50;
if (*entry != value)
return -60;
it = pj_hash_next(ht, it);
if (it != NULL)
return -70;
/* Erase item */
pj_hash_set(NULL, ht, &key, sizeof(key), 0, NULL);
if (pj_hash_get(ht, &key, sizeof(key), NULL) != NULL)
return -80;
if (pj_hash_count(ht) != 0)
return -90;
it = pj_hash_first(ht, &it_buf);
if (it != NULL)
return -100;
return 0;
}
static void dump_status(pj_turn_srv *srv)
{
char addr[80];
pj_hash_iterator_t itbuf, *it;
pj_time_val now;
unsigned i;
for (i=0; i<srv->core.lis_cnt; ++i) {
pj_turn_listener *lis = srv->core.listener[i];
printf("Server address : %s\n", lis->info);
}
printf("Worker threads : %d\n", srv->core.thread_cnt);
printf("Total mem usage: %u.%03uMB\n", (unsigned)(g_cp.used_size / 1000000),
(unsigned)((g_cp.used_size % 1000000)/1000));
printf("UDP port range : %u %u %u (next/min/max)\n", srv->ports.next_udp,
srv->ports.min_udp, srv->ports.max_udp);
printf("TCP port range : %u %u %u (next/min/max)\n", srv->ports.next_tcp,
srv->ports.min_tcp, srv->ports.max_tcp);
printf("Clients # : %u\n", pj_hash_count(srv->tables.alloc));
puts("");
if (pj_hash_count(srv->tables.alloc)==0) {
return;
}
puts("# Client addr. Alloc addr. Username Lftm Expy #prm #chl");
puts("------------------------------------------------------------------------------");
pj_gettimeofday(&now);
it = pj_hash_first(srv->tables.alloc, &itbuf);
i=1;
while (it) {
pj_turn_allocation *alloc = (pj_turn_allocation*)
pj_hash_this(srv->tables.alloc, it);
printf("%-3d %-22s %-22s %-8.*s %-4d %-4ld %-4d %-4d\n",
i,
alloc->info,
pj_sockaddr_print(&alloc->relay.hkey.addr, addr, sizeof(addr), 3),
(int)alloc->cred.data.static_cred.username.slen,
alloc->cred.data.static_cred.username.ptr,
alloc->relay.lifetime,
alloc->relay.expiry.sec - now.sec,
pj_hash_count(alloc->peer_table),
pj_hash_count(alloc->ch_table));
it = pj_hash_next(srv->tables.alloc, it);
++i;
}
}
/*
* Retrieve the current number of dialog-set currently registered
* in the hash table.
*/
PJ_DEF(unsigned) pjsip_ua_get_dlg_set_count(void)
{
unsigned count;
PJ_ASSERT_RETURN(mod_ua.endpt, 0);
pj_mutex_lock(mod_ua.mutex);
count = pj_hash_count(mod_ua.dlg_table);
pj_mutex_unlock(mod_ua.mutex);
return count;
}
void ht_list_item(hash_table_t* table_data) {
pj_hash_iterator_t it_buf,*it;
unsigned count;
int *ret;
count = pj_hash_count(table_data->hash_table);
SHOW_LOG(4, "Total: %d %s\n", count, (count < 2)?"entry":"entries" );
it = pj_hash_first(table_data->hash_table, &it_buf);
while (it) {
ret = (int *)pj_hash_this(table_data->hash_table, it);
SHOW_LOG(4, "Entry: %d\n", *ret);
it = pj_hash_next(table_data->hash_table, it);
}
}
static int hash_collision_test(pj_pool_t *pool)
{
enum {
COUNT = HASH_COUNT * 4
};
pj_hash_table_t *ht;
pj_hash_iterator_t it_buf, *it;
unsigned char *values;
unsigned i;
ht = pj_hash_create(pool, HASH_COUNT);
if (!ht)
return -200;
values = (unsigned char*) pj_pool_alloc(pool, COUNT);
for (i=0; i<COUNT; ++i) {
values[i] = (unsigned char)i;
pj_hash_set(pool, ht, &i, sizeof(i), 0, &values[i]);
}
if (pj_hash_count(ht) != COUNT)
return -210;
for (i=0; i<COUNT; ++i) {
unsigned char *entry;
entry = (unsigned char*) pj_hash_get(ht, &i, sizeof(i), NULL);
if (!entry)
return -220;
if (*entry != values[i])
return -230;
}
i = 0;
it = pj_hash_first(ht, &it_buf);
while (it) {
++i;
it = pj_hash_next(ht, it);
}
if (i != COUNT)
return -240;
return 0;
}
//
// Get number of items in the hash table.
//
unsigned count()
{
return pj_hash_count(table_);
}