7 files changed, 265 insertions, 164 deletions

diff --git a/core/DHT.c b/core/DHT.c
index 5039f710..272641ee 100644
--- a/core/DHT.c
+++ b/core/DHT.c
@@ -21,67 +21,98 @@
  *
  */
 
-#include "DHT.h"
+/*----------------------------------------------------------------------------------*/
 
-typedef struct {
-    uint8_t client_id[CLIENT_ID_SIZE];
-    IP_Port ip_port;
-    uint32_t timestamp;
-    uint32_t last_pinged;
-    IP_Port ret_ip_port;/* The ip_port returned by this node for the friend
-                           (for nodes in friends_list) or us (for nodes in close_clientlist) */
-    uint32_t ret_timestamp;
-} Client_data;
+#include "DHT.h"
 
 /* maximum number of clients stored per friend. */
 #define MAX_FRIEND_CLIENTS 8
 
-typedef struct {
-    uint8_t client_id[CLIENT_ID_SIZE];
-    Client_data client_list[MAX_FRIEND_CLIENTS];
-    uint32_t lastgetnode; /* time at which the last get_nodes request was sent. */
-
-    /*Symetric NAT hole punching stuff*/
-    uint8_t hole_punching; /*0 if not hole punching, 1 if currently hole punching */
-    uint32_t punching_index;
-    uint32_t punching_timestamp;
-    uint32_t recvNATping_timestamp;
-    uint64_t NATping_id;
-    uint32_t NATping_timestamp;
-} Friend;
+/* A list of the clients mathematically closest to ours. */
+#define LCLIENT_LIST 32
+
+/* The list of ip ports along with the ping_id of what we sent them and a timestamp */
+#define LPING_ARRAY 256
+
+#define LSEND_NODES_ARRAY LPING_ARRAY/2
+
+/* the number of seconds for a non responsive node to become bad. */
+#define BAD_NODE_TIMEOUT 70
+
+/* the max number of nodes to send with send nodes. */
+#define MAX_SENT_NODES 8
+
+/* ping timeout in seconds */
+#define PING_TIMEOUT 5
+
+/* The timeout after which a node is discarded completely. */
+#define Kill_NODE_TIMEOUT 300
+
+/* ping interval in seconds for each node in our lists. */
+#define PING_INTERVAL 60
+
+/* ping interval in seconds for each random sending of a get nodes request. */
+#define GET_NODE_INTERVAL 10
+
+#define MAX_PUNCHING_PORTS 32
+
+/*Interval in seconds between punching attempts*/
+#define PUNCH_INTERVAL 10
+
+/*----------------------------------------------------------------------------------*/
 
 typedef struct {
-    uint8_t client_id[CLIENT_ID_SIZE];
-    IP_Port ip_port;
-} Node_format;
+    uint8_t     client_id[CLIENT_ID_SIZE];
+    IP_Port     ip_port;
+    uint32_t    timestamp;
+    uint32_t    last_pinged;
+
+    /* Returned by this node. Either our friend or us */
+    IP_Port     ret_ip_port;
+    uint32_t    ret_timestamp;
+} Client_data;
 
 typedef struct {
-    IP_Port ip_port;
-    uint64_t ping_id;
-    uint32_t timestamp;
+    uint8_t     client_id[CLIENT_ID_SIZE];
+    Client_data client_list[MAX_FRIEND_CLIENTS];
 
-} Pinged;
+    /* time at which the last get_nodes request was sent. */
+    uint32_t    lastgetnode;
 
-/* Our client id/public key */
-uint8_t self_public_key[CLIENT_ID_SIZE];
-uint8_t self_secret_key[crypto_box_SECRETKEYBYTES];
+    /* Symetric NAT hole punching stuff */
 
-/* TODO: Move these out of here and put them into the .c file.
-   A list of the clients mathematically closest to ours. */
-#define LCLIENT_LIST 32
-static Client_data close_clientlist[LCLIENT_LIST];
+    /* 1 if currently hole punching, otherwise 0 */
+    uint8_t     hole_punching; 
+    uint32_t    punching_index;
+    uint32_t    punching_timestamp;
+    int64_t     recvNATping_timestamp;
+    uint64_t    NATping_id;
+    uint32_t    NATping_timestamp;
+} Friend;
 
-static Friend * friends_list;
-static uint16_t num_friends;
+typedef struct {
+    uint8_t     client_id[CLIENT_ID_SIZE];
+    IP_Port     ip_port;
+} Node_format;
 
