1 files changed, 258 insertions, 203 deletions

diff --git a/core/DHT.c b/core/DHT.c
index c3249846..226a38ca 100644
--- a/core/DHT.c
+++ b/core/DHT.c
@@ -77,7 +77,7 @@ typedef struct {
     /* Symetric NAT hole punching stuff */
 
     /* 1 if currently hole punching, otherwise 0 */
-    uint8_t     hole_punching; 
+    uint8_t     hole_punching;
     uint32_t    punching_index;
     uint64_t    punching_timestamp;
     uint64_t    recvNATping_timestamp;
@@ -98,11 +98,11 @@ typedef struct {
 
 /*----------------------------------------------------------------------------------*/
 
-                    /* Our client id/public key */
+/* Our client id/public key */
 uint8_t             self_public_key[CLIENT_ID_SIZE];
 uint8_t             self_secret_key[crypto_box_SECRETKEYBYTES];
 static Client_data  close_clientlist[LCLIENT_LIST];
-static Friend *     friends_list;
+static Friend      *friends_list;
 static uint16_t     num_friends;
 static Pinged       send_nodes[LSEND_NODES_ARRAY];
 static Node_format  toping[MAX_TOPING];
@@ -111,7 +111,7 @@ static uint64_t     last_toping;
 /*----------------------------------------------------------------------------------*/
 
 
-Client_data * DHT_get_close_list(void)
+Client_data *DHT_get_close_list(void)
 {
     return close_clientlist;
 }
@@ -121,37 +121,39 @@ Client_data * DHT_get_close_list(void)
  * return 1 if client_id1 is closer
  * return 2 if client_id2 is closer
  */
-static int id_closest(uint8_t * id, uint8_t * id1, uint8_t * id2)
+static int id_closest(uint8_t *id, uint8_t *id1, uint8_t *id2)
 {
     size_t   i;
     uint8_t distance1, distance2;
 
-    for(i = 0; i < CLIENT_ID_SIZE; ++i) {
+    for (i = 0; i < CLIENT_ID_SIZE; ++i) {
 
         distance1 = abs(id[i] ^ id1[i]);
         distance2 = abs(id[i] ^ id2[i]);
-        
-        if(distance1 < distance2)
+
+        if (distance1 < distance2)
             return 1;
-        if(distance1 > distance2)
+
+        if (distance1 > distance2)
             return 2;
     }
+
     return 0;
 }
 
 static int ipport_equal(IP_Port a, IP_Port b)
 {
-  return (a.ip.i == b.ip.i) && (a.port == b.port);
+    return (a.ip.i == b.ip.i) && (a.port == b.port);
 }
 
-static int id_equal(uint8_t* a, uint8_t* b)
+static int id_equal(uint8_t *a, uint8_t *b)
 {
-  return memcmp(a, b, CLIENT_ID_SIZE) == 0;
+    return memcmp(a, b, CLIENT_ID_SIZE) == 0;
 }
 
 static int is_timeout(uint64_t time_now, uint64_t timestamp, uint64_t timeout)
 {
-  return timestamp + timeout <= time_now;
+    return timestamp + timeout <= time_now;
 }
 
 /* check if client with client_id is already in list of length length.
@@ -161,18 +163,18 @@ static int is_timeout(uint64_t time_now, uint64_t timestamp, uint64_t timeout)
  *
  * TODO: maybe optimize this.
  */
-static int client_in_list(Client_data * list, uint32_t length, uint8_t * client_id, IP_Port ip_port)
+static int client_in_list(Client_data *list, uint32_t length, uint8_t *client_id, IP_Port ip_port)
 {
     uint32_t i;
     uint64_t temp_time = unix_time();
 
-    for(i = 0; i < length; ++i) {
+    for (i = 0; i < length; ++i) {
         /*If ip_port is assigned to a different client_id replace it*/
-        if(ipport_equal(list[i].ip_port, ip_port)) {
+        if (ipport_equal(list[i].ip_port, ip_port)) {
             memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE);
         }
 
-        if(id_equal(list[i].client_id, client_id)) {
+        if (id_equal(list[i].client_id, client_id)) {
             /* Refresh the client timestamp. */
             list[i].timestamp = temp_time;
             list[i].ip_port.ip.i = ip_port.ip.i;
@@ -180,18 +182,19 @@ static int client_in_list(Client_data * list, uint32_t length, uint8_t * client_
             return 1;
         }
     }
+
     return 0;
 }
 
 /* check if client with client_id is already in node format list of length length.
  * return True(1) or False(0)
  */
-static int client_in_nodelist(Node_format * list, uint32_t length, uint8_t * client_id)
+static int client_in_nodelist(Node_format *list, uint32_t length, uint8_t *client_id)
 {
     uint32_t i;
 
-    for(i = 0; i < length; ++i) {
-        if(id_equal(list[i].client_id, client_id))
+    for (i = 0; i < length; ++i) {
+        if (id_equal(list[i].client_id, client_id))
             return 1;
     }
 
@@ -200,12 +203,12 @@ static int client_in_nodelist(Node_format * list, uint32_t length, uint8_t * cli
 
 /* Returns the friend number from the client_id, or -1 if a failure occurs
  */
-static int friend_number(uint8_t * client_id)
+static int friend_number(uint8_t *client_id)
 {
     uint32_t i;
 
-    for(i = 0; i < num_friends; ++i) {
-        if(id_equal(friends_list[i].client_id, client_id))
+    for (i = 0; i < num_friends; ++i) {
+        if (id_equal(friends_list[i].client_id, client_id))
             return i;
     }
 
@@ -217,7 +220,7 @@ static int friend_number(uint8_t * client_id)
  *
  * TODO: For the love of based Allah make this function cleaner and much more efficient.
  */
-static int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
+static int get_close_nodes(uint8_t *client_id, Node_format *nodes_list)
 {
     uint32_t    i, j, k;
     uint64_t    temp_time = unix_time();
@@ -228,13 +231,13 @@ static int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
         inlist = client_in_nodelist(nodes_list, MAX_SENT_NODES, close_clientlist[i].client_id);
 
         /* if node isn't good or is already in list. */
-        if(tout || inlist)
+        if (tout || inlist)
             continue;
 
-        if(num_nodes < MAX_SENT_NODES) {
+        if (num_nodes < MAX_SENT_NODES) {
 
-            memcpy( nodes_list[num_nodes].client_id, 
-                    close_clientlist[i].client_id, 
+            memcpy( nodes_list[num_nodes].client_id,
+                    close_clientlist[i].client_id,
                     CLIENT_ID_SIZE );
 
             nodes_list[num_nodes].ip_port = close_clientlist[i].ip_port;
@@ -242,13 +245,14 @@ static int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
 
         } else {
 
-            for(j = 0; j < MAX_SENT_NODES; ++j) {
-                closest = id_closest(   client_id, 
-                                        nodes_list[j].client_id, 
+            for (j = 0; j < MAX_SENT_NODES; ++j) {
+                closest = id_closest(   client_id,
+                                        nodes_list[j].client_id,
                                         close_clientlist[i].client_id );
-                if(closest == 2) {
-                    memcpy( nodes_list[j].client_id, 
-                            close_clientlist[i].client_id, 
+
+                if (closest == 2) {
+                    memcpy( nodes_list[j].client_id,
+                            close_clientlist[i].client_id,
                             CLIENT_ID_SIZE);
 
                     nodes_list[j].ip_port = close_clientlist[i].ip_port;
@@ -258,35 +262,36 @@ static int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
         }
     }
 
-    for(i = 0; i < num_friends; ++i) {
-        for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
+    for (i = 0; i < num_friends; ++i) {
+        for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
 
             tout = is_timeout(temp_time, friends_list[i].client_list[j].timestamp, BAD_NODE_TIMEOUT);
             inlist = client_in_nodelist(    nodes_list,
-                                            MAX_SENT_NODES, 
+                                            MAX_SENT_NODES,
                                             friends_list[i].client_list[j].client_id);
 
             /* if node isn't good or is already in list. */
-            if(tout || inlist)
+            if (tout || inlist)
                 continue;
 
-            if(num_nodes < MAX_SENT_NODES) {
+            if (num_nodes < MAX_SENT_NODES) {
 
-                memcpy( nodes_list[num_nodes].client_id, 
-                        friends_list[i].client_list[j].client_id, 
+                memcpy( nodes_list[num_nodes].client_id,
+                        friends_list[i].client_list[j].client_id,
                         CLIENT_ID_SIZE);
 
                 nodes_list[num_nodes].ip_port = friends_list[i].client_list[j].ip_port;
                 num_nodes++;
             } else  {
-                for(k = 0; k < MAX_SENT_NODES; ++k) {
+                for (k = 0; k < MAX_SENT_NODES; ++k) {
 
-                    closest = id_closest(   client_id, 
-                                            nodes_list[k].client_id, 
+                    closest = id_closest(   client_id,
+                                            nodes_list[k].client_id,
                                             friends_list[i].client_list[j].client_id );
-                    if(closest == 2) {
-                        memcpy( nodes_list[k].client_id, 
-                                friends_list[i].client_list[j].client_id, 
+
+                    if (closest == 2) {
+                        memcpy( nodes_list[k].client_id,
+                                friends_list[i].client_list[j].client_id,
                                 CLIENT_ID_SIZE );
 
                         nodes_list[k].ip_port = friends_list[i].client_list[j].ip_port;
@@ -296,6 +301,7 @@ static int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
             }
         }
     }
+
     return num_nodes;
 }
 
@@ -303,16 +309,17 @@ static int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
  * return 0 if successful
  * return 1 if not (list contains no bad nodes)
  */
-static int replace_bad(    Client_data *   list, 
-                    uint32_t        length,  
-                    uint8_t *       client_id,   
-                    IP_Port         ip_port )
+static int replace_bad(    Client_data    *list,
+                           uint32_t        length,
+                           uint8_t        *client_id,
+                           IP_Port         ip_port )
 {
     uint32_t i;
     uint64_t temp_time = unix_time();
-    for(i = 0; i < length; ++i) {
+
+    for (i = 0; i < length; ++i) {
         /* if node is bad */
-        if(is_timeout(temp_time, list[i].timestamp, BAD_NODE_TIMEOUT)) {
+        if (is_timeout(temp_time, list[i].timestamp, BAD_NODE_TIMEOUT)) {
             memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE);
             list[i].ip_port = ip_port;
             list[i].timestamp = temp_time;
@@ -325,42 +332,46 @@ static int replace_bad(    Client_data *   list,
 
     return 1;
 }
-/*Sort the list. It will be sorted from furthest to closest. 
+/*Sort the list. It will be sorted from furthest to closest.
   TODO: this is innefficient and needs to be optimized.*/
 static void sort_list(Client_data *list, uint32_t length, uint8_t *comp_client_id)
 {
-    if(length == 0)
+    if (length == 0)
         return;
+
     uint32_t i, count;
-    while(1) {
+
+    while (1) {
         count = 0;
-        for(i = 0; i < (length - 1); ++i) {
-            if(id_closest(comp_client_id, list[i].client_id, list[i + 1].client_id) == 1) {
+
+        for (i = 0; i < (length - 1); ++i) {
+            if (id_closest(comp_client_id, list[i].client_id, list[i + 1].client_id) == 1) {
                 Client_data temp = list[i + 1];
                 list[i + 1] = list[i];
                 list[i] = temp;
                 ++count;
             }
         }
-        if(count == 0)
+
+        if (count == 0)
             return;
     }
 }
 
 
 /* replace the first good node that is further to the comp_client_id than that of the client_id in the list */
-static int replace_good(   Client_data *   list,
-                    uint32_t        length, 
-                    uint8_t *       client_id, 
-                    IP_Port         ip_port, 
-                    uint8_t *       comp_client_id )
+static int replace_good(   Client_data    *list,
+                           uint32_t        length,
+                           uint8_t        *client_id,
+                           IP_Port         ip_port,
+                           uint8_t        *comp_client_id )
 {
     uint32_t i;
     uint64_t temp_time = unix_time();
     sort_list(list, length, comp_client_id);
 
-    for(i = 0; i < length; ++i)
-        if(id_closest(comp_client_id, list[i].client_id, client_id) == 2) {
+    for (i = 0; i < length; ++i)
+        if (id_closest(comp_client_id, list[i].client_id, client_id) == 2) {
             memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE);
             list[i].ip_port = ip_port;
             list[i].timestamp = temp_time;
@@ -373,42 +384,42 @@ static int replace_good(   Client_data *   list,
     return 1;
 }
 
-/* Attempt to add client with ip_port and client_id to the friends client list 
- * and close_clientlist 
+/* Attempt to add client with ip_port and client_id to the friends client list
+ * and close_clientlist
  */
-void addto_lists(IP_Port ip_port, uint8_t * client_id)
+void addto_lists(IP_Port ip_port, uint8_t *client_id)
 {
     uint32_t i;
 
     /* NOTE: current behavior if there are two clients with the same id is
-     * to replace the first ip by the second. 
+     * to replace the first ip by the second.
      */
     if (!client_in_list(close_clientlist, LCLIENT_LIST, client_id, ip_port)) {
         if (replace_bad(close_clientlist, LCLIENT_LIST, client_id, ip_port)) {
             /* if we can't replace bad nodes we try replacing good ones */
-            replace_good(   close_clientlist, 
-                            LCLIENT_LIST, 
-                            client_id, 
-                            ip_port, 
+            replace_good(   close_clientlist,
+                            LCLIENT_LIST,
+                            client_id,
+                            ip_port,
                             self_public_key );
         }
     }
 
     for (i = 0; i < num_friends; ++i) {
-        if (!client_in_list(    friends_list[i].client_list, 
-                                MAX_FRIEND_CLIENTS, 
-                                client_id, 
+        if (!client_in_list(    friends_list[i].client_list,
+                                MAX_FRIEND_CLIENTS,
+                                client_id,
                                 ip_port )) {
 
-            if (replace_bad(    friends_list[i].client_list, 
+            if (replace_bad(    friends_list[i].client_list,
                                 MAX_FRIEND_CLIENTS,
-                                client_id, 
+                                client_id,
                                 ip_port )) {
                 /* if we can't replace bad nodes we try replacing good ones. */
-                replace_good(   friends_list[i].client_list, 
-                                MAX_FRIEND_CLIENTS, 
-                                client_id, 
-                                ip_port, 
+                replace_good(   friends_list[i].client_list,
+                                MAX_FRIEND_CLIENTS,
+                                client_id,
+                                ip_port,
                                 friends_list[i].client_id );
             }
         }
@@ -418,7 +429,7 @@ void addto_lists(IP_Port ip_port, uint8_t * client_id)
 /* If client_id is a friend or us, update ret_ip_port
  * nodeclient_id is the id of the node that sent us this info
  */
-static void returnedip_ports(IP_Port ip_port, uint8_t * client_id, uint8_t * nodeclient_id)
+static void returnedip_ports(IP_Port ip_port, uint8_t *client_id, uint8_t *nodeclient_id)
 {
     uint32_t i, j;
     uint64_t temp_time = unix_time();
@@ -458,17 +469,17 @@ static int is_gettingnodes(IP_Port ip_port, uint64_t ping_id)
     uint8_t pinging;
     uint64_t temp_time = unix_time();
 
-    for(i = 0; i < LSEND_NODES_ARRAY; ++i ) {
-        if(!is_timeout(temp_time, send_nodes[i].timestamp, PING_TIMEOUT)) {
+    for (i = 0; i < LSEND_NODES_ARRAY; ++i ) {
+        if (!is_timeout(temp_time, send_nodes[i].timestamp, PING_TIMEOUT)) {
             pinging = 0;
 
-            if(ip_port.ip.i != 0 && ipport_equal(send_nodes[i].ip_port, ip_port))
-                    ++pinging;
+            if (ip_port.ip.i != 0 && ipport_equal(send_nodes[i].ip_port, ip_port))
+                ++pinging;
 
-            if(ping_id != 0 && send_nodes[i].ping_id == ping_id)
-                    ++pinging;
+            if (ping_id != 0 && send_nodes[i].ping_id == ping_id)
+                ++pinging;
 
-            if(pinging == (ping_id != 0) + (ip_port.ip.i != 0))
+            if (pinging == (ping_id != 0) + (ip_port.ip.i != 0))
                 return 1;
         }
     }
@@ -483,9 +494,9 @@ static uint64_t add_gettingnodes(IP_Port ip_port)
     uint64_t ping_id = ((uint64_t)random_int() << 32) + random_int();
     uint64_t temp_time = unix_time();
 
-    for(i = 0; i < PING_TIMEOUT; ++i ) {
-        for(j = 0; j < LSEND_NODES_ARRAY; ++j ) {
-            if(is_timeout(temp_time, send_nodes[j].timestamp, PING_TIMEOUT - i)) {
+    for (i = 0; i < PING_TIMEOUT; ++i ) {
+        for (j = 0; j < LSEND_NODES_ARRAY; ++j ) {
+            if (is_timeout(temp_time, send_nodes[j].timestamp, PING_TIMEOUT - i)) {
                 send_nodes[j].timestamp = temp_time;
                 send_nodes[j].ip_port = ip_port;
                 send_nodes[j].ping_id = ping_id;
@@ -498,15 +509,15 @@ static uint64_t add_gettingnodes(IP_Port ip_port)
 }
 
 /* send a getnodes request */
-static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id)
+static int getnodes(IP_Port ip_port, uint8_t *public_key, uint8_t *client_id)
 {
     /* check if packet is gonna be sent to ourself */
-    if(id_equal(public_key, self_public_key) || is_gettingnodes(ip_port, 0))
+    if (id_equal(public_key, self_public_key) || is_gettingnodes(ip_port, 0))
         return 1;
 
     uint64_t ping_id = add_gettingnodes(ip_port);
 
-    if(ping_id == 0)
+    if (ping_id == 0)
         return 1;
 
     uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING];
@@ -518,14 +529,14 @@ static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id)
     memcpy(plain, &ping_id, sizeof(ping_id));
     memcpy(plain + sizeof(ping_id), client_id, CLIENT_ID_SIZE);
 
-    int len = encrypt_data( public_key, 
-                            self_secret_key, 
-                            nonce, 
-                            plain, 
-                            sizeof(ping_id) + CLIENT_ID_SIZE, 
+    int len = encrypt_data( public_key,
+                            self_secret_key,
+                            nonce,
+                            plain,
+                            sizeof(ping_id) + CLIENT_ID_SIZE,
                             encrypt );
 
-    if(len != sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING)
+    if (len != sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING)
         return -1;
 
     data[0] = 2;
@@ -537,10 +548,10 @@ static int getnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id)
 }
 
 /* send a send nodes response */
-static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id, uint64_t ping_id)
+static int sendnodes(IP_Port ip_port, uint8_t *public_key, uint8_t *client_id, uint64_t ping_id)
 {
     /* check if packet is gonna be sent to ourself */
-    if(id_equal(public_key, self_public_key)) 
+    if (id_equal(public_key, self_public_key))
         return 1;
 
     uint8_t data[1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + sizeof(ping_id)
@@ -549,7 +560,7 @@ static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id,
     Node_format nodes_list[MAX_SENT_NODES];
     int num_nodes = get_close_nodes(client_id, nodes_list);
 
-    if(num_nodes == 0)
+    if (num_nodes == 0)
         return 0;
 
     uint8_t plain[sizeof(ping_id) + sizeof(Node_format) * MAX_SENT_NODES];
@@ -560,14 +571,14 @@ static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id,
     memcpy(plain, &ping_id, sizeof(ping_id));
     memcpy(plain + sizeof(ping_id), nodes_list, num_nodes * sizeof(Node_format));
 
-    int len = encrypt_data( public_key, 
-                            self_secret_key, 
-                            nonce, 
+    int len = encrypt_data( public_key,
+                            self_secret_key,
+                            nonce,
                             plain,
-                            sizeof(ping_id) + num_nodes * sizeof(Node_format), 
+                            sizeof(ping_id) + num_nodes * sizeof(Node_format),
                             encrypt );
 
-    if(len != sizeof(ping_id) + num_nodes * sizeof(Node_format) + ENCRYPTION_PADDING)
+    if (len != sizeof(ping_id) + num_nodes * sizeof(Node_format) + ENCRYPTION_PADDING)
         return -1;
 
     data[0] = 3;
@@ -578,11 +589,11 @@ static int sendnodes(IP_Port ip_port, uint8_t * public_key, uint8_t * client_id,
     return sendpacket(ip_port, data, 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES + len);
 }
 
-static int handle_getnodes(IP_Port source, uint8_t * packet, uint32_t length)
+static int handle_getnodes(IP_Port source, uint8_t *packet, uint32_t length)
 {
     uint64_t ping_id;
 
-    if (length != ( 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES 
+    if (length != ( 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES
                     + sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING ))
         return 1;
 
@@ -592,11 +603,11 @@ static int handle_getnodes(IP_Port source, uint8_t * packet, uint32_t length)
 
     uint8_t plain[sizeof(ping_id) + CLIENT_ID_SIZE];
 
-    int len = decrypt_data( packet + 1, 
-                            self_secret_key, 
+    int len = decrypt_data( packet + 1,
+                            self_secret_key,
                             packet + 1 + CLIENT_ID_SIZE,
                             packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-                            sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING, 
+                            sizeof(ping_id) + CLIENT_ID_SIZE + ENCRYPTION_PADDING,
                             plain );
 
     if (len != sizeof(ping_id) + CLIENT_ID_SIZE)
@@ -610,32 +621,33 @@ static int handle_getnodes(IP_Port source, uint8_t * packet, uint32_t length)
     return 0;
 }
 
-static int handle_sendnodes(IP_Port source, uint8_t * packet, uint32_t length)
+static int handle_sendnodes(IP_Port source, uint8_t *packet, uint32_t length)
 {
     uint64_t ping_id;
     uint32_t cid_size = 1 + CLIENT_ID_SIZE;
     cid_size += crypto_box_NONCEBYTES + sizeof(ping_id) + ENCRYPTION_PADDING;
 
     if (length > (cid_size + sizeof(Node_format) * MAX_SENT_NODES) ||
-        ((length - cid_size) % sizeof(Node_format)) != 0 ||
-        (length < cid_size + sizeof(Node_format)))
+            ((length - cid_size) % sizeof(Node_format)) != 0 ||
+            (length < cid_size + sizeof(Node_format)))
         return 1;
 
     uint32_t num_nodes = (length - cid_size) / sizeof(Node_format);
     uint8_t plain[sizeof(ping_id) + sizeof(Node_format) * MAX_SENT_NODES];
 
-    int len = decrypt_data( 
-            packet + 1, 
-            self_secret_key, 
-            packet + 1 + CLIENT_ID_SIZE,
-            packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
-            sizeof(ping_id) + num_nodes * sizeof(Node_format) + ENCRYPTION_PADDING, plain );
+    int len = decrypt_data(
+                  packet + 1,
+                  self_secret_key,
+                  packet + 1 + CLIENT_ID_SIZE,
+                  packet + 1 + CLIENT_ID_SIZE + crypto_box_NONCEBYTES,
+                  sizeof(ping_id) + num_nodes * sizeof(Node_format) + ENCRYPTION_PADDING, plain );
 
-    if(len != sizeof(ping_id) + num_nodes * sizeof(Node_format))
+    if (len != sizeof(ping_id) + num_nodes * sizeof(Node_format))
         return 1;
 
     memcpy(&ping_id, plain, sizeof(ping_id));
-    if(!is_gettingnodes(source, ping_id))
+
+    if (!is_gettingnodes(source, ping_id))
         return 1;
 
     Node_format nodes_list[MAX_SENT_NODES];
@@ -644,8 +656,9 @@ static int handle_sendnodes(IP_Port source, uint8_t * packet, uint32_t length)
     addto_lists(source, packet + 1);
 
     uint32_t i;
-    for(i = 0; i < num_nodes; ++i)  {
-        send_ping_request(nodes_list[i].ip_port, (clientid_t*) &nodes_list[i].client_id);
+
+    for (i = 0; i < num_nodes; ++i)  {
+        send_ping_request(nodes_list[i].ip_port, (clientid_t *) &nodes_list[i].client_id);
         returnedip_ports(nodes_list[i].ip_port, nodes_list[i].client_id, packet + 1);
     }
 
@@ -655,12 +668,14 @@ static int handle_sendnodes(IP_Port source, uint8_t * packet, uint32_t length)
 /*----------------------------------------------------------------------------------*/
 /*------------------------END of packet handling functions--------------------------*/
 
-int DHT_addfriend(uint8_t * client_id)
+int DHT_addfriend(uint8_t *client_id)
 {
-    if(friend_number(client_id) != -1) /*Is friend already in DHT?*/
+    if (friend_number(client_id) != -1) /*Is friend already in DHT?*/
         return 1;
-    Friend * temp;
+
+    Friend *temp;
     temp = realloc(friends_list, sizeof(Friend) * (num_friends + 1));
+
     if (temp == NULL)
         return 1;
 
@@ -673,22 +688,24 @@ int DHT_addfriend(uint8_t * client_id)
     return 0;
 }
 
-int DHT_delfriend(uint8_t * client_id)
+int DHT_delfriend(uint8_t *client_id)
 {
     uint32_t i;
-    Friend * temp;
+    Friend *temp;
+
     for (i = 0; i < num_friends; ++i) {
         /* Equal */
         if (id_equal(friends_list[i].client_id, client_id)) {
             --num_friends;
 
             if (num_friends != i) {
-                memcpy( friends_list[i].client_id, 
-                        friends_list[num_friends].client_id, 
+                memcpy( friends_list[i].client_id,
+                        friends_list[num_friends].client_id,
                         CLIENT_ID_SIZE );
             }
 
             temp = realloc(friends_list, sizeof(Friend) * (num_friends));
+
             if (temp == NULL)
                 return 1;
 
@@ -701,7 +718,7 @@ int DHT_delfriend(uint8_t * client_id)
 }
 
 /* TODO: Optimize this. */
-IP_Port DHT_getfriendip(uint8_t * client_id)
+IP_Port DHT_getfriendip(uint8_t *client_id)
 {
     uint32_t i, j;
     uint64_t temp_time = unix_time();
@@ -711,18 +728,21 @@ IP_Port DHT_getfriendip(uint8_t * client_id)
         /* Equal */
         if (id_equal(friends_list[i].client_id, client_id)) {
             for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
-                if (id_equal(friends_list[i].client_list[j].client_id, client_id) && !is_timeout(temp_time, friends_list[i].client_list[j].timestamp, BAD_NODE_TIMEOUT))
+                if (id_equal(friends_list[i].client_list[j].client_id, client_id)
+                        && !is_timeout(temp_time, friends_list[i].client_list[j].timestamp, BAD_NODE_TIMEOUT))
                     return friends_list[i].client_list[j].ip_port;
             }
+
             return empty;
         }
     }
+
     empty.ip.i = 1;
     return empty;
 }
 
 /* Ping each client in the "friends" list every 60 seconds. Send a get nodes request
- * every 20 seconds to a random good node for each "friend" in our "friends" list. 
+ * every 20 seconds to a random good node for each "friend" in our "friends" list.
  */
 static void doDHTFriends(void)
 {
@@ -733,22 +753,25 @@ static void doDHTFriends(void)
 
     for (i = 0; i < num_friends; ++i) {
         uint32_t num_nodes = 0;
+
         for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
             /* if node is not dead. */
-          if (!is_timeout(temp_time, friends_list[i].client_list[j].timestamp, Kill_NODE_TIMEOUT)) {
+            if (!is_timeout(temp_time, friends_list[i].client_list[j].timestamp, Kill_NODE_TIMEOUT)) {
                 if ((friends_list[i].client_list[j].last_pinged + PING_INTERVAL) <= temp_time) {
-                    send_ping_request( friends_list[i].client_list[j].ip_port, 
-                                       (clientid_t*) &friends_list[i].client_list[j].client_id );
+                    send_ping_request( friends_list[i].client_list[j].ip_port,
+                                       (clientid_t *) &friends_list[i].client_list[j].client_id );
                     friends_list[i].client_list[j].last_pinged = temp_time;
                 }
+
                 /* if node is good. */
-                if (!is_timeout(temp_time, friends_list[i].client_list[j].timestamp, BAD_NODE_TIMEOUT)) { 
+                if (!is_timeout(temp_time, friends_list[i].client_list[j].timestamp, BAD_NODE_TIMEOUT)) {
                     index[num_nodes] = j;
                     ++num_nodes;
                 }
             }
         }
-        if(friends_list[i].lastgetnode + GET_NODE_INTERVAL <= temp_time && num_nodes != 0) {
+
+        if (friends_list[i].lastgetnode + GET_NODE_INTERVAL <= temp_time && num_nodes != 0) {
             rand_node = rand() % num_nodes;
             getnodes( friends_list[i].client_list[index[rand_node]].ip_port,
                       friends_list[i].client_list[index[rand_node]].client_id,
@@ -775,10 +798,11 @@ static void doClose(void)
         /* if node is not dead. */
         if (!is_timeout(temp_time, close_clientlist[i].timestamp, Kill_NODE_TIMEOUT)) {
             if ((close_clientlist[i].last_pinged + PING_INTERVAL) <= temp_time) {
-                send_ping_request( close_clientlist[i].ip_port, 
-                                   (clientid_t*) &close_clientlist[i].client_id );
+                send_ping_request( close_clientlist[i].ip_port,
+                                   (clientid_t *) &close_clientlist[i].client_id );
                 close_clientlist[i].last_pinged = temp_time;
             }
+
             /* if node is good. */
             if (!is_timeout(temp_time, close_clientlist[i].timestamp, BAD_NODE_TIMEOUT)) {
                 index[num_nodes] = i;
@@ -796,15 +820,15 @@ static void doClose(void)
     }
 }
 
-void DHT_bootstrap(IP_Port ip_port, uint8_t * public_key)
+void DHT_bootstrap(IP_Port ip_port, uint8_t *public_key)
 {
     getnodes(ip_port, public_key, self_public_key);
 }
 
 /* send the given packet to node with client_id
- * returns -1 if failure 
+ * returns -1 if failure
  */
-int route_packet(uint8_t * client_id, uint8_t * packet, uint32_t length)
+int route_packet(uint8_t *client_id, uint8_t *packet, uint32_t length)
 {
     uint32_t i;
 
@@ -822,17 +846,17 @@ int route_packet(uint8_t * client_id, uint8_t * packet, uint32_t length)
  * return 0 if we are connected to friend or if no ips were found.
  * returns -1 if no such friend
  */
-static int friend_iplist(IP_Port * ip_portlist, uint16_t friend_num)
+static int friend_iplist(IP_Port *ip_portlist, uint16_t friend_num)
 {
     int num_ips = 0;
     uint32_t i;
     uint64_t temp_time = unix_time();
-    
+
     if (friend_num >= num_friends)
         return -1;
 
-    Friend * friend = &friends_list[friend_num];
-    Client_data * client;
+    Friend *friend = &friends_list[friend_num];
+    Client_data *client;
 
     for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
         client = &friend->client_list[i];
@@ -847,22 +871,24 @@ static int friend_iplist(IP_Port * ip_portlist, uint16_t friend_num)
             ++num_ips;
         }
     }
+
     return num_ips;
 }
 
 /* Send the following packet to everyone who tells us they are connected to friend_id
  * returns the number of nodes it sent the packet to
  */
-int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length)
+int route_tofriend(uint8_t *friend_id, uint8_t *packet, uint32_t length)
 {
     int num = friend_number(friend_id);
+
     if (num == -1)
         return 0;
 
     uint32_t i, sent = 0;
     uint64_t temp_time = unix_time();
-    Friend * friend = &friends_list[num];
-    Client_data * client;
+    Friend *friend = &friends_list[num];
+    Client_data *client;
 
     for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
         client = &friend->client_list[i];
@@ -874,20 +900,22 @@ int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length)
                 ++sent;
         }
     }
+
     return sent;
 }
 
 /* Send the following packet to one random person who tells us they are connected to friend_id
 *  returns the number of nodes it sent the packet to
 */
-static int routeone_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length)
+static int routeone_tofriend(uint8_t *friend_id, uint8_t *packet, uint32_t length)
 {
     int num = friend_number(friend_id);
+
     if (num == -1)
         return 0;
 
-    Friend * friend = &friends_list[num];
-    Client_data * client;
+    Friend *friend = &friends_list[num];
+    Client_data *client;
 
     IP_Port ip_list[MAX_FRIEND_CLIENTS];
     int n = 0;
@@ -898,15 +926,18 @@ static int routeone_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t len
         client = &friend->client_list[i];
 
         /*If ip is not zero and node is good */
-        if(client->ret_ip_port.ip.i != 0 && !is_timeout(temp_time, client->ret_timestamp, BAD_NODE_TIMEOUT)) {
+        if (client->ret_ip_port.ip.i != 0 && !is_timeout(temp_time, client->ret_timestamp, BAD_NODE_TIMEOUT)) {
             ip_list[n] = client->ip_port;
             ++n;
         }
     }
+
     if (n < 1)
         return 0;
+
     if (sendpacket(ip_list[rand() % n], packet, length) == length)
         return 1;
+
     return 0;
 }
 
@@ -916,21 +947,23 @@ static int routeone_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t len
  * return 0 if we are connected to friend or if no ips were found.
  * returns -1 if no such friend
  */
-int friend_ips(IP_Port * ip_portlist, uint8_t * friend_id)
+int friend_ips(IP_Port *ip_portlist, uint8_t *friend_id)
 {
     uint32_t i;
+
     for (i = 0; i < num_friends; ++i) {
         /* Equal */
         if (id_equal(friends_list[i].client_id, friend_id))
             return friend_iplist(ip_portlist, i);
     }
+
     return -1;
 }
 
 /*----------------------------------------------------------------------------------*/
 /*---------------------BEGINNING OF NAT PUNCHING FUNCTIONS--------------------------*/
 
-static int send_NATping(uint8_t * public_key, uint64_t ping_id, uint8_t type)
+static int send_NATping(uint8_t *public_key, uint64_t ping_id, uint8_t type)
 {
     uint8_t data[sizeof(uint64_t) + 1];
     uint8_t packet[MAX_DATA_SIZE];
@@ -952,20 +985,22 @@ static int send_NATping(uint8_t * public_key, uint64_t ping_id, uint8_t type)
 
     if (num == 0)
         return -1;
+
     return num;
 }
 
 /* Handle a received ping request for */
-static int handle_NATping(IP_Port source, uint8_t * source_pubkey, uint8_t * packet, uint32_t length) 
+static int handle_NATping(IP_Port source, uint8_t *source_pubkey, uint8_t *packet, uint32_t length)
 {
     uint64_t ping_id;
     memcpy(&ping_id, packet + 1, sizeof(uint64_t));
 
     int friendnumber = friend_number(source_pubkey);
+
     if (friendnumber == -1)
         return 1;
 
-    Friend * friend = &friends_list[friendnumber];
+    Friend *friend = &friends_list[friendnumber];
 
     if (packet[0] == 0) {
         /* 1 is reply */
@@ -979,31 +1014,35 @@ static int handle_NATping(IP_Port source, uint8_t * source_pubkey, uint8_t * pac
             return 0;
         }
     }
+
     return 1;
 }
 
 /* Get the most common ip in the ip_portlist
  * Only return ip if it appears in list min_num or more
  * len must not be bigger than MAX_FRIEND_CLIENTS
- * return ip of 0 if failure 
+ * return ip of 0 if failure
  */
-static IP NAT_commonip(IP_Port * ip_portlist, uint16_t len, uint16_t min_num)
+static IP NAT_commonip(IP_Port *ip_portlist, uint16_t len, uint16_t min_num)
 {
     IP zero = {{0}};
-    if(len > MAX_FRIEND_CLIENTS)
+
+    if (len > MAX_FRIEND_CLIENTS)
         return zero;
 
     uint32_t i, j;
     uint16_t numbers[MAX_FRIEND_CLIENTS] = {0};
 
-    for(i = 0; i < len; ++i) {
-        for(j = 0; j < len; ++j) {
-            if(ip_portlist[i].ip.i == ip_portlist[j].ip.i)
+    for (i = 0; i < len; ++i) {
+        for (j = 0; j < len; ++j) {
+            if (ip_portlist[i].ip.i == ip_portlist[j].ip.i)
                 ++numbers[i];
         }
-        if(numbers[i] >= min_num)
+
+        if (numbers[i] >= min_num)
             return ip_portlist[i].ip;
     }
+
     return zero;
 }
 
@@ -1012,34 +1051,36 @@ static IP NAT_commonip(IP_Port * ip_portlist, uint16_t len, uint16_t min_num)
  * where len is the length of ip_portlist
  * returns the number of ports and puts the list of ports in portlist
  */
-static uint16_t NAT_getports(uint16_t * portlist, IP_Port * ip_portlist, uint16_t len, IP ip)
+static uint16_t NAT_getports(uint16_t *portlist, IP_Port *ip_portlist, uint16_t len, IP ip)
 {
     uint32_t i;
     uint16_t num = 0;
 
-    for(i = 0; i < len; ++i) {
-        if(ip_portlist[i].ip.i == ip.i) {
+    for (i = 0; i < len; ++i) {
+        if (ip_portlist[i].ip.i == ip.i) {
             portlist[num] = ntohs(ip_portlist[i].port);
             ++num;
         }
     }
+
     return num;
 }
 
-static void punch_holes(IP ip, uint16_t * port_list, uint16_t numports, uint16_t friend_num)
+static void punch_holes(IP ip, uint16_t *port_list, uint16_t numports, uint16_t friend_num)
 {
-    if(numports > MAX_FRIEND_CLIENTS || numports == 0)
+    if (numports > MAX_FRIEND_CLIENTS || numports == 0)
         return;
 
     uint32_t i;
     uint32_t top = friends_list[friend_num].punching_index + MAX_PUNCHING_PORTS;
 
-    for(i = friends_list[friend_num].punching_index; i != top; i++) {
+    for (i = friends_list[friend_num].punching_index; i != top; i++) {
         /*TODO: improve port guessing algorithm*/
-        uint16_t port = port_list[(i/2) % numports] + (i/(2*numports))*((i % 2) ? -1 : 1);
+        uint16_t port = port_list[(i / 2) % numports] + (i / (2 * numports)) * ((i % 2) ? -1 : 1);
         IP_Port pinging = {ip, htons(port)};
-        send_ping_request(pinging, (clientid_t*) &friends_list[friend_num].client_id);
+        send_ping_request(pinging, (clientid_t *) &friends_list[friend_num].client_id);
     }
+
     friends_list[friend_num].punching_index = i;
 }
 
@@ -1053,18 +1094,20 @@ static void doNAT(void)
         int num = friend_iplist(ip_list, i);
 
         /*If already connected or friend is not online don't try to hole punch*/
-        if (num < MAX_FRIEND_CLIENTS/2)
+        if (num < MAX_FRIEND_CLIENTS / 2)
             continue;
 
         if (friends_list[i].NATping_timestamp + PUNCH_INTERVAL < temp_time) {
             send_NATping(friends_list[i].client_id, friends_list[i].NATping_id, 0); /*0 is request*/
             friends_list[i].NATping_timestamp = temp_time;
         }
+
         if (friends_list[i].hole_punching == 1 &&
-            friends_list[i].punching_timestamp + PUNCH_INTERVAL < temp_time && 
-            friends_list[i].recvNATping_timestamp + PUNCH_INTERVAL*2 >= temp_time) {
+                friends_list[i].punching_timestamp + PUNCH_INTERVAL < temp_time &&
+                friends_list[i].recvNATping_timestamp + PUNCH_INTERVAL * 2 >= temp_time) {
+
+            IP ip = NAT_commonip(ip_list, num, MAX_FRIEND_CLIENTS / 2);
 
-            IP ip = NAT_commonip(ip_list, num, MAX_FRIEND_CLIENTS/2);
             if (ip.i == 0)
                 continue;
 
@@ -1087,14 +1130,16 @@ static void doNAT(void)
    and are then removed from the list.
    if the list is full the nodes farthest from our client_id are replaced
    the purpose of this list is to enable quick integration of new nodes into the
-   network while preventing amplification attacks. 
+   network while preventing amplification attacks.
    return 0 if node was added
    return -1 if node was not added */
 int add_toping(uint8_t *client_id, IP_Port ip_port)
 {
     if (ip_port.ip.i == 0)
         return -1;
+
     uint32_t i;
+
     for (i = 0; i < MAX_TOPING; ++i) {
         if (toping[i].ip_port.ip.i == 0) {
             memcpy(toping[i].client_id, client_id, CLIENT_ID_SIZE);
@@ -1103,6 +1148,7 @@ int add_toping(uint8_t *client_id, IP_Port ip_port)
             return 0;
         }
     }
+
     for (i = 0; i < MAX_TOPING; ++i) {
         if (id_closest(self_public_key, toping[i].client_id, client_id) == 2) {
             memcpy(toping[i].client_id, client_id, CLIENT_ID_SIZE);
@@ -1111,6 +1157,7 @@ int add_toping(uint8_t *client_id, IP_Port ip_port)
             return 0;
         }
     }
+
     return -1;
 }
 
@@ -1119,13 +1166,17 @@ int add_toping(uint8_t *client_id, IP_Port ip_port)
 static void do_toping()
 {
     uint64_t temp_time = unix_time();
+
     if (!is_timeout(temp_time, last_toping, TIME_TOPING))
         return;
+
     last_toping = temp_time;
     uint32_t i;
+
     for (i = 0; i < MAX_TOPING; ++i) {
         if (toping[i].ip_port.ip.i == 0)
             return;
+
         send_ping_request(toping[i].ip_port, (clientid_t *) toping[i].client_id);
         toping[i].ip_port.ip.i = 0;
     }
@@ -1156,7 +1207,7 @@ uint32_t DHT_size(void)
 }
 
 /* save the DHT in data where data is an array of size DHT_size() */
-void DHT_save(uint8_t * data)
+void DHT_save(uint8_t *data)
 {
     memcpy(data, close_clientlist, sizeof(close_clientlist));
     memcpy(data + sizeof(close_clientlist), friends_list, sizeof(Friend) * num_friends);
@@ -1164,60 +1215,64 @@ void DHT_save(uint8_t * data)
 
 /* load the DHT from data of size size;
  * return -1 if failure
- * return 0 if success 
+ * return 0 if success
  */
-int DHT_load(uint8_t * data, uint32_t size)
+int DHT_load(uint8_t *data, uint32_t size)
 {
     init_ping();
 
-    if(size < sizeof(close_clientlist))
+    if (size < sizeof(close_clientlist))
         return -1;
 
-    if((size - sizeof(close_clientlist)) % sizeof(Friend) != 0)
+    if ((size - sizeof(close_clientlist)) % sizeof(Friend) != 0)
         return -1;
 
     uint32_t i, j;
     uint16_t temp;
     /* uint64_t temp_time = unix_time(); */
 
-    Client_data * client;
+    Client_data *client;
 
-    temp = (size - sizeof(close_clientlist))/sizeof(Friend);
+    temp = (size - sizeof(close_clientlist)) / sizeof(Friend);
 
-    if(temp != 0) {
-        Friend * tempfriends_list = (Friend *)(data + sizeof(close_clientlist));
+    if (temp != 0) {
+        Friend *tempfriends_list = (Friend *)(data + sizeof(close_clientlist));
 
-        for(i = 0; i < temp; ++i) {
+        for (i = 0; i < temp; ++i) {
             DHT_addfriend(tempfriends_list[i].client_id);
 
-            for(j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
+            for (j = 0; j < MAX_FRIEND_CLIENTS; ++j) {
                 client = &tempfriends_list[i].client_list[j];
-                if(client->timestamp != 0)
+
+                if (client->timestamp != 0)
                     getnodes(client->ip_port, client->client_id, tempfriends_list[i].client_id);
             }
         }
     }
-    Client_data * tempclose_clientlist = (Client_data *)data;
 
-    for(i = 0; i < LCLIENT_LIST; ++i) {
-        if(tempclose_clientlist[i].timestamp != 0)
-            DHT_bootstrap(  tempclose_clientlist[i].ip_port, 
+    Client_data *tempclose_clientlist = (Client_data *)data;
+
+    for (i = 0; i < LCLIENT_LIST; ++i) {
+        if (tempclose_clientlist[i].timestamp != 0)
+            DHT_bootstrap(  tempclose_clientlist[i].ip_port,
                             tempclose_clientlist[i].client_id );
     }
+
     return 0;
 }
 
 /* returns 0 if we are not connected to the DHT
- * returns 1 if we are 
+ * returns 1 if we are
  */
 int DHT_isconnected(void)
 {
     uint32_t i;
     uint64_t temp_time = unix_time();
 
-    for(i = 0; i < LCLIENT_LIST; ++i) {
-      if(!is_timeout(temp_time, close_clientlist[i].timestamp, BAD_NODE_TIMEOUT))
+    for (i = 0; i < LCLIENT_LIST; ++i) {
+        if (!is_timeout(temp_time, close_clientlist[i].timestamp, BAD_NODE_TIMEOUT))
             return 1;
     }
+
     return 0;
 }