format cleanup

libs/libks/src/dht/ks_dht.c

@@ -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);
 		}
 	}
 	

libs/libks/src/dht/ks_dht.h

@@ -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,

libs/libks/src/dht/ks_dht_bucket.c

 /*
- * 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;