-/* The list of ip ports along with the ping_id of what we sent them and a timestamp */
-#define LPING_ARRAY 256
+typedef struct {
+    IP_Port     ip_port;
+    uint64_t    ping_id;
+    int64_t     timestamp;
+} Pinged;
 
-static Pinged pings[LPING_ARRAY];
+/*----------------------------------------------------------------------------------*/
 
-#define LSEND_NODES_ARRAY LPING_ARRAY/2
+                    /* 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 uint16_t     num_friends;
+static Pinged       pings[LPING_ARRAY];
+static Pinged       send_nodes[LSEND_NODES_ARRAY];
 
-static Pinged send_nodes[LSEND_NODES_ARRAY];
+/*----------------------------------------------------------------------------------*/
 
 /* Compares client_id1 and client_id2 with client_id
    return 0 if both are same distance
@@ -107,7 +138,7 @@ 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;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
 
     for(i = 0; i < length; ++i) {
         /*If ip_port is assigned to a different client_id replace it*/
@@ -150,11 +181,6 @@ static int friend_number(uint8_t * client_id)
     return -1;
 }
 
-/* the number of seconds for a non responsive node to become bad. */
-#define BAD_NODE_TIMEOUT 70
-/* the max number of nodes to send with send nodes. */
-#define MAX_SENT_NODES 8
-
 /* Find MAX_SENT_NODES nodes closest to the client_id for the send nodes request:
    put them in the nodes_list and return how many were found.
    TODO: Make this function much more efficient. */
