mirror of
https://github.com/signalwire/freeswitch.git
synced 2025-07-27 04:05:04 +00:00
format cleanup
This commit is contained in:
Anthony Minessale
Mike Jerris
parent
dc76746bf2
commit
4d7f864495
@ -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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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
|
||||
@ -53,7 +53,7 @@ typedef uint8_t ks_dhtrt_nodeid_t[KS_DHT_NODEID_SIZE];
|
||||
typedef struct ks_dhtrt_bucket_entry_s {
|
||||
ks_time_t tyme;
|
||||
uint8_t id[KS_DHT_NODEID_SIZE];
|
||||
ks_dht_node_t* gptr; /* ptr to peer */
|
||||
ks_dht_node_t *gptr; /* ptr to peer */
|
||||
uint8_t inuse;
|
||||
uint8_t outstanding_pings;
|
||||
uint8_t flags; /* active, suspect, expired */
|
||||
@ -63,7 +63,7 @@ typedef struct ks_dhtrt_bucket_s {
|
||||
ks_dhtrt_bucket_entry_t entries[KS_DHT_BUCKETSIZE];
|
||||
uint8_t count;
|
||||
uint8_t expired_count;
|
||||
ks_rwl_t* lock;
|
||||
ks_rwl_t * lock;
|
||||
uint8_t locked;
|
||||
} ks_dhtrt_bucket_t;
|
||||
|
||||
@ -74,7 +74,7 @@ typedef struct ks_dhtrt_bucket_header_s {
|
||||
struct ks_dhtrt_bucket_header_s* parent;
|
||||
struct ks_dhtrt_bucket_header_s* left;
|
||||
struct ks_dhtrt_bucket_header_s* right;
|
||||
ks_dhtrt_bucket_t* bucket;
|
||||
ks_dhtrt_bucket_t * bucket;
|
||||
ks_time_t tyme; /* last processed time */
|
||||
unsigned char mask[KS_DHT_NODEID_SIZE]; /* node id mask */
|
||||
unsigned char flags;
|
||||
@ -83,8 +83,8 @@ typedef struct ks_dhtrt_bucket_header_s {
|
||||
|
||||
typedef struct ks_dhtrt_internal_s {
|
||||
uint8_t localid[KS_DHT_NODEID_SIZE];
|
||||
ks_dhtrt_bucket_header_t* buckets; /* root bucketheader */
|
||||
ks_rwl_t* lock; /* lock for safe traversal of the tree */
|
||||
ks_dhtrt_bucket_header_t *buckets; /* root bucketheader */
|
||||
ks_rwl_t * lock; /* lock for safe traversal of the tree */
|
||||
uint8_t locked;
|
||||
} ks_dhtrt_internal_t;
|
||||
|
||||
@ -95,7 +95,7 @@ typedef struct ks_dhtrt_xort_s {
|
||||
} ks_dhtrt_xort_t;
|
||||
|
||||
typedef struct ks_dhtrt_sortedxors_s {
|
||||
ks_dhtrt_bucket_header_t* bheader;
|
||||
ks_dhtrt_bucket_header_t *bheader;
|
||||
ks_dhtrt_xort_t xort[KS_DHT_BUCKETSIZE];
|
||||
unsigned char hixor[KS_DHT_NODEID_SIZE];
|
||||
unsigned int startix;
|
||||
@ -107,53 +107,53 @@ typedef struct ks_dhtrt_sortedxors_s {
|
||||
/* --- static functions ---- */
|
||||
|
||||
static
|
||||
ks_dhtrt_bucket_header_t* ks_dhtrt_create_bucketheader(
|
||||
ks_dhtrt_bucket_header_t *ks_dhtrt_create_bucketheader(
|
||||
ks_pool_t *pool,
|
||||
ks_dhtrt_bucket_header_t* parent,
|
||||
unsigned char* mask);
|
||||
ks_dhtrt_bucket_header_t *parent,
|
||||
unsigned char *mask);
|
||||
static
|
||||
ks_dhtrt_bucket_t* ks_dhtrt_create_bucket(ks_pool_t* pool);
|
||||
ks_dhtrt_bucket_t *ks_dhtrt_create_bucket(ks_pool_t *pool);
|
||||
static
|
||||
ks_dhtrt_bucket_header_t* ks_dhtrt_find_bucketheader(ks_dhtrt_routetable_t* table, ks_dhtrt_nodeid_t id);
|
||||
ks_dhtrt_bucket_header_t *ks_dhtrt_find_bucketheader(ks_dhtrt_routetable_t *table, ks_dhtrt_nodeid_t id);
|
||||
static
|
||||
ks_dhtrt_bucket_entry_t* ks_dhtrt_find_bucketentry(ks_dhtrt_bucket_header_t* header, ks_dhtrt_nodeid_t id);
|
||||
ks_dhtrt_bucket_entry_t *ks_dhtrt_find_bucketentry(ks_dhtrt_bucket_header_t *header, ks_dhtrt_nodeid_t id);
|
||||
|
||||
static
|
||||
void ks_dhtrt_split_bucket(ks_dhtrt_bucket_header_t* original, ks_dhtrt_bucket_header_t* left, ks_dhtrt_bucket_header_t* right);
|
||||
void ks_dhtrt_split_bucket(ks_dhtrt_bucket_header_t *original, ks_dhtrt_bucket_header_t *left, ks_dhtrt_bucket_header_t *right);
|
||||
static
|
||||
ks_dht_node_t* ks_dhtrt_find_nodeid(ks_dhtrt_bucket_t* bucket, ks_dhtrt_nodeid_t nodeid);
|
||||
ks_dht_node_t *ks_dhtrt_find_nodeid(ks_dhtrt_bucket_t *bucket, ks_dhtrt_nodeid_t nodeid);
|
||||
|
||||
|
||||
static void
|
||||
ks_dhtrt_shiftright(uint8_t* id);
|
||||
ks_dhtrt_shiftright(uint8_t *id);
|
||||
static
|
||||
void ks_dhtrt_shiftleft(uint8_t* id);
|
||||
void ks_dhtrt_shiftleft(uint8_t *id);
|
||||
static void
|
||||
ks_dhtrt_xor(const uint8_t* id1, const uint8_t* id2, uint8_t* xor);
|
||||
ks_dhtrt_xor(const uint8_t *id1, const uint8_t *id2, uint8_t *xor);
|
||||
static int
|
||||
ks_dhtrt_ismasked(const uint8_t* id1, const uint8_t* mask);
|
||||
ks_dhtrt_ismasked(const uint8_t *id1, const uint8_t *mask);
|
||||
|
||||
static
|
||||
ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* node);
|
||||
ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t *table, ks_dht_node_t *node);
|
||||
static
|
||||
ks_status_t ks_dhtrt_insert_id(ks_dhtrt_bucket_t* bucket, ks_dht_node_t* node);
|
||||
ks_status_t ks_dhtrt_insert_id(ks_dhtrt_bucket_t *bucket, ks_dht_node_t *node);
|
||||
static
|
||||
void ks_dhtrt_delete_id(ks_dhtrt_bucket_t* bucket, ks_dhtrt_nodeid_t id);
|
||||
void ks_dhtrt_delete_id(ks_dhtrt_bucket_t *bucket, ks_dhtrt_nodeid_t id);
|
||||
static
|
||||
char* ks_dhtrt_printableid(uint8_t* id, char* buffer);
|
||||
char *ks_dhtrt_printableid(uint8_t *id, char *buffer);
|
||||
static
|
||||
unsigned char ks_dhtrt_isactive(ks_dhtrt_bucket_entry_t* entry);
|
||||
unsigned char ks_dhtrt_isactive(ks_dhtrt_bucket_entry_t *entry);
|
||||
static
|
||||
uint8_t ks_dhtrt_load_query(ks_dhtrt_querynodes_t* query, ks_dhtrt_sortedxors_t* xort);
|
||||
uint8_t ks_dhtrt_load_query(ks_dhtrt_querynodes_t *query, ks_dhtrt_sortedxors_t *xort);
|
||||
static
|
||||
uint8_t ks_dhtrt_findclosest_bucketnodes(unsigned char *nodeid,
|
||||
ks_dhtrt_bucket_header_t* header,
|
||||
ks_dhtrt_sortedxors_t* xors,
|
||||
unsigned char* hixor,
|
||||
ks_dhtrt_bucket_header_t *header,
|
||||
ks_dhtrt_sortedxors_t *xors,
|
||||
unsigned char *hixor,
|
||||
unsigned int max);
|
||||
|
||||
static
|
||||
void ks_dhtrt_ping(ks_dhtrt_bucket_entry_t* entry);
|
||||
void ks_dhtrt_ping(ks_dhtrt_bucket_entry_t *entry);
|
||||
|
||||
|
||||
|
||||
@ -172,90 +172,110 @@ 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));
|
||||
|
||||
ks_dhtrt_routetable_t* table = ks_pool_alloc(pool, sizeof(ks_dhtrt_routetable_t));
|
||||
ks_dhtrt_routetable_t *table = ks_pool_alloc(pool, sizeof(ks_dhtrt_routetable_t));
|
||||
memset(table, 0, sizeof(ks_dhtrt_routetable_t));
|
||||
|
||||
ks_dhtrt_internal_t* internal = ks_pool_alloc(pool, sizeof(ks_dhtrt_internal_t));
|
||||
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);
|
||||
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;
|
||||
}
|
||||
|
||||
KS_DECLARE(ks_status_t) ks_dhtrt_create_node( ks_dhtrt_routetable_t* table,
|
||||
KS_DECLARE(ks_status_t) ks_dhtrt_create_node( ks_dhtrt_routetable_t *table,
|
||||
ks_dht_nodeid_t nodeid,
|
||||
char* ip,
|
||||
char *ip,
|
||||
unsigned short port,
|
||||
ks_dht_node_t** node)
|
||||
ks_dht_node_t **node)
|
||||
{
|
||||
ks_dht_node_t* tnode = ks_dhtrt_find_node(table, nodeid);
|
||||
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; }
|
||||
|
||||
for (int i = 0; i < 5; ++i) {
|
||||
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) ||
|
||||
(ks_dhtrt_insert_node(table, tnode) != KS_STATUS_SUCCESS) ) {
|
||||
if ((ks_addr_set(&tnode->addr, ip, port, tnode->family) != KS_STATUS_SUCCESS) ||
|
||||
(ks_dhtrt_insert_node(table, tnode) != KS_STATUS_SUCCESS)) {
|
||||
ks_pool_free(table->pool, tnode);
|
||||
return KS_STATUS_FAIL;
|
||||
}
|
||||
|
||||
(*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_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);
|
||||
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, node->nodeid.id);
|
||||
|
||||
if (header != 0) {
|
||||
ks_dhtrt_bucket_t* bucket = header->bucket;
|
||||
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;
|
||||
}
|
||||
|
||||
static
|
||||
ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* node)
|
||||
ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t *table, ks_dht_node_t *node)
|
||||
{
|
||||
ks_dhtrt_bucket_t* bucket = 0;
|
||||
ks_dhtrt_bucket_t *bucket = 0;
|
||||
int insanity = 0;
|
||||
|
||||
/* first see if it exists */
|
||||
ks_dht_node_t* peer = ks_dhtrt_find_node(table, node->nodeid);
|
||||
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);
|
||||
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];
|
||||
@ -299,10 +321,13 @@ ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* no
|
||||
ks_dhtrt_shiftright(newmask);
|
||||
|
||||
/* create the new bucket structures */
|
||||
ks_dhtrt_bucket_header_t* newleft = ks_dhtrt_create_bucketheader(table->pool, header, newmask);
|
||||
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_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;
|
||||
}
|
||||
@ -328,20 +352,27 @@ ks_status_t ks_dhtrt_insert_node(ks_dhtrt_routetable_t* table, ks_dht_node_t* no
|
||||
return ks_dhtrt_insert_id(bucket, node);
|
||||
}
|
||||
|
||||
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;
|
||||
ks_dhtrt_bucket_t* bucket = header->bucket;
|
||||
if (bucket == 0) return 0; /* probably a logic error ?*/
|
||||
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 NULL;
|
||||
|
||||
ks_dhtrt_bucket_t *bucket = header->bucket;
|
||||
|
||||
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_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);
|
||||
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);
|
||||
|
||||
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_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);
|
||||
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);
|
||||
|
||||
ks_dhtrt_bucket_entry_t *e = ks_dhtrt_find_bucketentry(header, nodeid.id);
|
||||
|
||||
if (e != 0) {
|
||||
e->flags = DHTPEER_EXPIRED;
|
||||
return KS_STATUS_SUCCESS;
|
||||
@ -364,16 +399,17 @@ KS_DECLARE(ks_status_t) ks_dhtrt_expire_node(ks_dhtrt_routetable_t* table, ks_d
|
||||
return KS_STATUS_FAIL;
|
||||
}
|
||||
|
||||
KS_DECLARE(uint8_t) ks_dhtrt_findclosest_nodes(ks_dhtrt_routetable_t* table, ks_dhtrt_querynodes_t* query)
|
||||
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 */
|
||||
|
||||
ks_dhtrt_bucket_header_t* header = ks_dhtrt_find_bucketheader(table, query->nodeid.id);
|
||||
query->count = 0;
|
||||
|
||||
ks_dhtrt_bucket_header_t *header = ks_dhtrt_find_bucketheader(table, query->nodeid.id);
|
||||
|
||||
#ifdef KS_DHT_DEBUGPRINTF_
|
||||
char buffer[100];
|
||||
@ -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;
|
||||
|
||||
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,29 +480,34 @@ 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);
|
||||
|
||||
int insanity = 0;
|
||||
ks_dhtrt_bucket_header_t* lheader;
|
||||
ks_dhtrt_bucket_header_t* rheader;
|
||||
ks_dhtrt_sortedxors_t* prev = &xort1;
|
||||
ks_dhtrt_sortedxors_t* tofree = 0;
|
||||
ks_dhtrt_sortedxors_t* xortn;
|
||||
ks_dhtrt_sortedxors_t* xortn1;
|
||||
ks_dhtrt_bucket_header_t *lheader;
|
||||
ks_dhtrt_bucket_header_t *rheader;
|
||||
ks_dhtrt_sortedxors_t *prev = &xort1;
|
||||
ks_dhtrt_sortedxors_t *tofree = 0;
|
||||
ks_dhtrt_sortedxors_t *xortn;
|
||||
ks_dhtrt_sortedxors_t *xortn1;
|
||||
|
||||
do {
|
||||
lheader = 0;
|
||||
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,25 +538,30 @@ 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);
|
||||
}
|
||||
|
||||
} while(max < query->count);
|
||||
} while (max < query->count);
|
||||
|
||||
|
||||
ks_dhtrt_load_query(query, &xort0);
|
||||
|
||||
/* free up the xort structs on heap */
|
||||
while(tofree) {
|
||||
ks_dhtrt_sortedxors_t* x = tofree->next;
|
||||
while (tofree) {
|
||||
ks_dhtrt_sortedxors_t *x = tofree->next;
|
||||
|
||||
ks_pool_free(table->pool, tofree);
|
||||
tofree = x->next;
|
||||
}
|
||||
|
||||
return query->count;
|
||||
}
|
||||
|
||||
KS_DECLARE(void) ks_dhtrt_process_table(ks_dhtrt_routetable_t* table)
|
||||
KS_DECLARE(void) ks_dhtrt_process_table(ks_dhtrt_routetable_t *table)
|
||||
{
|
||||
/* walk the table and update the status of all known knodes */
|
||||
/* anything that is suspect automatically becomes expired */
|
||||
@ -524,30 +575,37 @@ KS_DECLARE(void) ks_dhtrt_process_table(ks_dhtrt_routetable_t* table)
|
||||
/* inactive again it is considered inactive */
|
||||
/* */
|
||||
|
||||
ks_dhtrt_internal_t* internal = table->internal;
|
||||
ks_dhtrt_bucket_header_t* header = internal->buckets;
|
||||
ks_dhtrt_bucket_header_t* stack[KS_DHT_NODEID_SIZE * 8];
|
||||
ks_dhtrt_internal_t *internal = table->internal;
|
||||
ks_dhtrt_bucket_header_t *header = internal->buckets;
|
||||
ks_dhtrt_bucket_header_t *stack[KS_DHT_NODEID_SIZE * 8];
|
||||
int stackix=0;
|
||||
ks_time_t t0 = ks_time_now();
|
||||
|
||||
while(header) {
|
||||
while (header) {
|
||||
stack[stackix++] = header;
|
||||
|
||||
if (header->bucket) {
|
||||
ks_dhtrt_bucket_t* b = 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];
|
||||
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];
|
||||
@ -566,43 +626,49 @@ KS_DECLARE(void) ks_dhtrt_process_table(ks_dhtrt_routetable_t* table)
|
||||
}
|
||||
|
||||
|
||||
KS_DECLARE(void) ks_dhtrt_dump(ks_dhtrt_routetable_t* table, int level) {
|
||||
KS_DECLARE(void) ks_dhtrt_dump(ks_dhtrt_routetable_t *table, int level) {
|
||||
/* dump buffer headers */
|
||||
char buffer[100];
|
||||
memset(buffer, 0, 100);
|
||||
ks_dhtrt_internal_t* internal = table->internal;
|
||||
ks_dhtrt_bucket_header_t* header = internal->buckets;
|
||||
ks_dhtrt_bucket_header_t* stack[KS_DHT_NODEID_SIZE * 8];
|
||||
ks_dhtrt_internal_t *internal = table->internal;
|
||||
ks_dhtrt_bucket_header_t *header = internal->buckets;
|
||||
ks_dhtrt_bucket_header_t *stack[KS_DHT_NODEID_SIZE * 8];
|
||||
int stackix = 0;
|
||||
|
||||
while(header) {
|
||||
while (header) {
|
||||
stack[stackix++] = header;
|
||||
/* 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;
|
||||
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) {
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
@ -611,9 +677,10 @@ KS_DECLARE(void) ks_dhtrt_dump(ks_dhtrt_routetable_t* table, int level) {
|
||||
*/
|
||||
|
||||
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 *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));
|
||||
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;
|
||||
@ -628,41 +695,47 @@ ks_dhtrt_bucket_header_t* ks_dhtrt_create_bucketheader(ks_pool_t *pool, ks_dhtrt
|
||||
}
|
||||
|
||||
static
|
||||
ks_dhtrt_bucket_t* ks_dhtrt_create_bucket(ks_pool_t *pool)
|
||||
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));
|
||||
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;
|
||||
}
|
||||
|
||||
static
|
||||
ks_dhtrt_bucket_header_t* ks_dhtrt_find_bucketheader(ks_dhtrt_routetable_t* table, ks_dhtrt_nodeid_t id)
|
||||
ks_dhtrt_bucket_header_t *ks_dhtrt_find_bucketheader(ks_dhtrt_routetable_t *table, ks_dhtrt_nodeid_t id)
|
||||
{
|
||||
/* find the right bucket.
|
||||
if a bucket header has a bucket, it does not children
|
||||
so it must be the bucket to use
|
||||
*/
|
||||
ks_dhtrt_internal_t* internal = table->internal;
|
||||
ks_dhtrt_bucket_header_t* header = internal->buckets;
|
||||
while(header) {
|
||||
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_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;
|
||||
ks_dhtrt_bucket_t *bucket = header->bucket;
|
||||
|
||||
if (bucket == 0) return NULL;
|
||||
|
||||
for (int ix=0; ix<KS_DHT_BUCKETSIZE; ++ix) {
|
||||
#ifdef KS_DHT_DEBUGPRINTF_
|
||||
@ -672,20 +745,21 @@ ks_dhtrt_bucket_entry_t* ks_dhtrt_find_bucketentry(ks_dhtrt_bucket_header_t* hea
|
||||
return &(bucket->entries[ix]);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
static
|
||||
void ks_dhtrt_split_bucket(ks_dhtrt_bucket_header_t* original,
|
||||
ks_dhtrt_bucket_header_t* left,
|
||||
ks_dhtrt_bucket_header_t* right)
|
||||
void ks_dhtrt_split_bucket(ks_dhtrt_bucket_header_t *original,
|
||||
ks_dhtrt_bucket_header_t *left,
|
||||
ks_dhtrt_bucket_header_t *right)
|
||||
{
|
||||
/* so split the bucket in two based on the masks in the new header */
|
||||
/* the existing bucket - with the remaining ids will be taken by the right hand side */
|
||||
|
||||
ks_dhtrt_bucket_t* source = original->bucket;
|
||||
ks_dhtrt_bucket_t* dest = left->bucket;
|
||||
ks_dhtrt_bucket_t *source = original->bucket;
|
||||
ks_dhtrt_bucket_t *dest = left->bucket;
|
||||
|
||||
int lix = 0;
|
||||
int rix = 0;
|
||||
@ -696,7 +770,7 @@ void ks_dhtrt_split_bucket(ks_dhtrt_bucket_header_t* original,
|
||||
/*ks_rwl_write_lock(source->lock);*/
|
||||
source->locked=1;
|
||||
|
||||
for( ; rix<KS_DHT_BUCKETSIZE; ++rix) {
|
||||
for ( ; rix<KS_DHT_BUCKETSIZE; ++rix) {
|
||||
if (ks_dhtrt_ismasked(source->entries[rix].id, left->mask)) {
|
||||
/* move it to the left */
|
||||
memcpy(dest->entries[lix].id, source->entries[rix].id, KS_DHT_NODEID_SIZE);
|
||||
@ -737,18 +811,20 @@ void ks_dhtrt_split_bucket(ks_dhtrt_bucket_header_t* original,
|
||||
* so at least the static array does away with the need for locking.
|
||||
*/
|
||||
static
|
||||
ks_status_t ks_dhtrt_insert_id(ks_dhtrt_bucket_t* bucket, ks_dht_node_t* node)
|
||||
ks_status_t ks_dhtrt_insert_id(ks_dhtrt_bucket_t *bucket, ks_dht_node_t *node)
|
||||
{
|
||||
/* sanity checks */
|
||||
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) {
|
||||
|
||||
for (; ix<KS_DHT_BUCKETSIZE; ++ix) {
|
||||
if (bucket->entries[ix].inuse == 0) {
|
||||
if (free == KS_DHT_BUCKETSIZE) {
|
||||
free = ix; /* use this one */
|
||||
@ -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);*/
|
||||
/* ********************** */
|
||||
@ -805,7 +883,7 @@ ks_status_t ks_dhtrt_insert_id(ks_dhtrt_bucket_t* bucket, ks_dht_node_t* node)
|
||||
}
|
||||
|
||||
static
|
||||
ks_dht_node_t* ks_dhtrt_find_nodeid(ks_dhtrt_bucket_t* bucket, ks_dhtrt_nodeid_t id)
|
||||
ks_dht_node_t *ks_dhtrt_find_nodeid(ks_dhtrt_bucket_t *bucket, ks_dhtrt_nodeid_t id)
|
||||
{
|
||||
#ifdef KS_DHT_DEBUGPRINTF_
|
||||
char buffer[100];
|
||||
@ -827,11 +905,11 @@ 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
|
||||
void ks_dhtrt_delete_id(ks_dhtrt_bucket_t* bucket, ks_dhtrt_nodeid_t id)
|
||||
void ks_dhtrt_delete_id(ks_dhtrt_bucket_t *bucket, ks_dhtrt_nodeid_t id)
|
||||
{
|
||||
#ifdef KS_DHT_DEBUGPRINTF_
|
||||
|
||||
@ -859,9 +937,9 @@ void ks_dhtrt_delete_id(ks_dhtrt_bucket_t* bucket, ks_dhtrt_nodeid_t id)
|
||||
|
||||
static
|
||||
uint8_t ks_dhtrt_findclosest_bucketnodes(ks_dhtrt_nodeid_t id,
|
||||
ks_dhtrt_bucket_header_t* header,
|
||||
ks_dhtrt_sortedxors_t* xors,
|
||||
unsigned char* hixor, /*todo: remove */
|
||||
ks_dhtrt_bucket_header_t *header,
|
||||
ks_dhtrt_sortedxors_t *xors,
|
||||
unsigned char *hixor, /*todo: remove */
|
||||
unsigned int max) {
|
||||
|
||||
uint8_t count = 0; /* count of nodes added this time */
|
||||
@ -872,7 +950,7 @@ uint8_t ks_dhtrt_findclosest_bucketnodes(ks_dhtrt_nodeid_t id,
|
||||
/* just ugh! - there must be a better way to do this */
|
||||
/* walk the entire bucket calculating the xor value on the way */
|
||||
/* add valid & relevant entries to the xor values */
|
||||
ks_dhtrt_bucket_t* bucket = header->bucket;
|
||||
ks_dhtrt_bucket_t *bucket = header->bucket;
|
||||
|
||||
if (bucket == 0) { /* sanity */
|
||||
#ifdef KS_DHT_DEBUGPRINTF_
|
||||
@ -883,7 +961,7 @@ uint8_t ks_dhtrt_findclosest_bucketnodes(ks_dhtrt_nodeid_t id,
|
||||
|
||||
}
|
||||
|
||||
for(uint8_t ix=0; ix<KS_DHT_BUCKETSIZE; ++ix) {
|
||||
for (uint8_t ix=0; ix<KS_DHT_BUCKETSIZE; ++ix) {
|
||||
if ( bucket->entries[ix].inuse == 1 &&
|
||||
ks_dhtrt_isactive( &(bucket->entries[ix])) ) {
|
||||
|
||||
@ -900,7 +978,7 @@ uint8_t ks_dhtrt_findclosest_bucketnodes(ks_dhtrt_nodeid_t id,
|
||||
unsigned int xorix = xors->startix; /* start of ordered list */
|
||||
unsigned int prev_xorix = KS_DHT_BUCKETSIZE;
|
||||
|
||||
for(int ix2=0; ix2<count; ++ix2) {
|
||||
for (int ix2=0; ix2<count; ++ix2) {
|
||||
if (memcmp(xorvalue, xors->xort[xorix].xor, KS_DHT_NODEID_SIZE) > 0) {
|
||||
|
||||
break; /* insert before xorix, after prev_xoris */
|
||||
@ -919,24 +997,24 @@ 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 */
|
||||
}
|
||||
|
||||
static
|
||||
uint8_t ks_dhtrt_load_query(ks_dhtrt_querynodes_t* query, ks_dhtrt_sortedxors_t* xort)
|
||||
uint8_t ks_dhtrt_load_query(ks_dhtrt_querynodes_t *query, ks_dhtrt_sortedxors_t *xort)
|
||||
{
|
||||
ks_dhtrt_sortedxors_t* current = xort;
|
||||
ks_dhtrt_sortedxors_t *current = xort;
|
||||
uint8_t loaded = 0;
|
||||
while(current) {
|
||||
while (current) {
|
||||
#ifdef KS_DHT_DEBUGPRINTF_
|
||||
char buf[100];
|
||||
printf(" loadquery from bucket %s count %d\n",
|
||||
@ -955,11 +1033,11 @@ uint8_t ks_dhtrt_load_query(ks_dhtrt_querynodes_t* query, ks_dhtrt_sortedxors_t*
|
||||
return loaded;
|
||||
}
|
||||
|
||||
void ks_dhtrt_ping(ks_dhtrt_bucket_entry_t* entry) {
|
||||
void ks_dhtrt_ping(ks_dhtrt_bucket_entry_t *entry) {
|
||||
++entry->outstanding_pings;
|
||||
/* @todo */
|
||||
/* set the appropriate command in the node and queue if for processing */
|
||||
/*ks_dht_node_t* node = entry->gptr; */
|
||||
/*ks_dht_node_t *node = entry->gptr; */
|
||||
#ifdef KS_DHT_DEBUGPRINTF_
|
||||
char buf[100];
|
||||
printf(" ping queued for nodeid %s count %d\n",
|
||||
@ -974,12 +1052,12 @@ void ks_dhtrt_ping(ks_dhtrt_bucket_entry_t* entry) {
|
||||
so format must be a right filled mask (hex: ..ffffffff)
|
||||
*/
|
||||
static
|
||||
void ks_dhtrt_shiftright(uint8_t* id)
|
||||
void ks_dhtrt_shiftright(uint8_t *id)
|
||||
{
|
||||
unsigned char b0 = 0;
|
||||
unsigned char b1 = 0;
|
||||
|
||||
for(int i = KS_DHT_NODEID_SIZE-1; i >= 0; --i) {
|
||||
for (int i = KS_DHT_NODEID_SIZE-1; i >= 0; --i) {
|
||||
if (id[i] == 0) break; /* beyond mask- we are done */
|
||||
b1 = id[i] & 0x01;
|
||||
id[i] >>= 1;
|
||||
@ -992,9 +1070,9 @@ void ks_dhtrt_shiftright(uint8_t* id)
|
||||
}
|
||||
|
||||
static
|
||||
void ks_dhtrt_shiftleft(uint8_t* id) {
|
||||
void ks_dhtrt_shiftleft(uint8_t *id) {
|
||||
|
||||
for(int i = KS_DHT_NODEID_SIZE-1; i >= 0; --i) {
|
||||
for (int i = KS_DHT_NODEID_SIZE-1; i >= 0; --i) {
|
||||
if (id[i] == 0xff) continue;
|
||||
id[i] <<= 1;
|
||||
id[i] |= 0x01;
|
||||
@ -1006,13 +1084,13 @@ void ks_dhtrt_shiftleft(uint8_t* id) {
|
||||
/* Determine whether id1 or id2 is closer to ref */
|
||||
|
||||
/*
|
||||
@todo: remove ? simple memcpy seems to do the job ?
|
||||
@todo: remove ? simple memcpy seems to do the job ?
|
||||
|
||||
static int
|
||||
ks_dhtrt_xorcmp(const uint8_t* id1, const uint8_t* id2, const uint8_t* ref);
|
||||
static int
|
||||
ks_dhtrt_xorcmp(const uint8_t *id1, const uint8_t *id2, const uint8_t *ref);
|
||||
|
||||
static int ks_dhtrt_xorcmp(const uint8_t* id1, const uint8_t* id2, const uint8_t* ref)
|
||||
{
|
||||
static int ks_dhtrt_xorcmp(const uint8_t *id1, const uint8_t *id2, const uint8_t *ref)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < KS_DHT_NODEID_SIZE; i++) {
|
||||
uint8_t xor1, xor2;
|
||||
@ -1027,12 +1105,12 @@ static int ks_dhtrt_xorcmp(const uint8_t* id1, const uint8_t* id2, const uint8_t
|
||||
return 1; / * id2 is closer * /
|
||||
}
|
||||
return 0; / * id2 and id2 are identical ! * /
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
|
||||
/* create an xor value from two ids */
|
||||
static void ks_dhtrt_xor(const uint8_t* id1, const uint8_t* id2, uint8_t* xor)
|
||||
static void ks_dhtrt_xor(const uint8_t *id1, const uint8_t *id2, uint8_t *xor)
|
||||
{
|
||||
for (int i = 0; i < KS_DHT_NODEID_SIZE; ++i) {
|
||||
if (id1[i] == id2[i]) {
|
||||
@ -1044,7 +1122,7 @@ static void ks_dhtrt_xor(const uint8_t* id1, const uint8_t* id2, uint8_t* xor)
|
||||
}
|
||||
|
||||
/* is id masked by mask 1 => yes, 0=> no */
|
||||
static int ks_dhtrt_ismasked(const uint8_t* id, const unsigned char *mask)
|
||||
static int ks_dhtrt_ismasked(const uint8_t *id, const unsigned char *mask)
|
||||
{
|
||||
for (int i = 0; i < KS_DHT_NODEID_SIZE; ++i) {
|
||||
if (mask[i] == 0 && id[i] != 0) return 0;
|
||||
@ -1054,9 +1132,9 @@ static int ks_dhtrt_ismasked(const uint8_t* id, const unsigned char *mask)
|
||||
return 1;
|
||||
}
|
||||
|
||||
static char* ks_dhtrt_printableid(uint8_t* id, char* buffer)
|
||||
static char *ks_dhtrt_printableid(uint8_t *id, char *buffer)
|
||||
{
|
||||
char* t = buffer;
|
||||
char *t = buffer;
|
||||
memset(buffer, 0, KS_DHT_NODEID_SIZE*2);
|
||||
for (int i = 0; i < KS_DHT_NODEID_SIZE; ++i, buffer+=2) {
|
||||
sprintf(buffer, "%02x", id[i]);
|
||||
@ -1064,7 +1142,7 @@ static char* ks_dhtrt_printableid(uint8_t* id, char* buffer)
|
||||
return t;
|
||||
}
|
||||
|
||||
unsigned char ks_dhtrt_isactive(ks_dhtrt_bucket_entry_t* entry)
|
||||
unsigned char ks_dhtrt_isactive(ks_dhtrt_bucket_entry_t *entry)
|
||||
{
|
||||
/* todo */
|
||||
return 1;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user