kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

format cleanup

This commit is contained in:
Anthony Minessale 2016-12-09 13:34:18 -06:00 committed by Mike Jerris
parent dc76746bf2
commit 4d7f864495
3 changed files with 553 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
libs/libks/src/dht/ks_dht.c
View File

@ -167,11 +167,11 @@ KS_DECLARE(ks_status_t) ks_dht_deinit(ks_dht_t *dht)
dht->token_secret_previous = 0;
dht->token_secret_expiration = 0;
if (dht->rt_ipv4) {
ks_dhtrt_deinitroute(dht->rt_ipv4);
ks_dhtrt_deinitroute(&dht->rt_ipv4);
dht->rt_ipv4 = NULL;
}
if (dht->rt_ipv6) {
ks_dhtrt_deinitroute(dht->rt_ipv6);
ks_dhtrt_deinitroute(&dht->rt_ipv6);
dht->rt_ipv6 = NULL;
}
dht->transactionid_next = 0;
@ -385,11 +385,11 @@ KS_DECLARE(ks_status_t) ks_dht_bind(ks_dht_t *dht, const ks_dht_nodeid_t *nodeid
// @todo initialize or add local nodeid to appropriate route table
if (ep->addr.family == AF_INET) {
if (!dht->rt_ipv4) {
//ks_dhtrt_initroute(&dht->rt_ipv4, dht->pool, &ep->nodeid);
ks_dhtrt_initroute(&dht->rt_ipv4, dht->pool, ep->nodeid);
}
} else {
if (!dht->rt_ipv6) {
//ks_dhtrt_initroute(&dht->rt_ipv6, dht->pool, &ep->nodeid);
ks_dhtrt_initroute(&dht->rt_ipv6, dht->pool, ep->nodeid);
}
}

4
libs/libks/src/dht/ks_dht.h
View File

@ -230,8 +230,8 @@ KS_DECLARE(ks_status_t) ks_dht_transaction_deinit(ks_dht_transaction_t *transact
* route table methods
*
*/
KS_DECLARE(ks_dhtrt_routetable_t*) ks_dhtrt_initroute( ks_pool_t *pool, ks_dht_nodeid_t nodeid);
KS_DECLARE(void) ks_dhtrt_deinitroute(ks_dhtrt_routetable_t* table );
KS_DECLARE(ks_status_t) ks_dhtrt_initroute(ks_dhtrt_routetable_t **tableP, ks_pool_t *pool, ks_dht_nodeid_t nodeid);
KS_DECLARE(void) ks_dhtrt_deinitroute(ks_dhtrt_routetable_t **table);
KS_DECLARE(ks_status_t) ks_dhtrt_create_node(ks_dhtrt_routetable_t* table,
ks_dht_nodeid_t nodeid,

128
libs/libks/src/dht/ks_dht_bucket.c
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2016, FreeSWITCH
* Copyright (c) 2016, FreeSWITCH Solutions LLC
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
@ -172,7 +172,7 @@ void ks_dhtrt_ping(ks_dhtrt_bucket_entry_t* entry);
*/
KS_DECLARE(ks_dhtrt_routetable_t*) ks_dhtrt_initroute( ks_pool_t *pool, ks_dht_nodeid_t nodeid)
KS_DECLARE(ks_status_t) ks_dhtrt_initroute(ks_dhtrt_routetable_t **tableP, ks_pool_t *pool, ks_dht_nodeid_t nodeid)
{
unsigned char initmask[KS_DHT_NODEID_SIZE];
memset(initmask, 0xff, sizeof(initmask));
@ -182,23 +182,32 @@ KS_DECLARE(ks_dhtrt_routetable_t*) ks_dhtrt_initroute( ks_pool_t *pool, ks_dht_n
ks_dhtrt_internal_t *internal = ks_pool_alloc(pool, sizeof(ks_dhtrt_internal_t));
memset(internal, 0, sizeof(ks_dhtrt_internal_t));
/*ks_rwl_create(&internal->lock, pool);*/
if (nodeid.id != 0) memcpy(internal->localid, nodeid.id, KS_DHT_NODEID_SIZE);
table->internal = internal;
/* initialize root bucket */
ks_dhtrt_bucket_header_t *initial_header = ks_dhtrt_create_bucketheader(pool, 0, initmask);
initial_header->flags = BHF_LEFT; /* fake left to allow splitting */
internal->buckets = initial_header;
initial_header->bucket = ks_dhtrt_create_bucket(pool);
table->pool = pool;
return table;
*tableP = table;
return KS_STATUS_SUCCESS;
}
KS_DECLARE(void) ks_dhtrt_deinitroute( ks_dhtrt_routetable_t* table )
KS_DECLARE(void) ks_dhtrt_deinitroute(ks_dhtrt_routetable_t **table)
{
/* @todo*/
ks_pool_free(table->pool, table);
ks_pool_t *pool = (*table)->pool;
ks_pool_free(pool, *table);
return;
}
@ -209,15 +218,20 @@ KS_DECLARE(ks_status_t) ks_dhtrt_create_node( ks_dhtrt_routetable_t* table,
ks_dht_node_t **node)
{
ks_dht_node_t *tnode = ks_dhtrt_find_node(table, nodeid);
if (tnode != 0) return KS_STATUS_FAIL; /* protect against duplicates */
/* @todo - replace with reusable memory pool */
tnode = ks_pool_alloc(table->pool, sizeof(ks_dht_node_t));
tnode->table = table;
for (int i = 0; i < 5; ++i) {
if (ip[i] == ':') { tnode->family = AF_INET6; break;}
else if (ip[i] == '.') { tnode->family = AF_INET; break; }
if (ip[i] == ':') {
tnode->family = AF_INET6; break;
} else if (ip[i] == '.') {
tnode->family = AF_INET; break;
}
}
memcpy(tnode->nodeid.id, nodeid.id, KS_DHT_NODEID_SIZE);
if ((ks_addr_set(&tnode->addr, ip, port, tnode->family) != KS_STATUS_SUCCESS) ||
@ -227,18 +241,22 @@ KS_DECLARE(ks_status_t) ks_dhtrt_create_node( ks_dhtrt_routetable_t* table,
}
(*node) = tnode;
return KS_STATUS_SUCCESS;
}
KS_DECLARE(ks_status_t) ks_dhtrt_delete_node(ks_dhtrt_routetable_t *table, ks_dht_node_t *node)
{
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, node->nodeid.id);
if (header != 0) {
ks_dhtrt_bucket_t *bucket = header->bucket;
if (bucket != 0) { /* we were not able to find a bucket*/
ks_dhtrt_delete_id(bucket, node->nodeid.id);
}
}
ks_pool_free(table->pool, node);
return KS_STATUS_SUCCESS;
}
@ -251,11 +269,13 @@ ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* no
/* first see if it exists */
ks_dht_node_t *peer = ks_dhtrt_find_node(table, node->nodeid);
if (peer != 0) {
return KS_STATUS_FAIL;
}
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, node->nodeid.id);
bucket = header->bucket;
assert(bucket != 0); /* we were not able to find a bucket*/
@ -266,6 +286,7 @@ ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* no
/* first - seek a stale entry to eject */
if (bucket->expired_count) {
ks_status_t s = ks_dhtrt_insert_id(bucket, node);
if (s == KS_STATUS_SUCCESS) return KS_STATUS_SUCCESS;
}
@ -287,6 +308,7 @@ ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* no
/* work out new mask */
unsigned char newmask[KS_DHT_NODEID_SIZE];
memcpy(newmask, header->mask, KS_DHT_NODEID_SIZE);
if (newmask[KS_DHT_NODEID_SIZE-1] == 0) { /* no more bits to shift - is this possible */
#ifdef KS_DHT_DEBUGPRINTF_
char buffer[100];
@ -300,9 +322,12 @@ ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* no
/* create the new bucket structures */
ks_dhtrt_bucket_header_t *newleft = ks_dhtrt_create_bucketheader(table->pool, header, newmask);
newleft->bucket = ks_dhtrt_create_bucket(table->pool);
newleft->flags = BHF_LEFT; /* flag as left hand side - therefore splitable */
ks_dhtrt_bucket_header_t *newright = ks_dhtrt_create_bucketheader(table->pool, header, header->mask);
ks_dhtrt_split_bucket(header, newleft, newright);
/* ok now we need to try again to see if the bucket has capacity */
@ -310,8 +335,7 @@ ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* no
if (ks_dhtrt_ismasked(node->nodeid.id, newleft->mask)) {
bucket = newleft->bucket;
header = newleft;
}
else {
} else {
bucket = newright->bucket;
header = newright;
}
@ -330,18 +354,25 @@ ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* no
KS_DECLARE(ks_dht_node_t *) ks_dhtrt_find_node(ks_dhtrt_routetable_t *table, ks_dht_nodeid_t nodeid) {
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, nodeid.id);
if (header == 0) return 0;
if (header == 0) return NULL;
ks_dhtrt_bucket_t *bucket = header->bucket;
if (bucket == 0) return 0; /* probably a logic error ?*/
if (bucket == 0) return NULL; /* probably a logic error ?*/
return ks_dhtrt_find_nodeid(bucket, nodeid.id);
}
KS_DECLARE(ks_status_t) ks_dhtrt_touch_node(ks_dhtrt_routetable_t *table, ks_dht_nodeid_t nodeid)
{
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, nodeid.id);
if (header == 0) return KS_STATUS_FAIL;
if (header->bucket == 0) return KS_STATUS_FAIL;
ks_dhtrt_bucket_entry_t *e = ks_dhtrt_find_bucketentry(header, nodeid.id);
if (e != 0) {
e->tyme = ks_time_now();
e->outstanding_pings = 0;
@ -349,14 +380,18 @@ KS_DECLARE(ks_status_t) ks_dhtrt_touch_node(ks_dhtrt_routetable_t* table, ks_dh
e->flags = DHTPEER_ACTIVE;
return KS_STATUS_SUCCESS;
}
return KS_STATUS_FAIL;
}
KS_DECLARE(ks_status_t) ks_dhtrt_expire_node(ks_dhtrt_routetable_t *table, ks_dht_nodeid_t nodeid)
{
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, nodeid.id);
if (header == 0) return KS_STATUS_FAIL;
ks_dhtrt_bucket_entry_t *e = ks_dhtrt_find_bucketentry(header, nodeid.id);
if (e != 0) {
e->flags = DHTPEER_EXPIRED;
return KS_STATUS_SUCCESS;
@ -366,13 +401,14 @@ KS_DECLARE(ks_status_t) ks_dhtrt_expire_node(ks_dhtrt_routetable_t* table, ks_d
KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t *table, ks_dhtrt_querynodes_t *query)
{
query->count = 0;
uint8_t max = query->max;
uint8_t total = 0;
uint8_t cnt;
if (max == 0) return 0; /* sanity check */
query->count = 0;
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, query->nodeid.id);
#ifdef KS_DHT_DEBUGPRINTF_
@ -383,8 +419,11 @@ KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t* table, ks_
ks_dhtrt_sortedxors_t xort0;
memset(&xort0, 0 , sizeof(xort0));
ks_dhtrt_nodeid_t initid;
memset(initid, 0xff, KS_DHT_NODEID_SIZE);
xort0.bheader = header;
@ -405,18 +444,19 @@ KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t* table, ks_
/* step2 - look at sibling */
/* ----------------------- */
ks_dhtrt_sortedxors_t xort1;
xort0.next = &xort1;
memset(&xort1, 0 , sizeof(xort1));
memcpy(initid, &xort0.hixor, KS_DHT_NODEID_SIZE);
ks_dhtrt_bucket_header_t *parent = header->parent;
if (header == parent->left) {
xort1.bheader = header = parent->right;
}
else {
} else {
if (!parent->left->bucket) { /* left hand might no have a bucket - if so choose left->right */
xort1.bheader = header = parent->left->right;
}
else {
} else {
xort1.bheader = header = parent->left;
}
}
@ -440,6 +480,7 @@ KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t* table, ks_
unsigned char leftid[KS_DHT_NODEID_SIZE];
unsigned char rightid[KS_DHT_NODEID_SIZE];
memcpy(leftid, xort0.bheader->mask, KS_DHT_NODEID_SIZE);
memcpy(rightid, xort1.bheader->mask, KS_DHT_NODEID_SIZE);
@ -456,13 +497,17 @@ KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t* table, ks_
rheader = 0;
xortn = 0;
xortn1 = 0;
if (leftid[0] != 0xff) {
ks_dhtrt_shiftleft(leftid);
lheader = ks_dhtrt_find_bucketheader(table, leftid);
if (lheader) {
xortn = ks_pool_alloc(table->pool, sizeof(ks_dhtrt_sortedxors_t));
memset(xortn, 0, sizeof(ks_dhtrt_sortedxors_t));
if (tofree == 0) tofree = xortn;
prev->next = xortn;
prev = xortn;
cnt += ks_dhtrt_findclosest_bucketnodes(query->nodeid.id, lheader, xortn, leftid ,max);
@ -477,6 +522,7 @@ KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t* table, ks_
if (max > 0 && rightid[KS_DHT_NODEID_SIZE-1] != 0x00) {
ks_dhtrt_shiftright(rightid);
rheader = ks_dhtrt_find_bucketheader(table, rightid);
if (rheader) {
xortn1 = ks_pool_alloc(table->pool, sizeof(ks_dhtrt_sortedxors_t));
memset(xortn1, 0, sizeof(ks_dhtrt_sortedxors_t));
@ -492,7 +538,9 @@ KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t* table, ks_
}
if (!lheader && !rheader) break;
++insanity;
if (insanity > 159) {
assert(insanity <= 159);
}
@ -501,12 +549,15 @@ KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t* table, ks_
ks_dhtrt_load_query(query, &xort0);
/* free up the xort structs on heap */
while (tofree) {
ks_dhtrt_sortedxors_t *x = tofree->next;
ks_pool_free(table->pool, tofree);
tofree = x->next;
}
return query->count;
}
@ -532,22 +583,29 @@ KS_DECLARE(void) ks_dhtrt_process_table(ks_dhtrt_routetable_t* table)
while (header) {
stack[stackix++] = header;
if (header->bucket) {
ks_dhtrt_bucket_t *b = header->bucket;
for (int ix=0; ix<KS_DHT_BUCKETSIZE; ++ix) {
ks_dhtrt_bucket_entry_t *e = &b->entries[ix];
if (e->inuse == 1) {
/* more than n pings outstanding? */
if (e->outstanding_pings >= KS_DHTRT_MAXPING) {
e->flags = DHTPEER_EXPIRED;
++b->expired_count;
continue;
}
if (e->flags == DHTPEER_SUSPECT) {
ks_dhtrt_ping(e);
continue;
}
ks_time_t tdiff = t0 - e->tyme;
if (tdiff > KS_DHTRT_INACTIVETIME) {
e->flags = DHTPEER_SUSPECT;
ks_dhtrt_ping(e);
@ -555,7 +613,9 @@ KS_DECLARE(void) ks_dhtrt_process_table(ks_dhtrt_routetable_t* table)
}
} /* end for each bucket_entry */
}
header = header->left;
if (header == 0 && stackix > 1) {
stackix -= 2;
header = stack[stackix];
@ -580,29 +640,35 @@ KS_DECLARE(void) ks_dhtrt_dump(ks_dhtrt_routetable_t* table, int level) {
/* walk and report left handsize */
memset(buffer, 0, 100);
/*ks_log*/ printf("bucket header: [%s]\n", ks_dhtrt_printableid(header->mask, buffer) );
if (header->bucket) {
ks_dhtrt_bucket_t *b = header->bucket;
printf(" bucket holds %d entries\n", b->count);
if (level == 7) {
printf(" --------------------------\n");
for (int ix=0; ix<KS_DHT_BUCKETSIZE; ++ix) {
memset(buffer, 0, 100);
if (b->entries[ix].inuse == 1) ks_dhtrt_printableid(b->entries[ix].id, buffer);
else strcpy(buffer, "<free>");
printf(" slot %d: %s\n", ix, buffer);
}
printf(" --------------------------\n\n");
}
}
header = header->left;
if (header == 0 && stackix > 1) {
stackix -= 2;
header = stack[stackix];
header = header->right;
}
}
return;
}
@ -614,6 +680,7 @@ static
ks_dhtrt_bucket_header_t *ks_dhtrt_create_bucketheader(ks_pool_t *pool, ks_dhtrt_bucket_header_t *parent, uint8_t *mask)
{
ks_dhtrt_bucket_header_t *header = ks_pool_alloc(pool, sizeof(ks_dhtrt_bucket_header_t));
memset(header, 0, sizeof(ks_dhtrt_bucket_header_t));
memcpy(header->mask, mask, sizeof(header->mask));
header->parent = parent;
@ -631,6 +698,7 @@ static
ks_dhtrt_bucket_t *ks_dhtrt_create_bucket(ks_pool_t *pool)
{
ks_dhtrt_bucket_t *bucket = ks_pool_alloc(pool, sizeof(ks_dhtrt_bucket_t));
memset(bucket, 0, sizeof(ks_dhtrt_bucket_t));
/*ks_rwl_create(&bucket->lock, pool);*/
return bucket;
@ -645,24 +713,29 @@ ks_dhtrt_bucket_header_t* ks_dhtrt_find_bucketheader(ks_dhtrt_routetable_t* tabl
*/
ks_dhtrt_internal_t *internal = table->internal;
ks_dhtrt_bucket_header_t *header = internal->buckets;
while (header) {
if ( header->bucket ) {
return header;
}
/* left hand side is more restrictive (closer) so should be tried first */
if (header->left != 0 && (ks_dhtrt_ismasked(id, header->left->mask)))
if (header->left != 0 && (ks_dhtrt_ismasked(id, header->left->mask))) {
header = header->left;
else
} else {
header = header->right;
}
return 0;
}
return NULL;
}
static
ks_dhtrt_bucket_entry_t *ks_dhtrt_find_bucketentry(ks_dhtrt_bucket_header_t *header, ks_dhtrt_nodeid_t nodeid)
{
ks_dhtrt_bucket_t *bucket = header->bucket;
if (bucket == 0) return 0;
if (bucket == 0) return NULL;
for (int ix=0; ix<KS_DHT_BUCKETSIZE; ++ix) {
#ifdef KS_DHT_DEBUGPRINTF_
@ -672,7 +745,8 @@ ks_dhtrt_bucket_entry_t* ks_dhtrt_find_bucketentry(ks_dhtrt_bucket_header_t* hea
return &(bucket->entries[ix]);
}
}
return 0;
return NULL;
}
@ -743,11 +817,13 @@ ks_status_t ks_dhtrt_insert_id(ks_dhtrt_bucket_t* bucket, ks_dht_node_t* node)
if (!bucket || bucket->count >= KS_DHT_BUCKETSIZE) {
assert(0);
}
uint8_t free = KS_DHT_BUCKETSIZE;
uint8_t expiredix = KS_DHT_BUCKETSIZE;
/* find free .. but also check that it is not already here! */
uint8_t ix = 0;
for (; ix<KS_DHT_BUCKETSIZE; ++ix) {
if (bucket->entries[ix].inuse == 0) {
if (free == KS_DHT_BUCKETSIZE) {
@ -773,6 +849,7 @@ ks_status_t ks_dhtrt_insert_id(ks_dhtrt_bucket_t* bucket, ks_dht_node_t* node)
/* ****************** */
/*ks_rwl_write_lock(bucket->lock);*/
bucket->locked = 1;
if (free == KS_DHT_BUCKETSIZE && expiredix<KS_DHT_BUCKETSIZE ) {
/* bump this one - but only if we have no other option */
free = expiredix;
@ -795,6 +872,7 @@ ks_status_t ks_dhtrt_insert_id(ks_dhtrt_bucket_t* bucket, ks_dht_node_t* node)
#endif
return KS_STATUS_SUCCESS;
}
bucket->locked = 0;
/*ks_rwl_write_unlock(bucket->lock);*/
/* ********************** */
@ -827,7 +905,7 @@ ks_dht_node_t* ks_dhtrt_find_nodeid(ks_dhtrt_bucket_t* bucket, ks_dhtrt_nodeid_t
return bucket->entries[ix].gptr;
}
}
return 0;
return NULL;
}
static
@ -919,14 +997,14 @@ uint8_t ks_dhtrt_findclosest_bucketnodes(ks_dhtrt_nodeid_t id,
xors->xort[count].nextix = xorix; /* correct forward chain */
if (prev_xorix < KS_DHT_BUCKETSIZE) { /* correct backward chain */
xors->xort[prev_xorix].nextix = count;
}
else {
} else {
xors->startix = count;
}
++count;
}
}
}
xors->count = count;
return count; /* return count of added nodes */
}