9 files changed, 497 insertions, 263 deletions

diff --git a/core/DHT.c b/core/DHT.c
index 5a362ecc..f779ef18 100644
--- a/core/DHT.c
+++ b/core/DHT.c
@@ -85,7 +85,7 @@ typedef struct {
     uint8_t     hole_punching; 
     uint32_t    punching_index;
     uint32_t    punching_timestamp;
-    uint32_t    recvNATping_timestamp;
+    int64_t     recvNATping_timestamp;
     uint64_t    NATping_id;
     uint32_t    NATping_timestamp;
 } Friend;
@@ -98,7 +98,7 @@ typedef struct {
 typedef struct {
     IP_Port     ip_port;
     uint64_t    ping_id;
-    uint32_t    timestamp;
+    int64_t     timestamp;
 } Pinged;
 
 /*----------------------------------------------------------------------------------*/
@@ -145,7 +145,8 @@ int id_closest(uint8_t * client_id, uint8_t * client_id1, uint8_t * client_id2)
  */
 int client_in_list(Client_data * list, uint32_t length, uint8_t * client_id, IP_Port ip_port)
 {
-    uint32_t i, temp_time = unix_time();
+    uint32_t i;
+    int64_t temp_time = unix_time();
 
     for(i = 0; i < length; ++i) {
         /*If ip_port is assigned to a different client_id replace it*/
@@ -197,7 +198,8 @@ static int friend_number(uint8_t * client_id)
  */
 int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
 {
-    uint32_t    i, j, k, temp_time = unix_time();
+    uint32_t    i, j, k;
+    int64_t     temp_time = unix_time();
     int         num_nodes = 0, closest, tout, inlist;
 
     for (i = 0; i < LCLIENT_LIST; ++i) {
@@ -283,7 +285,7 @@ int replace_bad(    Client_data *   list,
                     IP_Port         ip_port )
 {
     uint32_t i;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     for(i = 0; i < length; ++i) {
         /* if node is bad */
         if(list[i].timestamp + BAD_NODE_TIMEOUT < temp_time) {
@@ -308,7 +310,7 @@ int replace_good(   Client_data *   list,
                     uint8_t *       comp_client_id )
 {
     uint32_t i;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
 
     for(i = 0; i < length; ++i)
         if(id_closest(comp_client_id, list[i].client_id, client_id) == 2) {
@@ -371,7 +373,8 @@ void addto_lists(IP_Port ip_port, uint8_t * client_id)
  */
 void returnedip_ports(IP_Port ip_port, uint8_t * client_id, uint8_t * nodeclient_id)
 {
-    uint32_t i, j, temp_time = unix_time();
+    uint32_t i, j;
+    int64_t temp_time = unix_time();
 
     if (memcmp(client_id, self_public_key, CLIENT_ID_SIZE) == 0) {
         for (i = 0; i < LCLIENT_LIST; ++i) {
@@ -411,8 +414,9 @@ void returnedip_ports(IP_Port ip_port, uint8_t * client_id, uint8_t * nodeclient
  */
 int is_pinging(IP_Port ip_port, uint64_t ping_id)
 {
-    uint32_t i, temp_time = unix_time();
+    uint32_t i;
     uint8_t pinging;
+    int64_t temp_time = unix_time();
 
     for (i = 0; i < LPING_ARRAY; ++i ) {
         if ((pings[i].timestamp + PING_TIMEOUT) > temp_time) {
@@ -434,8 +438,9 @@ int is_pinging(IP_Port ip_port, uint64_t ping_id)
 /* Same as last function but for get_node requests. */
 int is_gettingnodes(IP_Port ip_port, uint64_t ping_id)
 {
-    uint32_t i, temp_time = unix_time();
+    uint32_t i;
     uint8_t pinging;
+    int64_t temp_time = unix_time();
 
     for(i = 0; i < LSEND_NODES_ARRAY; ++i ) {
         if((send_nodes[i].timestamp + PING_TIMEOUT) > temp_time) {
@@ -462,8 +467,10 @@ int is_gettingnodes(IP_Port ip_port, uint64_t ping_id)
  */
 uint64_t add_pinging(IP_Port ip_port)
 {
-    uint32_t i, j, temp_time = unix_time();
+    uint32_t i, j;
     uint64_t ping_id = ((uint64_t)random_int() << 32) + random_int();
+    int64_t temp_time = unix_time();
+
 
     for(i = 0; i < PING_TIMEOUT; ++i ) {
         for(j = 0; j < LPING_ARRAY; ++j ) {
@@ -484,7 +491,7 @@ uint64_t add_gettingnodes(IP_Port ip_port)
 {
     uint32_t i, j;
     uint64_t ping_id = ((uint64_t)random_int() << 32) + random_int();
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
 
     for(i = 0; i < PING_TIMEOUT; ++i ) {
         for(j = 0; j < LSEND_NODES_ARRAY; ++j ) {
@@ -823,7 +830,8 @@ int DHT_delfriend(uint8_t * client_id)
 /* TODO: Optimize this. */
 IP_Port DHT_getfriendip(uint8_t * client_id)
 {
-    uint32_t i, j, temp_time = unix_time();
+    uint32_t i, j;
+    int64_t temp_time = unix_time();
     IP_Port empty = {{{0}}, 0};
 
     for (i = 0; i < num_friends; ++i) {
@@ -849,7 +857,7 @@ IP_Port DHT_getfriendip(uint8_t * client_id)
 void doDHTFriends()
 {
     uint32_t i, j;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     uint32_t rand_node;
     uint32_t index[MAX_FRIEND_CLIENTS];
 
@@ -888,7 +896,7 @@ static uint32_t close_lastgetnodes;
 void doClose()
 {
     uint32_t i;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     uint32_t num_nodes = 0;
     uint32_t rand_node;
     uint32_t index[LCLIENT_LIST];
@@ -945,8 +953,9 @@ int route_packet(uint8_t * client_id, uint8_t * packet, uint32_t length)
 static int friend_iplist(IP_Port * ip_portlist, uint16_t friend_num)
 {
     int num_ips = 0;
-    uint32_t i, temp_time = unix_time();
-
+    uint32_t i;
+    int64_t temp_time = unix_time();
+    
     if (friend_num >= num_friends)
         return -1;
 
@@ -979,7 +988,8 @@ int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length)
     if (num == -1)
         return 0;
 
-    uint32_t i, sent = 0, temp_time = unix_time();
+    uint32_t i, sent = 0;
+    int64_t temp_time = unix_time();
     Friend * friend = &friends_list[num];
     Client_data * client;
 
@@ -1012,6 +1022,7 @@ int routeone_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length)
     IP_Port ip_list[MAX_FRIEND_CLIENTS];
     int n = 0;
     uint32_t i, temp_time = unix_time();
+    int64_t temp_time = unix_time();
 
     for (i = 0; i < MAX_FRIEND_CLIENTS; ++i) {
         client = &friend->client_list[i];
@@ -1184,7 +1195,8 @@ static void punch_holes(IP ip, uint16_t * port_list, uint16_t numports, uint16_t
 
 static void doNAT()
 {
-    uint32_t i, temp_time = unix_time();
+    uint32_t i;
+    int64_t temp_time = unix_time();
 
     for (i = 0; i < num_friends; ++i) {
         IP_Port ip_list[MAX_FRIEND_CLIENTS];
@@ -1279,7 +1291,7 @@ int DHT_load(uint8_t * data, uint32_t size)
 
     uint32_t i, j;
     uint16_t temp;
-    /* uint32_t temp_time = unix_time(); */
+    /* int64_t temp_time = unix_time(); */
 
     Client_data * client;
 
@@ -1314,6 +1326,7 @@ int DHT_load(uint8_t * data, uint32_t size)
 int DHT_isconnected()
 {
     uint32_t i, temp_time = unix_time();
+    int64_t temp_time = unix_time();
 
     for(i = 0; i < LCLIENT_LIST; ++i) {
         if(close_clientlist[i].timestamp + BAD_NODE_TIMEOUT > temp_time)
diff --git a/core/DHT.h b/core/DHT.h
index dbb640a5..5e1fd0a5 100644
--- a/core/DHT.h
+++ b/core/DHT.h
@@ -31,7 +31,7 @@ extern "C" {
 #endif
 
 /* Current time, unix format */
-#define unix_time() ((uint32_t)time(NULL))
+#define unix_time() ((int64_t)time(NULL))
 
 /* size of the client_id in bytes */
 #define CLIENT_ID_SIZE crypto_box_PUBLICKEYBYTES
diff --git a/core/LAN_discovery.c b/core/LAN_discovery.c
index 0a23914d..72e00d32 100644
--- a/core/LAN_discovery.c
+++ b/core/LAN_discovery.c
@@ -23,13 +23,70 @@
 
 #include "LAN_discovery.h"
 
+#define MAX_INTERFACES 16
 
-/*Return the broadcast ip
-  TODO: make it return the real one, not the 255.255.255.255 one.*/
+#ifdef __linux
+/* get the first working broadcast address that's not from "lo"
+ *  returns higher than 0 on success
+ *  returns 0 on error */
+uint32_t get_broadcast(void)
+{
+    /* not sure how many platforms this will
+     *  run on, so it's wrapped in __linux for now */
+    struct sockaddr_in *sock_holder = NULL;
+    struct ifreq i_faces[MAX_INTERFACES];
+    struct ifconf ifconf;
+    int count = 0;
+    int sock = 0;
+    int i = 0;
+
+    /* configure ifconf for the ioctl call */
+    if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+        perror("[!] get_broadcast: socket() error");
+        return 0;
+    }
+
+    memset(i_faces, 0, sizeof(struct ifreq) * MAX_INTERFACES);
+
+    ifconf.ifc_buf = (char *)i_faces;
+    ifconf.ifc_len = sizeof(i_faces);
+    count = ifconf.ifc_len / sizeof(struct ifreq);
+    if(ioctl(sock, SIOCGIFCONF, &ifconf) < 0) {
+        perror("get_broadcast: ioctl() error");
+        return 0;
+    }
+
+    for(i = 0; i < count; i++) {
+        /* skip the loopback interface, as it's useless */
+        if(strcmp(i_faces[i].ifr_name, "lo") != 0) {
+            if(ioctl(sock, SIOCGIFBRDADDR, &i_faces[i]) < 0) {
+                perror("[!] get_broadcast: ioctl error");
+                return 0;
+            }
+
+            /* just to clarify where we're getting the values from */
+            sock_holder = (struct sockaddr_in *)&i_faces[i].ifr_broadaddr;
+            break;
+        }
+    }
+    close(sock);
+
+    return sock_holder->sin_addr.s_addr;
+}
+#endif
+
+/* Return the broadcast ip */
 IP broadcast_ip()
 {
     IP ip;
+    #ifdef __linux
+    ip.i = get_broadcast();
+    if(ip.i == 0)
+        /* error errored, but try anyway? */
+        ip.i = ~0;
+    #else
     ip.i = ~0;
+    #endif
     return ip;
 }
 
diff --git a/core/LAN_discovery.h b/core/LAN_discovery.h
index 4ca65c03..96a6e6ad 100644
--- a/core/LAN_discovery.h
+++ b/core/LAN_discovery.h
@@ -28,6 +28,13 @@
 
 #include "DHT.h"
 
+/* used for get_broadcast() */
+#ifdef __linux
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <linux/netdevice.h>
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --git a/core/Lossless_UDP.c b/core/Lossless_UDP.c
index 6be8328f..4affc38f 100644
--- a/core/Lossless_UDP.c
+++ b/core/Lossless_UDP.c
@@ -21,67 +21,95 @@
  *
  */
 
-/* TODO: clean this file a bit.
-   There are a couple of useless variables to get rid of. */
+/* 
+ * TODO: clean this file a bit.
+ * There are a couple of useless variables to get rid of.
+ */
+
 #include "Lossless_UDP.h"
 
 /* maximum data packets in sent and receive queues. */
-#define MAX_QUEUE_NUM 16
-
-/* maximum length of the data in the data packets */
-/* #define MAX_DATA_SIZE 1024 */ /* defined in Lossless_UDP.h */
+#define MAX_QUEUE_NUM     16
 
 /* maximum number of data packets in the buffer */
 #define BUFFER_PACKET_NUM (16-1)
 
-/* Lossless UDP connection timeout.
-timeout per connection is randomly set between CONNEXION_TIMEOUT and 2*CONNEXION_TIMEOUT */
+/* timeout per connection is randomly set between CONNEXION_TIMEOUT and 2*CONNEXION_TIMEOUT */
 #define CONNEXION_TIMEOUT 5
 
 /* initial amount of sync/hanshake packets to send per second. */
-#define SYNC_RATE 2
+#define SYNC_RATE         2
 
 /* initial send rate of data. */
-#define DATA_SYNC_RATE 30
+#define DATA_SYNC_RATE    30
 
 typedef struct {
-    uint8_t data[MAX_DATA_SIZE];
+    uint8_t  data[MAX_DATA_SIZE];
     uint16_t size;
 } Data;
 
 typedef struct {
     IP_Port ip_port;
-    uint8_t status; /* 0 if connection is dead, 1 if attempting handshake,
-                       2 if handshake is done (we start sending SYNC packets)
-                       3 if we are sending SYNC packets and can send data
-                       4 if the connection has timed out. */
-
-    uint8_t inbound; /* 1 or 2 if connection was initiated by someone else, 0 if not.
-                        2 if incoming_connection() has not returned it yet, 1 if it has. */
-
-    uint16_t SYNC_rate; /* current SYNC packet send rate packets per second. */
-    uint16_t data_rate; /* current data packet send rate packets per second. */
-    uint64_t last_SYNC; /* time at which our last SYNC packet was sent. */
-    uint64_t last_sent; /* time at which our last data or handshake packet was sent. */
-    uint64_t last_recvSYNC; /* time at which we last received a SYNC packet from the other */
-    uint64_t last_recvdata; /* time at which we last received a DATA packet from the other */
-    uint64_t killat; /* time at which to kill the connection */
-    Data sendbuffer[MAX_QUEUE_NUM]; /* packet send buffer. */
-    Data recvbuffer[MAX_QUEUE_NUM]; /* packet receive buffer. */
-    uint32_t handshake_id1;
-    uint32_t handshake_id2;
-    uint32_t recv_packetnum; /* number of data packets received (also used as handshake_id1) */
-    uint32_t orecv_packetnum; /* number of packets received by the other peer */
-    uint32_t sent_packetnum; /* number of data packets sent */
-    uint32_t osent_packetnum; /* number of packets sent by the other peer. */
-    uint32_t sendbuff_packetnum; /* number of latest packet written onto the sendbuffer */
-    uint32_t successful_sent; /* we know all packets before that number were successfully sent */
-    uint32_t successful_read; /* packet number of last packet read with the read_packet function */
-    uint32_t req_packets[BUFFER_PACKET_NUM]; /* list of currently requested packet numbers(by the other person) */
-    uint16_t num_req_paquets;  /* total number of currently requested packets(by the other person) */
-    uint8_t recv_counter;
-    uint8_t send_counter;
-    uint8_t timeout; /* connection timeout in seconds. */
+
+    /*
+     * 0 if connection is dead, 1 if attempting handshake,
+     * 2 if handshake is done (we start sending SYNC packets)
+     * 3 if we are sending SYNC packets and can send data
+     * 4 if the connection has timed out.
+     */
+    uint8_t status;
+
+    /* 
+     * 1 or 2 if connection was initiated by someone else, 0 if not.
+     * 2 if incoming_connection() has not returned it yet, 1 if it has. 
+     */
+    uint8_t inbound;
+
+    uint16_t  SYNC_rate;     /* current SYNC packet send rate packets per second. */
+    uint16_t  data_rate;     /* current data packet send rate packets per second. */
+
+    uint64_t  last_SYNC;     /* time our last SYNC packet was sent. */
+    uint64_t  last_sent;     /* time our last data or handshake packet was sent. */
+    uint64_t  last_recvSYNC; /* time we last received a SYNC packet from the other */
+    uint64_t  last_recvdata; /* time we last received a DATA packet from the other */
+    uint64_t  killat;        /* time to kill the connection */
+
+    Data      sendbuffer[MAX_QUEUE_NUM]; /* packet send buffer. */
+    Data      recvbuffer[MAX_QUEUE_NUM]; /* packet receive buffer. */
+
+    uint32_t  handshake_id1;
+    uint32_t  handshake_id2;
+
+    /* number of data packets received (also used as handshake_id1) */
+    uint32_t  recv_packetnum; 
+
+    /* number of packets received by the other peer */
+    uint32_t  orecv_packetnum;
+
+    /* number of data packets sent */
+    uint32_t  sent_packetnum; 
+
+    /* number of packets sent by the other peer. */
+    uint32_t  osent_packetnum; 
+
+    /* number of latest packet written onto the sendbuffer */
+    uint32_t  sendbuff_packetnum;
+
+    /* we know all packets before that number were successfully sent */
+    uint32_t  successful_sent; 
+
+    /* packet number of last packet read with the read_packet function */
+    uint32_t  successful_read; 
+
+    /* list of currently requested packet numbers(by the other person) */
+    uint32_t  req_packets[BUFFER_PACKET_NUM]; 
+
+    /* total number of currently requested packets(by the other person) */
+    uint16_t  num_req_paquets;  
+
+    uint8_t   recv_counter;
+    uint8_t   send_counter;
+    uint8_t   timeout; /* connection timeout in seconds. */
 } Connection;
 
 
@@ -94,26 +122,33 @@ static uint32_t connections_number; /* Number of connections in connections arra
 
 /* Functions */
 
-/* get connection id from IP_Port
-   return -1 if there are no connections like we are looking for
-   return id if it found it */
+/* 
+ * Get connection id from IP_Port
+ * Return -1 if there are no connections like we are looking for
+ * Return id if it found it
+ */
 int getconnection_id(IP_Port ip_port)
 {
     uint32_t i;
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if (connections[i].ip_port.ip.i == ip_port.ip.i &&
-            connections[i].ip_port.port == ip_port.port && connections[i].status > 0)
+            connections[i].ip_port.port == ip_port.port && 
+            connections[i].status > 0)
             return i;
     }
+
     return -1;
 }
 
 /* table of random numbers used below. */
 static uint32_t randtable[6][256];
 
-/* generate a handshake_id which depends on the ip_port.
-   this function will always give one unique handshake_id per ip_port.
-   TODO: make this better */
+/* 
+ * Generate a handshake_id which depends on the ip_port.
+ * This function will always give one unique handshake_id per ip_port.
+ *
+ * TODO: make this better
+ */
 uint32_t handshake_id(IP_Port source)
 {
     uint32_t id = 0, i;
@@ -124,21 +159,27 @@ uint32_t handshake_id(IP_Port source)
     }
     if (id == 0) /* id can't be zero */
         id = 1;
+
     return id;
 }
 
-/* change the hnshake id associated with that ip_port
-   TODO: make this better */
+/* 
+ * Change the hanshake id associated with that ip_port
+ *
+ * TODO: make this better
+ */
 void change_handshake(IP_Port source)
 {
     uint8_t rand = random_int() % 4;
     randtable[rand][((uint8_t *)&source)[rand]] = random_int();
 }
 
-/* initialize a new connection to ip_port
-   returns an integer corresponding to the connection id.
-   return -1 if it could not initialize the connection.
-   if there already was an existing connection to that ip_port return its number. */
+/* 
+ * Initialize a new connection to ip_port
+ * Returns an integer corresponding to the connection idt
+ * Return -1 if it could not initialize the connectiont
+ * If there already was an existing connection to that ip_port return its number.
+ */
 int new_connection(IP_Port ip_port)
 {
     int connect = getconnection_id(ip_port);
@@ -148,8 +189,10 @@ int new_connection(IP_Port ip_port)
     if(connections_number == connections_length) {
         Connection * temp;
         temp = realloc(connections, sizeof(Connection) * (connections_length + 1));
+
         if(temp == NULL)
             return -1;
+
         memset(&temp[connections_length], 0, sizeof(Connection));
         ++connections_length;
         connections = temp;
@@ -159,31 +202,37 @@ int new_connection(IP_Port ip_port)
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if(connections[i].status == 0) {
             memset(&connections[i], 0, sizeof(Connection));
-            connections[i].ip_port = ip_port;
-            connections[i].status = 1;
-            connections[i].inbound = 0;
-            connections[i].handshake_id1 = handshake_id(ip_port);
-            connections[i].sent_packetnum = connections[i].handshake_id1;
-            connections[i].sendbuff_packetnum = connections[i].handshake_id1;
-            connections[i].successful_sent = connections[i].handshake_id1;
-            connections[i].SYNC_rate = SYNC_RATE;
-            connections[i].data_rate = DATA_SYNC_RATE;
-            connections[i].last_recvSYNC = current_time();
-            connections[i].last_sent = current_time();
-            connections[i].killat = ~0;
-            connections[i].send_counter = 0;
-            /* add randomness to timeout to prevent connections getting stuck in a loop. */
-            connections[i].timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
+
+            connections[i] = (Connection) {
+              .ip_port            = ip_port,
+              .status             = 1,
+              .inbound            = 0,
+              .handshake_id1      = handshake_id(ip_port),
+              .sent_packetnum     = connections[i].handshake_id1,
+              .sendbuff_packetnum = connections[i].handshake_id1,
+              .successful_sent    = connections[i].handshake_id1,
+              .SYNC_rate          = SYNC_RATE,
+              .data_rate          = DATA_SYNC_RATE,
+              .last_recvSYNC      = current_time(),
+              .last_sent          = current_time(),
+              .killat             = ~0,
+              .send_counter       = 0,
+              /* add randomness to timeout to prevent connections getting stuck in a loop. */
+              .timeout            = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT
+            };
             ++connections_number;
+
             return i;
         }
     }
     return -1;
 }
 
-/* initialize a new inbound connection from ip_port
-   returns an integer corresponding to the connection id.
-   return -1 if it could not initialize the connection. */
+/* 
+ * Initialize a new inbound connection from ip_port
+ * Returns an integer corresponding to the connection id.
+ * Return -1 if it could not initialize the connection.
+ */
 int new_inconnection(IP_Port ip_port)
 {
     if (getconnection_id(ip_port) != -1)
@@ -192,8 +241,10 @@ int new_inconnection(IP_Port ip_port)
     if(connections_number == connections_length) {
         Connection * temp;
         temp = realloc(connections, sizeof(Connection) * (connections_length + 1));
+
         if(temp == NULL)
             return -1;
+
         memset(&temp[connections_length], 0, sizeof(Connection));
         ++connections_length;
         connections = temp;
@@ -203,18 +254,23 @@ int new_inconnection(IP_Port ip_port)
     for (i = 0; i < MAX_CONNECTIONS; ++i) {
         if (connections[i].status == 0) {
             memset(&connections[i], 0, sizeof(Connection));
-            connections[i].ip_port = ip_port;
-            connections[i].status = 2;
-            connections[i].inbound = 2;
-            connections[i].SYNC_rate = SYNC_RATE;
-            connections[i].data_rate = DATA_SYNC_RATE;
-            connections[i].last_recvSYNC = current_time();
-            connections[i].last_sent = current_time();
-            /* add randomness to timeout to prevent connections getting stuck in a loop. */
-            connections[i].timeout = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT;
-            /* if this connection isn't handled within the timeout kill it. */
-            connections[i].killat = current_time() + 1000000UL*connections[i].timeout;
-            connections[i].send_counter = 127;
+
+            connections[i] = (Connection){
+                .ip_port       = ip_port,
+                .status        = 2,
+                .inbound       = 2,
+                .SYNC_rate     = SYNC_RATE,
+                .data_rate     = DATA_SYNC_RATE,
+                .last_recvSYNC = current_time(),
+                .last_sent     = current_time(),
+                .send_counter  = 127,
+
+                /* add randomness to timeout to prevent connections getting stuck in a loop. */
+                .timeout       = CONNEXION_TIMEOUT + rand() % CONNEXION_TIMEOUT,
+
+                /* if this connection isn't handled within the timeout kill it. */
+                .killat        = current_time() + 1000000UL*connections[i].timeout
+            };
             ++connections_number;
             return i;
         }
@@ -222,8 +278,10 @@ int new_inconnection(IP_Port ip_port)
     return -1;
 }
 
-/* returns an integer corresponding to the next connection in our incoming connection list
-   return -1 if there are no new incoming connections in the list. */
+/* 
+ * Returns an integer corresponding to the next connection in our incoming connection list.
+ * Return -1 if there are no new incoming connections in the list.
+ */
 int incoming_connection()
 {
     uint32_t i;
@@ -233,9 +291,11 @@ int incoming_connection()
             return i;
         }
     }
+
     return -1;
 }
-/*Try to free some memory from the connections array.*/
+
+/* Try to free some memory from the connections array. */
 static void free_connections()
 {
     uint32_t i;
@@ -245,16 +305,20 @@ static void free_connections()
 
     if(connections_length == i)
         return;
+
     Connection * temp;
     temp = realloc(connections, sizeof(Connection) * i);
     if(temp == NULL && i != 0)
         return;
+
     connections = temp;
     connections_length = i;
 }
 
-/* return -1 if it could not kill the connection.
-   return 0 if killed successfully */
+/* 
+ * Return -1 if it could not kill the connection.
+ * Return 0 if killed successfully
+ */
 int kill_connection(int connection_id)
 {
     if (connection_id >= 0 && connection_id < MAX_CONNECTIONS) {
@@ -269,9 +333,11 @@ int kill_connection(int connection_id)
     return -1;
 }
 
-/* kill connection in seconds seconds.
-   return -1 if it can not kill the connection.
-   return 0 if it will kill it */
+/* 
+ * Kill connection in seconds.
+ * Return -1 if it can not kill the connection.
+ * Return 0 if it will kill it.
+ */
 int kill_connection_in(int connection_id, uint32_t seconds)
 {
     if (connection_id >= 0 && connection_id < MAX_CONNECTIONS) {
@@ -283,12 +349,14 @@ int kill_connection_in(int connection_id, uint32_t seconds)
     return -1;
 }
 
-/* check if connection is connected
-   return 0 no.
-   return 1 if attempting handshake
-   return 2 if handshake is done
-   return 3 if fully connected
-   return 4 if timed out and waiting to be killed */
+/* 
+ * Check if connection is connected:
+ * Return 0 no.
+ * Return 1 if attempting handshake.
+ * Return 2 if handshake is done.
+ * Return 3 if fully connected.
+ * Return 4 if timed out and waiting to be killed.
+ */
 int is_connected(int connection_id)
 {
     if (connection_id >= 0 && connection_id < MAX_CONNECTIONS)
@@ -327,8 +395,10 @@ char id_packet(int connection_id)
 {
     if (connection_id < 0 || connection_id >= MAX_CONNECTIONS)
         return -1;
+
     if (recvqueue(connection_id) != 0 && connections[connection_id].status != 0)
         return connections[connection_id].recvbuffer[connections[connection_id].successful_read % MAX_QUEUE_NUM].data[0];
+
     return -1;
 }
 
@@ -338,7 +408,7 @@ int read_packet(int connection_id, uint8_t * data)
 {
     if (recvqueue(connection_id) != 0) {
         uint16_t index = connections[connection_id].successful_read % MAX_QUEUE_NUM;
-        uint16_t size = connections[connection_id].recvbuffer[index].size;
+        uint16_t size  = connections[connection_id].recvbuffer[index].size;
         memcpy(data, connections[connection_id].recvbuffer[index].data, size);
         ++connections[connection_id].successful_read;
         connections[connection_id].recvbuffer[index].size = 0;
@@ -347,14 +417,15 @@ int read_packet(int connection_id, uint8_t * data)
     return 0;
 }
 
-/* return 0 if data could not be put in packet queue
-   return 1 if data was put into the queue */
+/* 
+ * Return 0 if data could not be put in packet queue
+ * Return 1 if data was put into the queue
+ */
 int write_packet(int connection_id, uint8_t * data, uint32_t length)
 {
-    if (length > MAX_DATA_SIZE)
-        return 0;
-    if (length == 0)
+    if (length > MAX_DATA_SIZE || length == 0)
         return 0;
+
     if (sendqueue(connection_id) <  BUFFER_PACKET_NUM) {
         uint32_t index = connections[connection_id].sendbuff_packetnum % MAX_QUEUE_NUM;
         memcpy(connections[connection_id].sendbuffer[index].data, data, length);
@@ -362,6 +433,7 @@ int write_packet(int connection_id, uint8_t * data, uint32_t length)
         connections[connection_id].sendbuff_packetnum++;
         return 1;
     }
+
     return 0;
 }
 
@@ -371,8 +443,11 @@ uint32_t missing_packets(int connection_id, uint32_t * requested)
     uint32_t number = 0;
     uint32_t i;
     uint32_t temp;
-    if (recvqueue(connection_id) >= (BUFFER_PACKET_NUM - 1)) /* don't request packets if the buffer is full. */
+
+    /* don't request packets if the buffer is full. */
+    if (recvqueue(connection_id) >= (BUFFER_PACKET_NUM - 1)) 
         return 0;
+
     for (i = connections[connection_id].recv_packetnum; i != connections[connection_id].osent_packetnum; i++) {
         if(connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size == 0) {
             temp = htonl(i);
@@ -380,14 +455,19 @@ uint32_t missing_packets(int connection_id, uint32_t * requested)
             ++number;
         }
     }
+    
     if(number == 0)
         connections[connection_id].recv_packetnum = connections[connection_id].osent_packetnum;
+
     return number;
 }
 
-/* Packet sending functions
-  One per packet type.
-  see docs/Lossless_UDP.txt for more information. */
+/* 
+ * BEGIN Packet sending functions
+ * One per packet type.
+ * see docs/Lossless_UDP.txt for more information.
+ */
+
 int send_handshake(IP_Port ip_port, uint32_t handshake_id1, uint32_t handshake_id2)
 {
     uint8_t packet[1 + 4 + 4];
@@ -398,21 +478,22 @@ int send_handshake(IP_Port ip_port, uint32_t handshake_id1, uint32_t handshake_i
     memcpy(packet + 1, &temp, 4);
     temp = htonl(handshake_id2);
     memcpy(packet + 5, &temp, 4);
+
     return sendpacket(ip_port, packet, sizeof(packet));
 }
 
 int send_SYNC(uint32_t connection_id)
 {
-
     uint8_t packet[(BUFFER_PACKET_NUM*4 + 4 + 4 + 2)];
     uint16_t index = 0;
 
-    IP_Port ip_port = connections[connection_id].ip_port;
-    uint8_t counter = connections[connection_id].send_counter;
+    IP_Port ip_port         = connections[connection_id].ip_port;
+    uint8_t counter         = connections[connection_id].send_counter;
     uint32_t recv_packetnum = htonl(connections[connection_id].recv_packetnum);
     uint32_t sent_packetnum = htonl(connections[connection_id].sent_packetnum);
+
     uint32_t requested[BUFFER_PACKET_NUM];
-    uint32_t number = missing_packets(connection_id, requested);
+    uint32_t number         = missing_packets(connection_id, requested);
 
     packet[0] = 17;
     index += 1;
@@ -462,17 +543,24 @@ int send_DATA(uint32_t connection_id)
     return 0;
 }
 
-/* END of packet sending functions */
+/* 
+ * END of packet sending functions
+ *
+ *
+ * BEGIN Packet handling functions
+ * One to handle each type of packets we receive
+ */
+
 
-/* Packet handling functions
-   One to handle each type of packets we receive
-   return 0 if handled correctly, 1 if packet is bad. */
+/* Return 0 if handled correctly, 1 if packet is bad. */
 int handle_handshake(uint8_t * packet, uint32_t length, IP_Port source)
 {
     if (length != (1 + 4 + 4))
         return 1;
+
     uint32_t temp;
     uint32_t handshake_id1, handshake_id2;
+
     int connection = getconnection_id(source);
     memcpy(&temp, packet + 1, 4);
     handshake_id1 = ntohl(temp);
@@ -485,21 +573,22 @@ int handle_handshake(uint8_t * packet, uint32_t length, IP_Port source)
     }
     if (is_connected(connection) != 1)
         return 1;
-    if (handshake_id2 == connections[connection].handshake_id1) { /* if handshake_id2 is what we sent previously as handshake_id1 */
+
+    /* if handshake_id2 is what we sent previously as handshake_id1 */
+    if (handshake_id2 == connections[connection].handshake_id1) { 
         connections[connection].status = 2;
         /* NOTE: is this necessary?
         connections[connection].handshake_id2 = handshake_id1; */
         connections[connection].orecv_packetnum = handshake_id2;
         connections[connection].osent_packetnum = handshake_id1;
-        connections[connection].recv_packetnum = handshake_id1;
+        connections[connection].recv_packetnum  = handshake_id1;
         connections[connection].successful_read = handshake_id1;
     }
-    return 0;
 
+    return 0;
 }
 
-/* returns 1 if sync packet is valid
-   0 if not. */
+/* returns 1 if sync packet is valid 0 if not. */
 int SYNC_valid(uint32_t length)
 {
     if (length < 4 + 4 + 2)
@@ -510,19 +599,19 @@ int SYNC_valid(uint32_t length)
     return 1;
 }
 
-/* case 1: */
+/* case 1 in handle_SYNC: */
 int handle_SYNC1(IP_Port source, uint32_t recv_packetnum, uint32_t sent_packetnum)
 {
     if (handshake_id(source) == recv_packetnum) {
         int x = new_inconnection(source);
         if (x != -1) {
-            connections[x].orecv_packetnum = recv_packetnum;
-            connections[x].sent_packetnum = recv_packetnum;
+            connections[x].orecv_packetnum    = recv_packetnum;
+            connections[x].sent_packetnum     = recv_packetnum;
             connections[x].sendbuff_packetnum = recv_packetnum;
-            connections[x].successful_sent = recv_packetnum;
-            connections[x].osent_packetnum = sent_packetnum;
-            connections[x].recv_packetnum = sent_packetnum;
-            connections[x].successful_read = sent_packetnum;
+            connections[x].successful_sent    = recv_packetnum;
+            connections[x].osent_packetnum    = sent_packetnum;
+            connections[x].recv_packetnum     = sent_packetnum;
+            connections[x].successful_read    = sent_packetnum;
 
             return x;
         }
@@ -530,7 +619,7 @@ int handle_SYNC1(IP_Port source, uint32_t recv_packetnum, uint32_t sent_packetnu
     return -1;
 }
 
-/* case 2: */
+/* case 2 in handle_SYNC: */
 int handle_SYNC2(int connection_id, uint8_t counter, uint32_t recv_packetnum, uint32_t sent_packetnum)
 {
     if (recv_packetnum == connections[connection_id].orecv_packetnum) {
@@ -543,7 +632,7 @@ int handle_SYNC2(int connection_id, uint8_t counter, uint32_t recv_packetnum, ui
     }
     return 1;
 }
-/* case 3: */
+/* case 3 in handle_SYNC: */
 int handle_SYNC3(int connection_id, uint8_t counter, uint32_t recv_packetnum, uint32_t sent_packetnum, uint32_t * req_packets,
                  uint16_t number)
 {
@@ -553,17 +642,25 @@ int handle_SYNC3(int connection_id, uint8_t counter, uint32_t recv_packetnum, ui
        uint32_t comp_2 = (sent_packetnum - connections[connection_id].successful_read); */
     uint32_t comp_1 = (recv_packetnum - connections[connection_id].orecv_packetnum);
     uint32_t comp_2 = (sent_packetnum - connections[connection_id].osent_packetnum);
-    if (comp_1 <= BUFFER_PACKET_NUM && comp_2 <= BUFFER_PACKET_NUM && comp_counter < 10 && comp_counter != 0) { /* packet valid */
+
+    /* packet valid */
+    if (comp_1 <= BUFFER_PACKET_NUM && 
+        comp_2 <= BUFFER_PACKET_NUM && 
+        comp_counter < 10 && comp_counter != 0) { 
+
         connections[connection_id].orecv_packetnum = recv_packetnum;
         connections[connection_id].osent_packetnum = sent_packetnum;
         connections[connection_id].successful_sent = recv_packetnum;
-        connections[connection_id].last_recvSYNC = current_time();
-        connections[connection_id].recv_counter = counter;
+        connections[connection_id].last_recvSYNC   = current_time();
+        connections[connection_id].recv_counter    = counter;
+
         ++connections[connection_id].send_counter;
+
         for (i = 0; i < number; ++i) {
             temp = ntohl(req_packets[i]);
             memcpy(connections[connection_id].req_packets + i, &temp, 4 * number);
         }
+
         connections[connection_id].num_req_paquets = number;
         return 0;
     }
@@ -575,6 +672,7 @@ int handle_SYNC(uint8_t *packet, uint32_t length, IP_Port source)
 
     if (!SYNC_valid(length))
         return 1;
+
     int connection = getconnection_id(source);
     uint8_t counter;
     uint32_t temp;
@@ -587,19 +685,27 @@ int handle_SYNC(uint8_t *packet, uint32_t length, IP_Port source)
     recv_packetnum = ntohl(temp);
     memcpy(&temp,packet + 6,  4);
     sent_packetnum = ntohl(temp);
+
     if (number != 0)
         memcpy(req_packets, packet + 10,  4 * number);
+
     if (connection == -1)
         return handle_SYNC1(source, recv_packetnum, sent_packetnum);
+
     if (connections[connection].status ==  2)
-        return handle_SYNC2(connection, counter, recv_packetnum, sent_packetnum);
+        return handle_SYNC2(connection, counter, 
+                            recv_packetnum, sent_packetnum);
+
     if (connections[connection].status ==  3)
-        return handle_SYNC3(connection, counter, recv_packetnum, sent_packetnum, req_packets, number);
+        return handle_SYNC3(connection, counter, recv_packetnum, 
+                            sent_packetnum, req_packets, number);
     return 0;
 }
 
-/* add a packet to the received buffer and set the recv_packetnum of the connection to its proper value.
-   return 1 if data was too big, 0 if not. */
+/* 
+ * Add a packet to the received buffer and set the recv_packetnum of the 
+ * connection to its proper value. Return 1 if data was too big, 0 if not.
+ */
 int add_recv(int connection_id, uint32_t data_num, uint8_t *data, uint16_t size)
 {
     if (size > MAX_DATA_SIZE)
@@ -608,16 +714,22 @@ int add_recv(int connection_id, uint32_t data_num, uint8_t *data, uint16_t size)
     uint32_t i;
     uint32_t maxnum = connections[connection_id].successful_read + BUFFER_PACKET_NUM;
     uint32_t sent_packet = data_num - connections[connection_id].osent_packetnum;
+
     for (i = connections[connection_id].recv_packetnum; i != maxnum; ++i) {
         if (i == data_num) {
             memcpy(connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].data, data, size);
+
             connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size = size;
             connections[connection_id].last_recvdata = current_time();
-            if (sent_packet < BUFFER_PACKET_NUM)
+
+            if (sent_packet < BUFFER_PACKET_NUM) {
                 connections[connection_id].osent_packetnum = data_num;
+            }
+
             break;
         }
     }
+
     for (i = connections[connection_id].recv_packetnum; i != maxnum; ++i) {
         if (connections[connection_id].recvbuffer[i % MAX_QUEUE_NUM].size != 0)
             connections[connection_id].recv_packetnum = i;
@@ -635,25 +747,30 @@ int handle_data(uint8_t *packet, uint32_t length, IP_Port source)
     if (connection == -1)
         return 1;
 
-    if (connections[connection].status != 3) /* Drop the data packet if connection is not connected. */
+    /* Drop the data packet if connection is not connected. */
+    if (connections[connection].status != 3)
         return 1;
 
     if (length > 1 + 4 + MAX_DATA_SIZE || length < 1 + 4 + 1)
         return 1;
+
     uint32_t temp;
     uint32_t number;
     uint16_t size = length - 1 - 4;
 
     memcpy(&temp, packet + 1, 4);
     number = ntohl(temp);
+
     return add_recv(connection, number, packet + 5, size);
 }
 
-/* END of packet handling functions */
+/* 
+ * END of packet handling functions 
+ */
 
 int LosslessUDP_handlepacket(uint8_t *packet, uint32_t length, IP_Port source)
 {
-    switch (packet[0]) { //TODO: check if no break statement is correct???
+    switch (packet[0]) {
     case 16:
         return handle_handshake(packet, length, source);
 
@@ -670,8 +787,10 @@ int LosslessUDP_handlepacket(uint8_t *packet, uint32_t length, IP_Port source)
     return 0;
 }
 
-/* Send handshake requests
-   handshake packets are sent at the same rate as SYNC packets */
+/*
+ * Send handshake requests
+ * handshake packets are sent at the same rate as SYNC packets
+ */
 void doNew()
 {
     uint32_t i;
@@ -684,10 +803,13 @@ void doNew()
             }
 
         /* kill all timed out connections */
-        if ( connections[i].status > 0 && (connections[i].last_recvSYNC + connections[i].timeout * 1000000UL) < temp_time &&
-             connections[i].status != 4)
-            /* kill_connection(i); */
+        if (connections[i].status > 0 && 
+            (connections[i].last_recvSYNC + connections[i].timeout * 1000000UL) < temp_time &&
+            connections[i].status != 4) {
             connections[i].status = 4;
+            /* kill_connection(i); */
+        }
+
         if (connections[i].status > 0 && connections[i].killat < temp_time)
             kill_connection(i);
     }
@@ -720,11 +842,13 @@ void doData()
             }
 }
 
-/* TODO: flow control.
-   automatically adjusts send rates of packets for optimal transmission. */
-
 #define MAX_SYNC_RATE 10
 
+/* 
+ * Automatically adjusts send rates of packets for optimal transmission.
+ *
+ * TODO: flow control.
+ */
 void adjustRates()
 {
     uint32_t i;
@@ -744,8 +868,7 @@ void adjustRates()
     }
 }
 
-/* Call this function a couple times per second
-   It's the main loop. */
+/* Call this function a couple times per second It's the main loop. */
 void doLossless_UDP()
 {
     doNew();
diff --git a/core/Lossless_UDP.h b/core/Lossless_UDP.h
index 033bc480..573e1ab9 100644
--- a/core/Lossless_UDP.h
+++ b/core/Lossless_UDP.h
@@ -33,70 +33,90 @@ extern "C" {
 /* maximum length of the data in the data packets */
 #define MAX_DATA_SIZE 1024
 
-/* Functions */
-
-/* initialize a new connection to ip_port
-    returns an integer corresponding to the connection id.
-    return -1 if it could not initialize the connection.
-    if there already was an existing connection to that ip_port return its number. */
+/* 
+ * Initialize a new connection to ip_port
+ * Returns an integer corresponding to the connection id.
+ * Return -1 if it could not initialize the connection.
+ * Return number if there already was an existing connection to that ip_port.
+ */
 int new_connection(IP_Port ip_port);
 
-/* get connection id from IP_Port
-    return -1 if there are no connections like we are looking for
-    return id if it found it */
+/* 
+ * Get connection id from IP_Port.
+ * Return -1 if there are no connections like we are looking for.
+ * Return id if it found it .
+ */
 int getconnection_id(IP_Port ip_port);
 
-/* returns an integer corresponding to the next connection in our imcoming connection list
-    return -1 if there are no new incoming connections in the list. */
+/* 
+ * Returns an int corresponding to the next connection in our imcoming connection list
+ * Return -1 if there are no new incoming connections in the list.
+ */
 int incoming_connection();
 
-/* return -1 if it could not kill the connection.
-    return 0 if killed successfully */
+/* 
+ * Return -1 if it could not kill the connection.
+ * Return 0 if killed successfully
+ */
 int kill_connection(int connection_id);
 
-/* kill connection in seconds seconds.
-    return -1 if it can not kill the connection.
-    return 0 if it will kill it */
+/* 
+ * Kill connection in seconds seconds.
+ * Return -1 if it can not kill the connection.
+ * Return 0 if it will kill it
+ */
 int kill_connection_in(int connection_id, uint32_t seconds);
 
-/* returns the ip_port of the corresponding connection.
-    return 0 if there is no such connection. */
+/* 
+ * Returns the ip_port of the corresponding connection.
+ * Return 0 if there is no such connection.
+ */
 IP_Port connection_ip(int connection_id);
 
-/* returns the id of the next packet in the queue
-    return -1 if no packet in queue */
+/* 
+ * Returns the id of the next packet in the queue 
+ * Return -1 if no packet in queue 
+ */
 char id_packet(int connection_id);
 
-/* return 0 if there is no received data in the buffer.
-    return length of received packet if successful */
+/* 
+ * Return 0 if there is no received data in the buffer.
+ * Return length of received packet if successful 
+ */
 int read_packet(int connection_id, uint8_t *data);
 
-/* return 0 if data could not be put in packet queue
-    return 1 if data was put into the queue */
+/* 
+ * Return 0 if data could not be put in packet queue
+ * Return 1 if data was put into the queue
+ */
 int write_packet(int connection_id, uint8_t *data, uint32_t length);
 
-/* returns the number of packets in the queue waiting to be successfully sent. */
+/* Returns the number of packets in the queue waiting to be successfully sent. */
 uint32_t sendqueue(int connection_id);
 
-/* returns the number of packets in the queue waiting to be successfully read with read_packet(...) */
+/* 
+ * returns the number of packets in the queue waiting to be successfully 
+ * read with read_packet(...)
+ */
 uint32_t recvqueue(int connection_id);
 
-/* check if connection is connected
-    return 0 no.
-    return 1 if attempting handshake
-    return 2 if handshake is done
-    return 3 if fully connected
-    return 4 if timed out and wating to be killed */
+/* Check if connection is connected:
+ * Return 0 no.
+ * Return 1 if attempting handshake.
+ * Return 2 if handshake is done.
+ * Return 3 if fully connected.
+ * Return 4 if timed out and wating to be killed.
+ */
 int is_connected(int connection_id);
 
-/* Call this function a couple times per second
-    It's the main loop. */
+/* Call this function a couple times per second It's the main loop. */
 void doLossless_UDP();
 
-
-/* if we receive a Lossless_UDP packet we call this function so it can be handled.
-    return 0 if packet is handled correctly.
-    return 1 if it didn't handle the packet or if the packet was shit. */
+/* 
+ * If we receive a Lossless_UDP packet, call this function so it can be handled.
+ * Return 0 if packet is handled correctly.
+ * Return 1 if it didn't handle the packet or if the packet was shit.
+ */
 int LosslessUDP_handlepacket(uint8_t *packet, uint32_t length, IP_Port source);
 
 #ifdef __cplusplus
diff --git a/core/Messenger.c b/core/Messenger.c
index eb59b81a..30f3f658 100644
--- a/core/Messenger.c
+++ b/core/Messenger.c
@@ -27,7 +27,7 @@
 typedef struct {
     uint8_t client_id[CLIENT_ID_SIZE];
     int crypt_connection_id;
-    int friend_request_id; /* id of the friend request corresponding to the current friend request to the current friend. */
+    int64_t friend_request_id; /* id of the friend request corresponding to the current friend request to the current friend. */
     uint8_t status; /* 0 if no friend, 1 if added, 2 if friend request sent, 3 if confirmed friend, 4 if online. */
     uint8_t info[MAX_DATA_SIZE]; /* the data that is sent during the friend requests we do */
     uint8_t name[MAX_NAME_LENGTH];
@@ -94,24 +94,31 @@ int getclient_id(int friend_id, uint8_t *client_id)
     return -1;
 }
 
-/* add a friend
-   set the data that will be sent along with friend request
-   client_id is the client id of the friend
-   data is the data and length is the length
-   returns the friend number if success
-   return -1 if key length is wrong.
-   return -2 if user's own key
-   return -3 if already a friend
-   return -4 for other*/
+/*
+ * add a friend
+ * set the data that will be sent along with friend request
+ * client_id is the client id of the friend
+ * data is the data and length is the length
+ * returns the friend number if success
+ * return -1 if message length is too long
+ * return -2 if no message (message length must be >= 1 byte)
+ * return -3 if user's own key
+ * return -4 if friend request already sent or already a friend
+ * return -5 for unknown error 
+ */
 int m_addfriend(uint8_t *client_id, uint8_t *data, uint16_t length)
 {
-    if (length == 0 || length >=
-        (MAX_DATA_SIZE - crypto_box_PUBLICKEYBYTES - crypto_box_NONCEBYTES - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES))
+    if (length >= (MAX_DATA_SIZE - crypto_box_PUBLICKEYBYTES 
+                         - crypto_box_NONCEBYTES - crypto_box_BOXZEROBYTES 
+                         + crypto_box_ZEROBYTES))
         return -1;
-    if (memcmp(client_id, self_public_key, crypto_box_PUBLICKEYBYTES) == 0)
+    if (length < 1)
         return -2;
-    if (getfriend_id(client_id) != -1)
+    if (memcmp(client_id, self_public_key, crypto_box_PUBLICKEYBYTES) == 0)
         return -3;
+    if (getfriend_id(client_id) != -1)
+        return -4;
+
     uint32_t i;
     for (i = 0; i <= numfriends; ++i) { /*TODO: dynamic memory allocation, this will segfault if there are more than MAX_NUM_FRIENDS*/
         if(friendlist[i].status == 0) {
@@ -129,7 +136,7 @@ int m_addfriend(uint8_t *client_id, uint8_t *data, uint16_t length)
             return i;
         }
     }
-    return -4;
+    return -5;
 }
 
 int m_addfriend_norequest(uint8_t * client_id)
@@ -484,7 +491,7 @@ static void doInbound()
 /*Interval in seconds between LAN discovery packet sending*/
 #define LAN_DISCOVERY_INTERVAL 60
 
-static uint32_t last_LANdiscovery;
+static int64_t last_LANdiscovery;
 
 /*Send a LAN discovery packet every LAN_DISCOVERY_INTERVAL seconds*/
 static void LANdiscovery()
diff --git a/core/Messenger.h b/core/Messenger.h
index 9ce96fb4..3f144ff4 100644
--- a/core/Messenger.h
+++ b/core/Messenger.h
@@ -45,15 +45,18 @@ extern "C" {
 /* don't assume MAX_USERSTATUS_LENGTH will stay at 128, it may be increased
     to an absurdly large number later */
 
-/* add a friend
-   set the data that will be sent along with friend request
-   client_id is the client id of the friend
-   data is the data and length is the length
-   returns the friend number if success
-   return -1 if key length is wrong.
-   return -2 if user's own key
-   return -3 if already a friend
-   return -4 for other*/
+/*
+ * add a friend
+ * set the data that will be sent along with friend request
+ * client_id is the client id of the friend
+ * data is the data and length is the length
+ * returns the friend number if success
+ * return -1 if message length is too long
+ * return -2 if no message (message length must be >= 1 byte)
+ * return -3 if user's own key
+ * return -4 if friend request already sent or already a friend
+ * return -5 for unknown error 
+ */
 int m_addfriend(uint8_t *client_id, uint8_t *data, uint16_t length);
 
 
diff --git a/core/net_crypto.c b/core/net_crypto.c
index 83cb20a2..31fb24be 100644
--- a/core/net_crypto.c
+++ b/core/net_crypto.c
@@ -48,6 +48,12 @@ typedef struct {
 
 static Crypto_Connection crypto_connections[MAX_CRYPTO_CONNECTIONS];
 
+#define CONN_NO_CONNECTION 0
+#define CONN_HANDSHAKE_SENT 1
+#define CONN_NOT_CONFIRMED 2
+#define CONN_ESTABLISHED 3
+#define CONN_TIMED_OUT 4
+
 #define MAX_INCOMING 64
 
 /* keeps track of the connection numbers for friends request so we can check later if they were sent */
@@ -75,10 +81,9 @@ int encrypt_data(uint8_t *public_key, uint8_t *secret_key, uint8_t *nonce,
     uint32_t i;
     uint32_t check = 0;
     for(i = 0; i < crypto_box_BOXZEROBYTES; ++i) {
-        if (temp_encrypted[i] != 0)
-            check = 1;
+            check |= temp_encrypted[i] ^ 0;
     }
-    if(check == 1)
+    if(check != 0)
         return -1;
 
     /* unpad the encrypted message */
@@ -110,10 +115,9 @@ int decrypt_data(uint8_t *public_key, uint8_t *secret_key, uint8_t *nonce,
     uint32_t i;
     uint32_t check = 0;
     for(i = 0; i < crypto_box_ZEROBYTES; ++i) {
-        if (temp_plain[i] != 0)
-            check = 1;
+            check |= temp_plain[i] ^ 0;
     }
-    if(check == 1)
+    if(check != 0)
         return -1;
 
     /* unpad the plain message */
@@ -149,7 +153,7 @@ int read_cryptpacket(int crypt_connection_id, uint8_t *data)
 {
     if (crypt_connection_id < 0 || crypt_connection_id >= MAX_CRYPTO_CONNECTIONS)
         return 0;
-    if (crypto_connections[crypt_connection_id].status != 3)
+    if (crypto_connections[crypt_connection_id].status != CONN_ESTABLISHED)
         return 0;
     uint8_t temp_data[MAX_DATA_SIZE];
     int length = read_packet(crypto_connections[crypt_connection_id].number, temp_data);
@@ -175,7 +179,7 @@ int write_cryptpacket(int crypt_connection_id, uint8_t *data, uint32_t length)
         return 0;
     if (length - crypto_box_BOXZEROBYTES + crypto_box_ZEROBYTES > MAX_DATA_SIZE - 1)
         return 0;
-    if (crypto_connections[crypt_connection_id].status != 3)
+    if (crypto_connections[crypt_connection_id].status != CONN_ESTABLISHED)
         return 0;
     uint8_t temp_data[MAX_DATA_SIZE];
     int len = encrypt_data(crypto_connections[crypt_connection_id].peersessionpublic_key,
@@ -295,7 +299,7 @@ int getcryptconnection_id(uint8_t *public_key)
 {
     uint32_t i;
     for (i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) {
-        if (crypto_connections[i].status > 0)
+        if (crypto_connections[i].status != CONN_NO_CONNECTION)
             if (memcmp(public_key, crypto_connections[i].public_key, crypto_box_PUBLICKEYBYTES) == 0)
                 return i;
     }
@@ -315,12 +319,12 @@ int crypto_connect(uint8_t *public_key, IP_Port ip_port)
             return -1;
     }
     for (i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) {
-        if (crypto_connections[i].status == 0) {
+        if (crypto_connections[i].status == CONN_NO_CONNECTION) {
             int id = new_connection(ip_port);
             if (id == -1)
                 return -1;
             crypto_connections[i].number = id;
-            crypto_connections[i].status = 1;
+            crypto_connections[i].status = CONN_HANDSHAKE_SENT;
             random_nonce(crypto_connections[i].recv_nonce);
             memcpy(crypto_connections[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);
             crypto_box_keypair(crypto_connections[i].sessionpublic_key, crypto_connections[i].sessionsecret_key);
@@ -374,8 +378,8 @@ int crypto_kill(int crypt_connection_id)
 {
     if (crypt_connection_id < 0 || crypt_connection_id >= MAX_CRYPTO_CONNECTIONS)
         return 1;
-    if (crypto_connections[crypt_connection_id].status != 0) {
-        crypto_connections[crypt_connection_id].status = 0;
+    if (crypto_connections[crypt_connection_id].status != CONN_NO_CONNECTION) {
+        crypto_connections[crypt_connection_id].status = CONN_NO_CONNECTION;
         kill_connection(crypto_connections[crypt_connection_id].number);
         memset(&crypto_connections[crypt_connection_id], 0 ,sizeof(Crypto_Connection));
         crypto_connections[crypt_connection_id].number = ~0;
@@ -398,9 +402,9 @@ int accept_crypto_inbound(int connection_id, uint8_t *public_key, uint8_t *secre
         return -1;
     }*/
     for (i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) {
-        if(crypto_connections[i].status == 0) {
+        if(crypto_connections[i].status == CONN_NO_CONNECTION) {
             crypto_connections[i].number = connection_id;
-            crypto_connections[i].status = 2;
+            crypto_connections[i].status = CONN_NOT_CONFIRMED;
             random_nonce(crypto_connections[i].recv_nonce);
             memcpy(crypto_connections[i].sent_nonce, secret_nonce, crypto_box_NONCEBYTES);
             memcpy(crypto_connections[i].peersessionpublic_key, session_key, crypto_box_PUBLICKEYBYTES);
@@ -413,9 +417,9 @@ int accept_crypto_inbound(int connection_id, uint8_t *public_key, uint8_t *secre
                                      crypto_connections[i].sessionpublic_key) == 1) {
                 increment_nonce(crypto_connections[i].recv_nonce);
                 uint32_t zero = 0;
-                crypto_connections[i].status = 3; /* connection status needs to be 3 for write_cryptpacket() to work */
+                crypto_connections[i].status = CONN_ESTABLISHED; /* connection status needs to be 3 for write_cryptpacket() to work */
                 write_cryptpacket(i, ((uint8_t *)&zero), sizeof(zero));
-                crypto_connections[i].status = 2; /* set it to its proper value right after. */
+                crypto_connections[i].status = CONN_NOT_CONFIRMED; /* set it to its proper value right after. */
                 return i;
             }
             return -1; /* this should never happen. */
@@ -431,7 +435,7 @@ int is_cryptoconnected(int crypt_connection_id)
 {
     if (crypt_connection_id >= 0 && crypt_connection_id < MAX_CRYPTO_CONNECTIONS)
         return crypto_connections[crypt_connection_id].status;
-    return 0;
+    return CONN_NO_CONNECTION;
 }
 
 /* Generate our public and private keys
@@ -490,7 +494,7 @@ static void receive_crypto()
 {
     uint32_t i;
     for (i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) {
-        if (crypto_connections[i].status == 1) {
+        if (crypto_connections[i].status == CONN_HANDSHAKE_SENT) {
             uint8_t temp_data[MAX_DATA_SIZE];
             uint8_t secret_nonce[crypto_box_NONCEBYTES];
             uint8_t public_key[crypto_box_PUBLICKEYBYTES];
@@ -507,17 +511,17 @@ static void receive_crypto()
                         memcpy(crypto_connections[i].peersessionpublic_key, session_key, crypto_box_PUBLICKEYBYTES);
                         increment_nonce(crypto_connections[i].sent_nonce);
                         uint32_t zero = 0;
-                        crypto_connections[i].status = 3; /* connection status needs to be 3 for write_cryptpacket() to work */
+                        crypto_connections[i].status = CONN_ESTABLISHED; /* connection status needs to be 3 for write_cryptpacket() to work */
                         write_cryptpacket(i, ((uint8_t *)&zero), sizeof(zero));
-                        crypto_connections[i].status = 2; /* set it to its proper value right after. */
+                        crypto_connections[i].status = CONN_NOT_CONFIRMED; /* set it to its proper value right after. */
                     }
                 }
             } else if (id_packet(crypto_connections[i].number) != -1) // This should not happen kill the connection if it does
                 crypto_kill(crypto_connections[i].number);
 
         }
-        if (crypto_connections[i].status == 2) {
-            if (id_packet(crypto_connections[i].number) == 3) {
+        if (crypto_connections[i].status == CONN_NOT_CONFIRMED) {
+            if (id_packet(crypto_connections[i].number) == CONN_ESTABLISHED) {
                 uint8_t temp_data[MAX_DATA_SIZE];
                 uint8_t data[MAX_DATA_SIZE];
                 int length = read_packet(crypto_connections[i].number, temp_data);
@@ -527,7 +531,7 @@ static void receive_crypto()
                 uint32_t zero = 0;
                 if (len == sizeof(uint32_t) && memcmp(((uint8_t *)&zero), data, sizeof(uint32_t)) == 0) {
                     increment_nonce(crypto_connections[i].recv_nonce);
-                    crypto_connections[i].status = 3;
+                    crypto_connections[i].status = CONN_ESTABLISHED;
 
                     /* connection is accepted so we disable the auto kill by setting it to about 1 month from now. */
                     kill_connection_in(crypto_connections[i].number, 3000000);
@@ -556,8 +560,8 @@ static void killTimedout()
 {
     uint32_t i;
     for (i = 0; i < MAX_CRYPTO_CONNECTIONS; ++i) {
-        if (crypto_connections[i].status != 0 && is_connected(crypto_connections[i].number) == 4)
-            crypto_connections[i].status = 4;
+        if (crypto_connections[i].status != CONN_NO_CONNECTION && is_connected(crypto_connections[i].number) == 4)
+            crypto_connections[i].status = CONN_TIMED_OUT;
         else if (is_connected(crypto_connections[i].number) == 4) {
             kill_connection(crypto_connections[i].number);
             crypto_connections[i].number = ~0;