@@ -162,7 +188,7 @@ int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
 {
     uint32_t i, j, k;
     int num_nodes=0;
-    uint32_t 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 &&
            !client_in_nodelist(nodes_list, MAX_SENT_NODES,close_clientlist[i].client_id)) {
@@ -204,7 +230,7 @@ int get_close_nodes(uint8_t * client_id, Node_format * nodes_list)
 int replace_bad(Client_data * list, uint32_t length, uint8_t * client_id, IP_Port ip_port) /* tested */
 {
     uint32_t i;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     for(i = 0; i < length; ++i)
         if(list[i].timestamp + BAD_NODE_TIMEOUT < temp_time) { /* if node is bad. */
             memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE);
@@ -223,7 +249,7 @@ int replace_bad(Client_data * list, uint32_t length, uint8_t * client_id, IP_Por
 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;
-    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) {
@@ -262,7 +288,7 @@ 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;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     if(memcmp(client_id, self_public_key, CLIENT_ID_SIZE) == 0) {
         for(i = 0; i < LCLIENT_LIST; ++i)
             if(memcmp(nodeclient_id, close_clientlist[i].client_id, CLIENT_ID_SIZE) == 0) {
@@ -281,9 +307,6 @@ void returnedip_ports(IP_Port ip_port, uint8_t * client_id, uint8_t * nodeclient
                     }
 }
 
-/* ping timeout in seconds */
-#define PING_TIMEOUT 5
-
 /* check if we are currently pinging an ip_port and/or a ping_id
    variables with values of zero will not be checked.
    if we are already, return 1
@@ -293,7 +316,7 @@ int is_pinging(IP_Port ip_port, uint64_t ping_id)
 {
     uint32_t i;
     uint8_t pinging;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
 
     for(i = 0; i < LPING_ARRAY; ++i )
         if((pings[i].timestamp + PING_TIMEOUT) > temp_time) {
@@ -317,7 +340,7 @@ int is_gettingnodes(IP_Port ip_port, uint64_t ping_id)
 {
     uint32_t i;
     uint8_t pinging;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
 
     for(i = 0; i < LSEND_NODES_ARRAY; ++i )
         if((send_nodes[i].timestamp + PING_TIMEOUT) > temp_time) {
@@ -345,7 +368,7 @@ uint64_t add_pinging(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 < LPING_ARRAY; ++j )
@@ -364,7 +387,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 )
@@ -619,7 +642,8 @@ int handle_sendnodes(uint8_t * packet, uint32_t length, IP_Port source)
     return 0;
 }
 
-/* END of packet handling functions */
+/*----------------------------------------------------------------------------------*/
+/*------------------------END of packet handling functions--------------------------*/
 
 int DHT_addfriend(uint8_t * client_id)
 {
@@ -660,7 +684,7 @@ IP_Port DHT_getfriendip(uint8_t * client_id)
 {
     uint32_t i, j;
     IP_Port empty = {{{0}}, 0};
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     for(i = 0; i < num_friends; ++i)
         /* Equal */
         if(memcmp(friends_list[i].client_id, client_id, CLIENT_ID_SIZE) == 0) {
@@ -676,21 +700,12 @@ IP_Port DHT_getfriendip(uint8_t * client_id)
 
 }
 
-/* The timeout after which a node is discarded completely. */
-#define Kill_NODE_TIMEOUT 300
-
-/* ping interval in seconds for each node in our lists. */
-#define PING_INTERVAL 60
-
-/* ping interval in seconds for each random sending of a get nodes request. */
-#define GET_NODE_INTERVAL 10
-
 /* 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. */
 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];
 
@@ -724,7 +739,7 @@ static uint32_t close_lastgetnodes;
 void doClose() /* tested */
 {
     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];
@@ -777,7 +792,7 @@ static int friend_iplist(IP_Port * ip_portlist, uint16_t friend_num)
 {
     int num_ips = 0;
     uint32_t i;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     if(friend_num >= num_friends)
         return -1;
     for(i = 0; i < MAX_FRIEND_CLIENTS; ++i)
@@ -798,7 +813,7 @@ int route_tofriend(uint8_t * friend_id, uint8_t * packet, uint32_t length)
 {
     uint32_t i, j;
     uint32_t sent = 0;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     for(i = 0; i < num_friends; ++i)
         /* Equal */
         if(memcmp(friends_list[i].client_id, friend_id, CLIENT_ID_SIZE) == 0)  {
@@ -824,7 +839,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;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     for(i = 0; i < MAX_FRIEND_CLIENTS; ++i)
         /*If ip is not zero and node is good */
         if(friends_list[num].client_list[i].ret_ip_port.ip.i != 0 &&
@@ -855,7 +870,8 @@ int friend_ips(IP_Port * ip_portlist, uint8_t * friend_id)
     return -1;
 }
 
-/*BEGINNING OF NAT PUNCHING FUNCTIONS*/
+/*----------------------------------------------------------------------------------*/
+/*---------------------BEGINNING OF NAT PUNCHING FUNCTIONS--------------------------*/
 
 int send_NATping(uint8_t * public_key, uint64_t ping_id, uint8_t type)
 {
@@ -955,8 +971,6 @@ static uint16_t NAT_getports(uint16_t * portlist, IP_Port * ip_portlist, uint16_
     return num;
 }
 
-#define MAX_PUNCHING_PORTS 32
-
 static void punch_holes(IP ip, uint16_t * port_list, uint16_t numports, uint16_t friend_num)
 {
     if(numports > MAX_FRIEND_CLIENTS || numports == 0)
@@ -972,13 +986,10 @@ static void punch_holes(IP ip, uint16_t * port_list, uint16_t numports, uint16_t
     friends_list[friend_num].punching_index = i;
 }
 
-/*Interval in seconds between punching attempts*/
-#define PUNCH_INTERVAL 10
-
 static void doNAT()
 {
     uint32_t i;
-    uint32_t temp_time = unix_time();
+    int64_t temp_time = unix_time();
     for(i = 0; i < num_friends; ++i) {
         IP_Port ip_list[MAX_FRIEND_CLIENTS];
         int num = friend_iplist(ip_list, i);
@@ -1008,7 +1019,8 @@ static void doNAT()
     }
 }
 
-/*END OF NAT PUNCHING FUNCTIONS*/
+/*----------------------------------------------------------------------------------*/
+/*-----------------------END OF NAT PUNCHING FUNCTIONS------------------------------*/
 
 int DHT_handlepacket(uint8_t * packet, uint32_t length, IP_Port source)
 {
@@ -1066,7 +1078,7 @@ int DHT_load(uint8_t * data, uint32_t size)
     if((size - sizeof(close_clientlist)) % sizeof(Friend) != 0)
         return -1;
     uint32_t i, j;
-    /* uint32_t temp_time = unix_time(); */
+    /* int64_t temp_time = unix_time(); */
     uint16_t temp;
 
     temp = (size - sizeof(close_clientlist))/sizeof(Friend);
@@ -1096,7 +1108,7 @@ int DHT_load(uint8_t * data, uint32_t size)
 int DHT_isconnected()
 {
     uint32_t i;
-    uint32_t 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)
             return 1;
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/Messenger.c b/core/Messenger.c
index eb59b81a..3ffbe6ab 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];
@@ -71,12 +71,6 @@ int getfriend_id(uint8_t *client_id)
     return -1;
 }
 
-/* Returns number of friends */
-int getnumfriends()
-{
-    return numfriends;
-}
-
 /* copies the public key associated to that friend id into client_id buffer.
    make sure that client_id is of size CLIENT_ID_SIZE.
    return 0 if success
@@ -94,29 +88,36 @@ 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 FA_TOOLONG if message length is too long
+ * return FAERR_NOMESSAGE if no message (message length must be >= 1 byte)
+ * return FAERR_OWNKEY if user's own key
+ * return FAERR_ALREADYSENT if friend request already sent or already a friend
+ * return FAERR_UNKNOWN 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))
-        return -1;
+    if (length >= (MAX_DATA_SIZE - crypto_box_PUBLICKEYBYTES 
+                         - crypto_box_NONCEBYTES - crypto_box_BOXZEROBYTES 
+                         + crypto_box_ZEROBYTES))
+        return FAERR_TOOLONG;
+    if (length < 1)
+        return FAERR_NOMESSAGE;
     if (memcmp(client_id, self_public_key, crypto_box_PUBLICKEYBYTES) == 0)
-        return -2;
+        return FAERR_OWNKEY;
     if (getfriend_id(client_id) != -1)
-        return -3;
+        return FAERR_ALREADYSENT;
+
     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) {
+        if(friendlist[i].status == NOFRIEND) {
             DHT_addfriend(client_id);
-            friendlist[i].status = 1;
+            friendlist[i].status = FRIEND_ADDED;
             friendlist[i].crypt_connection_id = -1;
             friendlist[i].friend_request_id = -1;
             memcpy(friendlist[i].client_id, client_id, CLIENT_ID_SIZE);
@@ -129,7 +130,7 @@ int m_addfriend(uint8_t *client_id, uint8_t *data, uint16_t length)
             return i;
         }
     }
-    return -4;
+    return FAERR_UNKNOWN;
 }
 
 int m_addfriend_norequest(uint8_t * client_id)
@@ -138,9 +139,9 @@ int m_addfriend_norequest(uint8_t * client_id)
         return -1;
     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) {
+        if(friendlist[i].status == NOFRIEND) {
             DHT_addfriend(client_id);
-            friendlist[i].status = 2;
+            friendlist[i].status = FRIEND_REQUESTED;
             friendlist[i].crypt_connection_id = -1;
             friendlist[i].friend_request_id = -1;
             memcpy(friendlist[i].client_id, client_id, CLIENT_ID_SIZE);
@@ -168,7 +169,7 @@ int m_delfriend(int friendnumber)
     uint32_t i;
 
     for (i = numfriends; i != 0; --i) {
-        if (friendlist[i-1].status != 0)
+        if (friendlist[i-1].status != NOFRIEND)
             break;
     }
     numfriends = i;
@@ -176,15 +177,15 @@ int m_delfriend(int friendnumber)
     return 0;
 }
 
-/* return 4 if friend is online
-   return 3 if friend is confirmed
-   return 2 if the friend request was sent
-   return 1 if the friend was added
-   return 0 if there is no friend with that number */
+/* return FRIEND_ONLINE if friend is online
+   return FRIEND_CONFIRMED if friend is confirmed
+   return FRIEND_REQUESTED if the friend request was sent
+   return FRIEND_ADDED if the friend was added
+   return NOFRIEND if there is no friend with that number */
 int m_friendstatus(int friendnumber)
 {
     if (friendnumber < 0 || friendnumber >= numfriends)
-        return 0;
+        return NOFRIEND;
     return friendlist[friendnumber].status;
 }
 
@@ -195,7 +196,7 @@ int m_sendmessage(int friendnumber, uint8_t *message, uint32_t length)
 {
     if (friendnumber < 0 || friendnumber >= numfriends)
         return 0;
-    if (length >= MAX_DATA_SIZE || friendlist[friendnumber].status != 4)
+    if (length >= MAX_DATA_SIZE || friendlist[friendnumber].status != FRIEND_ONLINE)
         /* this does not mean the maximum message length is MAX_DATA_SIZE - 1, it is actually 17 bytes less. */
         return 0;
     uint8_t temp[MAX_DATA_SIZE];
@@ -384,15 +385,15 @@ static void doFriends()
     int len;
     uint8_t temp[MAX_DATA_SIZE];
     for (i = 0; i < numfriends; ++i) {
-        if (friendlist[i].status == 1) {
+        if (friendlist[i].status == FRIEND_ADDED) {
             int fr = send_friendrequest(friendlist[i].client_id, friendlist[i].info, friendlist[i].info_size);
             if (fr == 0) /* TODO: This needs to be fixed so that it sends the friend requests a couple of times in case of packet loss */
-                friendlist[i].status = 2;
+                friendlist[i].status = FRIEND_REQUESTED;
             else if (fr > 0)
-                friendlist[i].status = 2;
+                friendlist[i].status = FRIEND_REQUESTED;
         }
-        if (friendlist[i].status == 2 || friendlist[i].status == 3) { /* friend is not online */
-            if (friendlist[i].status == 2) {
+        if (friendlist[i].status == FRIEND_REQUESTED || friendlist[i].status == FRIEND_CONFIRMED) { /* friend is not online */
+            if (friendlist[i].status == FRIEND_REQUESTED) {
                 if (friendlist[i].friend_request_id + 10 < unix_time()) { /*I know this is hackish but it should work.*/
                     send_friendrequest(friendlist[i].client_id, friendlist[i].info, friendlist[i].info_size);
                     friendlist[i].friend_request_id = unix_time();
@@ -405,7 +406,7 @@ static void doFriends()
                     friendlist[i].crypt_connection_id = crypto_connect(friendlist[i].client_id, friendip);
                 break;
             case 3: /*  Connection is established */
-                friendlist[i].status = 4;
+                friendlist[i].status = FRIEND_ONLINE;
                 break;
             case 4:
                 crypto_kill(friendlist[i].crypt_connection_id);
@@ -415,7 +416,7 @@ static void doFriends()
                 break;
             }
         }
-        while (friendlist[i].status == 4) { /* friend is online */
+        while (friendlist[i].status == FRIEND_ONLINE) { /* friend is online */
             if (friendlist[i].name_sent == 0) {
                 if (m_sendname(i, self_name, self_name_length))
                     friendlist[i].name_sent = 1;
@@ -455,7 +456,7 @@ static void doFriends()
                 if (is_cryptoconnected(friendlist[i].crypt_connection_id) == 4) { /* if the connection timed out, kill it */
                     crypto_kill(friendlist[i].crypt_connection_id);
                     friendlist[i].crypt_connection_id = -1;
-                    friendlist[i].status = 3;
+                    friendlist[i].status = FRIEND_CONFIRMED;
                 }
                 break;
             }
@@ -476,7 +477,7 @@ static void doInbound()
             friendlist[friend_id].crypt_connection_id =
                 accept_crypto_inbound(inconnection, public_key, secret_nonce, session_key);
 
-            friendlist[friend_id].status = 3;
+            friendlist[friend_id].status = FRIEND_CONFIRMED;
         }
     }
 }
@@ -484,7 +485,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..acf62a32 100644
--- a/core/Messenger.h
+++ b/core/Messenger.h
@@ -42,18 +42,36 @@ extern "C" {
 #define PACKET_ID_USERSTATUS 49
 #define PACKET_ID_MESSAGE 64
 
+/* status definitions */
+#define FRIEND_ONLINE 4
+#define FRIEND_CONFIRMED 3
+#define FRIEND_REQUESTED 2
+#define FRIEND_ADDED 1
+#define NOFRIEND 0
+
+/* errors for m_addfriend
+ *  FAERR - Friend Add Error */
+#define FAERR_TOOLONG -1
+#define FAERR_NOMESSAGE -2
+#define FAERR_OWNKEY -3
+#define FAERR_ALREADYSENT -4
+#define FAERR_UNKNOWN -5
+
 /* 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 34d481ca..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,7 +81,7 @@ 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) {
-            check |= temp_plain[i] ^ 0;
+            check |= temp_encrypted[i] ^ 0;
     }
     if(check != 0)
         return -1;
@@ -147,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);
@@ -173,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,
@@ -293,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;
     }
@@ -313,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);
@@ -372,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;
@@ -396,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);
@@ -411,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. */
@@ -429,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
@@ -488,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];
@@ -505,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);
@@ -525,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);
@@ -554,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;