1 files changed, 211 insertions, 109 deletions

diff --git a/core/Messenger.c b/core/Messenger.c
index 4ed8bc41..09032067 100644
--- a/core/Messenger.c
+++ b/core/Messenger.c
@@ -35,11 +35,14 @@ static int write_cryptpacket_id(Messenger *m, int friendnumber, uint8_t packet_i
 
 /* set the size of the friend list to numfriends
    return -1 if realloc fails */
-int realloc_friendlist(Messenger *m, uint32_t num) {
-    Friend *newfriendlist = realloc(m->friendlist, num*sizeof(Friend));
+int realloc_friendlist(Messenger *m, uint32_t num)
+{
+    Friend *newfriendlist = realloc(m->friendlist, num * sizeof(Friend));
+
     if (newfriendlist == NULL)
         return -1;
-    memset(&newfriendlist[num-1], 0, sizeof(Friend));
+
+    memset(&newfriendlist[num - 1], 0, sizeof(Friend));
     m->friendlist = newfriendlist;
     return 0;
 }
@@ -85,8 +88,10 @@ static uint16_t address_checksum(uint8_t *address, uint32_t len)
     uint8_t checksum[2] = {0};
     uint16_t check;
     uint32_t i;
-    for(i = 0; i < len; ++i)
+
+    for (i = 0; i < len; ++i)
         checksum[i % 2] ^= address[i];
+
     memcpy(&check, checksum, sizeof(check));
     return check;
 }
@@ -125,25 +130,33 @@ void getaddress(Messenger *m, uint8_t *address)
 int m_addfriend(Messenger *m, uint8_t *address, uint8_t *data, uint16_t length)
 {
     if (length >= (MAX_DATA_SIZE - crypto_box_PUBLICKEYBYTES
-                         - crypto_box_NONCEBYTES - crypto_box_BOXZEROBYTES
-                         + crypto_box_ZEROBYTES))
+                   - crypto_box_NONCEBYTES - crypto_box_BOXZEROBYTES
+                   + crypto_box_ZEROBYTES))
         return FAERR_TOOLONG;
+
     uint8_t client_id[crypto_box_PUBLICKEYBYTES];
     memcpy(client_id, address, crypto_box_PUBLICKEYBYTES);
     uint16_t check, checksum = address_checksum(address, FRIEND_ADDRESS_SIZE - sizeof(checksum));
     memcpy(&check, address + crypto_box_PUBLICKEYBYTES + sizeof(uint32_t), sizeof(check));
+
     if (check != checksum)
         return FAERR_BADCHECKSUM;
+
     if (length < 1)
         return FAERR_NOMESSAGE;
+
     if (memcmp(client_id, self_public_key, crypto_box_PUBLICKEYBYTES) == 0)
         return FAERR_OWNKEY;
+
     int friend_id = getfriend_id(m, client_id);
+
     if (friend_id != -1) {
         uint32_t nospam;
         memcpy(&nospam, address + crypto_box_PUBLICKEYBYTES, sizeof(nospam));
-        if(m->friendlist[friend_id].friendrequest_nospam == nospam)
+
+        if (m->friendlist[friend_id].friendrequest_nospam == nospam)
             return FAERR_ALREADYSENT;
+
         m->friendlist[friend_id].friendrequest_nospam = nospam;
         return FAERR_SETNEWNOSPAM;
     }
@@ -153,6 +166,7 @@ int m_addfriend(Messenger *m, uint8_t *address, uint8_t *data, uint16_t length)
         return FAERR_NOMEM;
 
     uint32_t i;
+
     for (i = 0; i <= m->numfriends; ++i)  {
         if (m->friendlist[i].status == NOFRIEND) {
             DHT_addfriend(client_id);
@@ -173,10 +187,11 @@ int m_addfriend(Messenger *m, uint8_t *address, uint8_t *data, uint16_t length)
             return i;
         }
     }
+
     return FAERR_UNKNOWN;
 }
 
-int m_addfriend_norequest(Messenger *m, uint8_t * client_id)
+int m_addfriend_norequest(Messenger *m, uint8_t *client_id)
 {
     if (getfriend_id(m, client_id) != -1)
         return -1;
@@ -186,8 +201,9 @@ int m_addfriend_norequest(Messenger *m, uint8_t * client_id)
         return FAERR_NOMEM;
 
     uint32_t i;
+
     for (i = 0; i <= m->numfriends; ++i) {
-        if(m->friendlist[i].status == NOFRIEND) {
+        if (m->friendlist[i].status == NOFRIEND) {
             DHT_addfriend(client_id);
             m->friendlist[i].status = FRIEND_REQUESTED;
             m->friendlist[i].crypt_connection_id = -1;
@@ -202,6 +218,7 @@ int m_addfriend_norequest(Messenger *m, uint8_t * client_id)
             return i;
         }
     }
+
     return -1;
 }
 
@@ -220,9 +237,10 @@ int m_delfriend(Messenger *m, int friendnumber)
     uint32_t i;
 
     for (i = m->numfriends; i != 0; --i) {
-        if (m->friendlist[i-1].status != NOFRIEND)
+        if (m->friendlist[i - 1].status != NOFRIEND)
             break;
     }
+
     m->numfriends = i;
 
     if (realloc_friendlist(m, m->numfriends + 1) != 0)
@@ -240,6 +258,7 @@ int m_friendstatus(Messenger *m, int friendnumber)
 {
     if (friendnumber < 0 || friendnumber >= m->numfriends)
         return NOFRIEND;
+
     return m->friendlist[friendnumber].status;
 }
 
@@ -250,10 +269,13 @@ uint32_t m_sendmessage(Messenger *m, int friendnumber, uint8_t *message, uint32_
 {
     if (friendnumber < 0 || friendnumber >= m->numfriends)
         return 0;
+
     uint32_t msgid = ++m->friendlist[friendnumber].message_id;
+
     if (msgid == 0)
         msgid = 1; /* otherwise, false error */
-    if(m_sendmessage_withid(m, friendnumber, msgid, message, length)) {
+
+    if (m_sendmessage_withid(m, friendnumber, msgid, message, length)) {
         return msgid;
     }
 
@@ -264,6 +286,7 @@ uint32_t m_sendmessage_withid(Messenger *m, int friendnumber, uint32_t theid, ui
 {
     if (length >= (MAX_DATA_SIZE - sizeof(theid)))
         return 0;
+
     uint8_t temp[MAX_DATA_SIZE];
     theid = htonl(theid);
     memcpy(temp, &theid, sizeof(theid));
@@ -281,20 +304,22 @@ int m_sendaction(Messenger *m, int friendnumber, uint8_t *action, uint32_t lengt
 
 /* send a name packet to friendnumber
    length is the length with the NULL terminator*/
-static int m_sendname(Messenger *m, int friendnumber, uint8_t * name, uint16_t length)
+static int m_sendname(Messenger *m, int friendnumber, uint8_t *name, uint16_t length)
 {
-    if(length > MAX_NAME_LENGTH || length == 0)
+    if (length > MAX_NAME_LENGTH || length == 0)
         return 0;
+
     return write_cryptpacket_id(m, friendnumber, PACKET_ID_NICKNAME, name, length);
 }
 
 /* set the name of a friend
    return 0 if success
    return -1 if failure */
-static int setfriendname(Messenger *m, int friendnumber, uint8_t * name)
+static int setfriendname(Messenger *m, int friendnumber, uint8_t *name)
 {
     if (friendnumber >= m->numfriends || friendnumber < 0)
         return -1;
+
     memcpy(m->friendlist[friendnumber].name, name, MAX_NAME_LENGTH);
     return 0;
 }
@@ -305,15 +330,18 @@ static int setfriendname(Messenger *m, int friendnumber, uint8_t * name)
    length is the length of name with the NULL terminator
    return 0 if success
    return -1 if failure */
-int setname(Messenger *m, uint8_t * name, uint16_t length)
+int setname(Messenger *m, uint8_t *name, uint16_t length)
 {
     if (length > MAX_NAME_LENGTH || length == 0)
         return -1;
+
     memcpy(m->name, name, length);
     m->name_length = length;
     uint32_t i;
+
     for (i = 0; i < m->numfriends; ++i)
         m->friendlist[i].name_sent = 0;
+
     return 0;
 }
 
@@ -340,10 +368,11 @@ uint16_t getself_name(Messenger *m, uint8_t *name, uint16_t nlen)
    name needs to be a valid memory location with a size of at least MAX_NAME_LENGTH bytes.
    return 0 if success
    return -1 if failure */
-int getname(Messenger *m, int friendnumber, uint8_t * name)
+int getname(Messenger *m, int friendnumber, uint8_t *name)
 {
     if (friendnumber >= m->numfriends || friendnumber < 0)
         return -1;
+
     memcpy(name, m->friendlist[friendnumber].name, MAX_NAME_LENGTH);
     return 0;
 }
@@ -352,12 +381,15 @@ int m_set_statusmessage(Messenger *m, uint8_t *status, uint16_t length)
 {
     if (length > MAX_STATUSMESSAGE_LENGTH)
         return -1;
+
     memcpy(m->statusmessage, status, length);
     m->statusmessage_length = length;
 
     uint32_t i;
+
     for (i = 0; i < m->numfriends; ++i)
         m->friendlist[i].statusmessage_sent = 0;
+
     return 0;
 }
 
@@ -366,10 +398,13 @@ int m_set_userstatus(Messenger *m, USERSTATUS status)
     if (status >= USERSTATUS_INVALID) {
         return -1;
     }
+
     m->userstatus = status;
     uint32_t i;
+
     for (i = 0; i < m->numfriends; ++i)
         m->friendlist[i].userstatus_sent = 0;
+
     return 0;
 }
 
@@ -379,21 +414,23 @@ int m_get_statusmessage_size(Messenger *m, int friendnumber)
 {
     if (friendnumber >= m->numfriends || friendnumber < 0)
         return -1;
+
     return m->friendlist[friendnumber].statusmessage_length;
 }
 
 /*  copy the user status of friendnumber into buf, truncating if needed to maxlen
     bytes, use m_get_statusmessage_size to find out how much you need to allocate */
-int m_copy_statusmessage(Messenger *m, int friendnumber, uint8_t * buf, uint32_t maxlen)
+int m_copy_statusmessage(Messenger *m, int friendnumber, uint8_t *buf, uint32_t maxlen)
 {
     if (friendnumber >= m->numfriends || friendnumber < 0)
         return -1;
+
     memset(buf, 0, maxlen);
     memcpy(buf, m->friendlist[friendnumber].statusmessage, MIN(maxlen, MAX_STATUSMESSAGE_LENGTH) - 1);
     return 0;
 }
 
-int m_copy_self_statusmessage(Messenger *m, uint8_t * buf, uint32_t maxlen)
+int m_copy_self_statusmessage(Messenger *m, uint8_t *buf, uint32_t maxlen)
 {
     memset(buf, 0, maxlen);
     memcpy(buf, m->statusmessage, MIN(maxlen, MAX_STATUSMESSAGE_LENGTH) - 1);
@@ -404,10 +441,13 @@ USERSTATUS m_get_userstatus(Messenger *m, int friendnumber)
 {
     if (friendnumber >= m->numfriends || friendnumber < 0)
         return USERSTATUS_INVALID;
+
     USERSTATUS status = m->friendlist[friendnumber].userstatus;
+
     if (status >= USERSTATUS_INVALID) {
         status = USERSTATUS_NONE;
     }
+
     return status;
 }
 
@@ -416,7 +456,7 @@ USERSTATUS m_get_self_userstatus(Messenger *m)
     return m->userstatus;
 }
 
-static int send_statusmessage(Messenger *m, int friendnumber, uint8_t * status, uint16_t length)
+static int send_statusmessage(Messenger *m, int friendnumber, uint8_t *status, uint16_t length)
 {
     return write_cryptpacket_id(m, friendnumber, PACKET_ID_STATUSMESSAGE, status, length);
 }
@@ -427,10 +467,11 @@ static int send_userstatus(Messenger *m, int friendnumber, USERSTATUS status)
     return write_cryptpacket_id(m, friendnumber, PACKET_ID_USERSTATUS, &stat, sizeof(stat));
 }
 
-static int set_friend_statusmessage(Messenger *m, int friendnumber, uint8_t * status, uint16_t length)
+static int set_friend_statusmessage(Messenger *m, int friendnumber, uint8_t *status, uint16_t length)
 {
     if (friendnumber >= m->numfriends || friendnumber < 0)
         return -1;
+
     uint8_t *newstatus = calloc(length, 1);
     memcpy(newstatus, status, length);
     free(m->friendlist[friendnumber].statusmessage);
@@ -449,56 +490,61 @@ void m_set_sends_receipts(Messenger *m, int friendnumber, int yesno)
 {
     if (yesno != 0 || yesno != 1)
         return;
+
     if (friendnumber >= m->numfriends || friendnumber < 0)
         return;
+
     m->friendlist[friendnumber].receives_read_receipts = yesno;
 }
 
 /* static void (*friend_request)(uint8_t *, uint8_t *, uint16_t); */
 /* set the function that will be executed when a friend request is received. */
-void m_callback_friendrequest(Messenger *m, void (*function)(uint8_t *, uint8_t *, uint16_t, void*), void* userdata)
+void m_callback_friendrequest(Messenger *m, void (*function)(uint8_t *, uint8_t *, uint16_t, void *), void *userdata)
 {
     callback_friendrequest(function, userdata);
 }
 
 /* set the function that will be executed when a message from a friend is received. */
-void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, int, uint8_t *, uint16_t, void*), void* userdata)
+void m_callback_friendmessage(Messenger *m, void (*function)(Messenger *m, int, uint8_t *, uint16_t, void *),
+                              void *userdata)
 {
     m->friend_message = function;
     m->friend_message_userdata = userdata;
 }
 
-void m_callback_action(Messenger *m, void (*function)(Messenger *m, int, uint8_t *, uint16_t, void*), void* userdata)
+void m_callback_action(Messenger *m, void (*function)(Messenger *m, int, uint8_t *, uint16_t, void *), void *userdata)
 {
     m->friend_action = function;
     m->friend_action_userdata = userdata;
 }
 
-void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, int, uint8_t *, uint16_t, void*), void* userdata)
+void m_callback_namechange(Messenger *m, void (*function)(Messenger *m, int, uint8_t *, uint16_t, void *),
+                           void *userdata)
 {
     m->friend_namechange = function;
     m->friend_namechange_userdata = userdata;
 }
 
-void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, int, uint8_t *, uint16_t, void*), void* userdata)
+void m_callback_statusmessage(Messenger *m, void (*function)(Messenger *m, int, uint8_t *, uint16_t, void *),
+                              void *userdata)
 {
     m->friend_statusmessagechange = function;
     m->friend_statuschange_userdata = userdata;
 }
 
-void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, int, USERSTATUS, void*), void* userdata)
+void m_callback_userstatus(Messenger *m, void (*function)(Messenger *m, int, USERSTATUS, void *), void *userdata)
 {
     m->friend_userstatuschange = function;
     m->friend_userstatuschange_userdata = userdata;
 }
 
-void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, int, uint32_t, void*), void* userdata)
+void m_callback_read_receipt(Messenger *m, void (*function)(Messenger *m, int, uint32_t, void *), void *userdata)
 {
     m->read_receipt = function;
     m->read_receipt_userdata = userdata;
 }
 
-void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, int, uint8_t, void*), void* userdata)
+void m_callback_connectionstatus(Messenger *m, void (*function)(Messenger *m, int, uint8_t, void *), void *userdata)
 {
     m->friend_connectionstatuschange = function;
     m->friend_connectionstatuschange_userdata = userdata;
@@ -508,10 +554,13 @@ static void check_friend_connectionstatus(Messenger *m, int friendnumber, uint8_
 {
     if (!m->friend_connectionstatuschange)
         return;
+
     if (status == NOFRIEND)
         return;
+
     const uint8_t was_connected = m->friendlist[friendnumber].status == FRIEND_ONLINE;
     const uint8_t is_connected = status == FRIEND_ONLINE;
+
     if (is_connected != was_connected)
         m->friend_connectionstatuschange(m, friendnumber, is_connected, m->friend_connectionstatuschange_userdata);
 }
@@ -526,8 +575,10 @@ int write_cryptpacket_id(Messenger *m, int friendnumber, uint8_t packet_id, uint
 {
     if (friendnumber < 0 || friendnumber >= m->numfriends)
         return 0;
+
     if (length >= MAX_DATA_SIZE || m->friendlist[friendnumber].status != FRIEND_ONLINE)
         return 0;
+
     uint8_t packet[length + 1];
     packet[0] = packet_id;
     memcpy(packet + 1, data, length);
@@ -541,7 +592,7 @@ int write_cryptpacket_id(Messenger *m, int friendnumber, uint8_t packet_id, uint
 #define PORT 33445
 
 /*Send a LAN discovery packet every LAN_DISCOVERY_INTERVAL seconds*/
-int LANdiscovery(timer* t, void* arg)
+int LANdiscovery(timer *t, void *arg)
 {
     send_LANdiscovery(htons(PORT));
     timer_start(t, LAN_DISCOVERY_INTERVAL);
@@ -549,19 +600,20 @@ int LANdiscovery(timer* t, void* arg)
 }
 
 /* run this at startup */
-Messenger * initMessenger(void)
+Messenger *initMessenger(void)
 {
     Messenger *m = calloc(1, sizeof(Messenger));
-    if( ! m )
+
+    if ( ! m )
         return 0;
 
     new_keys();
-    m_set_statusmessage(m, (uint8_t*)"Online", sizeof("Online"));
+    m_set_statusmessage(m, (uint8_t *)"Online", sizeof("Online"));
     initNetCrypto();
     IP ip;
     ip.i = 0;
 
-    if(init_networking(ip,PORT) == -1)
+    if (init_networking(ip, PORT) == -1)
         return 0;
 
     DHT_init();
@@ -576,7 +628,8 @@ Messenger * initMessenger(void)
 }
 
 /* run this before closing shop */
-void cleanupMessenger(Messenger *m){
+void cleanupMessenger(Messenger *m)
+{
     /* FIXME TODO ideally cleanupMessenger will mirror initMessenger
      * this requires the other modules to expose cleanup functions
      */
@@ -591,117 +644,155 @@ void doFriends(Messenger *m)
     uint32_t i;
     int len;
     uint8_t temp[MAX_DATA_SIZE];
+
     for (i = 0; i < m->numfriends; ++i) {
         if (m->friendlist[i].status == FRIEND_ADDED) {
-            int fr = send_friendrequest(m->friendlist[i].client_id, m->friendlist[i].friendrequest_nospam, m->friendlist[i].info, m->friendlist[i].info_size);
+            int fr = send_friendrequest(m->friendlist[i].client_id, m->friendlist[i].friendrequest_nospam, m->friendlist[i].info,
+                                        m->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 */
                 set_friend_status(m, i, FRIEND_REQUESTED);
             else if (fr > 0)
                 set_friend_status(m, i, FRIEND_REQUESTED);
         }
-        if (m->friendlist[i].status == FRIEND_REQUESTED || m->friendlist[i].status == FRIEND_CONFIRMED) { /* friend is not online */
+
+        if (m->friendlist[i].status == FRIEND_REQUESTED
+                || m->friendlist[i].status == FRIEND_CONFIRMED) { /* friend is not online */
             if (m->friendlist[i].status == FRIEND_REQUESTED) {
                 if (m->friendlist[i].friend_request_id + 10 < unix_time()) { /*I know this is hackish but it should work.*/
-                    send_friendrequest(m->friendlist[i].client_id, m->friendlist[i].friendrequest_nospam, m->friendlist[i].info, m->friendlist[i].info_size);
+                    send_friendrequest(m->friendlist[i].client_id, m->friendlist[i].friendrequest_nospam, m->friendlist[i].info,
+                                       m->friendlist[i].info_size);
                     m->friendlist[i].friend_request_id = unix_time();
                 }
             }
+
             IP_Port friendip = DHT_getfriendip(m->friendlist[i].client_id);
+
             switch (is_cryptoconnected(m->friendlist[i].crypt_connection_id)) {
-            case 0:
-                if (friendip.ip.i > 1)
-                    m->friendlist[i].crypt_connection_id = crypto_connect(m->friendlist[i].client_id, friendip);
-                break;
-            case 3: /*  Connection is established */
-                set_friend_status(m, i, FRIEND_ONLINE);
-                m->friendlist[i].name_sent = 0;
-                m->friendlist[i].userstatus_sent = 0;
-                m->friendlist[i].statusmessage_sent = 0;
-                break;
-            case 4:
-                crypto_kill(m->friendlist[i].crypt_connection_id);
-                m->friendlist[i].crypt_connection_id = -1;
-                break;
-            default:
-                break;
+                case 0:
+                    if (friendip.ip.i > 1)
+                        m->friendlist[i].crypt_connection_id = crypto_connect(m->friendlist[i].client_id, friendip);
+
+                    break;
+
+                case 3: /*  Connection is established */
+                    set_friend_status(m, i, FRIEND_ONLINE);
+                    m->friendlist[i].name_sent = 0;
+                    m->friendlist[i].userstatus_sent = 0;
+                    m->friendlist[i].statusmessage_sent = 0;
+                    break;
+
+                case 4:
+                    crypto_kill(m->friendlist[i].crypt_connection_id);
+                    m->friendlist[i].crypt_connection_id = -1;
+                    break;
+
+                default:
+                    break;
             }
         }
+
         while (m->friendlist[i].status == FRIEND_ONLINE) { /* friend is online */
             if (m->friendlist[i].name_sent == 0) {
                 if (m_sendname(m, i, m->name, m->name_length))
                     m->friendlist[i].name_sent = 1;
             }
+
             if (m->friendlist[i].statusmessage_sent == 0) {
                 if (send_statusmessage(m, i, m->statusmessage, m->statusmessage_length))
                     m->friendlist[i].statusmessage_sent = 1;
             }
+
             if (m->friendlist[i].userstatus_sent == 0) {
                 if (send_userstatus(m, i, m->userstatus))
                     m->friendlist[i].userstatus_sent = 1;
             }
+
             len = read_cryptpacket(m->friendlist[i].crypt_connection_id, temp);
             uint8_t packet_id = temp[0];
-            uint8_t* data = temp + 1;
+            uint8_t *data = temp + 1;
             int data_length = len - 1;
+
             if (len > 0) {
                 switch (packet_id) {
-                case PACKET_ID_NICKNAME: {
-                    if (data_length >= MAX_NAME_LENGTH || data_length == 0)
+                    case PACKET_ID_NICKNAME: {
+                        if (data_length >= MAX_NAME_LENGTH || data_length == 0)
+                            break;
+
+                        if (m->friend_namechange)
+                            m->friend_namechange(m, i, data, data_length, m->friend_namechange_userdata);
+
+                        memcpy(m->friendlist[i].name, data, data_length);
+                        m->friendlist[i].name[data_length - 1] = 0; /* make sure the NULL terminator is present. */
                         break;
-                    if(m->friend_namechange)
-                        m->friend_namechange(m, i, data, data_length, m->friend_namechange_userdata);
-                    memcpy(m->friendlist[i].name, data, data_length);
-                    m->friendlist[i].name[data_length - 1] = 0; /* make sure the NULL terminator is present. */
-                    break;
-                }
-                case PACKET_ID_STATUSMESSAGE: {
-                    if (data_length == 0)
+                    }
+
+                    case PACKET_ID_STATUSMESSAGE: {
+                        if (data_length == 0)
+                            break;
+
+                        uint8_t *status = calloc(MIN(data_length, MAX_STATUSMESSAGE_LENGTH), 1);
+                        memcpy(status, data, MIN(data_length, MAX_STATUSMESSAGE_LENGTH));
+
+                        if (m->friend_statusmessagechange)
+                            m->friend_statusmessagechange(m, i, status, MIN(data_length, MAX_STATUSMESSAGE_LENGTH),
+                                                          m->friend_statuschange_userdata);
+
+                        set_friend_statusmessage(m, i, status, MIN(data_length, MAX_STATUSMESSAGE_LENGTH));
+                        free(status);
                         break;
-                    uint8_t *status = calloc(MIN(data_length, MAX_STATUSMESSAGE_LENGTH), 1);
-                    memcpy(status, data, MIN(data_length, MAX_STATUSMESSAGE_LENGTH));
-                    if (m->friend_statusmessagechange)
-                        m->friend_statusmessagechange(m, i, status, MIN(data_length, MAX_STATUSMESSAGE_LENGTH),
-                                                      m->friend_statuschange_userdata);
-                    set_friend_statusmessage(m, i, status, MIN(data_length, MAX_STATUSMESSAGE_LENGTH));
-                    free(status);
-                    break;
-                }
-                case PACKET_ID_USERSTATUS: {
-                    if (data_length != 1)
+                    }
+
+                    case PACKET_ID_USERSTATUS: {
+                        if (data_length != 1)
+                            break;
+
+                        USERSTATUS status = data[0];
+
+                        if (m->friend_userstatuschange)
+                            m->friend_userstatuschange(m, i, status, m->friend_userstatuschange_userdata);
+
+                        set_friend_userstatus(m, i, status);
                         break;
-                    USERSTATUS status = data[0];
-                    if (m->friend_userstatuschange)
-                        m->friend_userstatuschange(m, i, status, m->friend_userstatuschange_userdata);
-                    set_friend_userstatus(m, i, status);
-                    break;
-                }
-                case PACKET_ID_MESSAGE: {
-                    uint8_t *message_id = data;
-                    uint8_t message_id_length = 4;
-                    uint8_t *message = data + message_id_length;
-                    uint16_t message_length = data_length - message_id_length;
-                    if (m->friendlist[i].receives_read_receipts) {
-                        write_cryptpacket_id(m, i, PACKET_ID_RECEIPT, message_id, message_id_length);
                     }
-                    if (m->friend_message)
-                        (*m->friend_message)(m, i, message, message_length, m->friend_message_userdata);
-                    break;
-                }
-                case PACKET_ID_ACTION: {
-                    if (m->friend_action)
-                        (*m->friend_action)(m, i, data, data_length, m->friend_action_userdata);
-                    break;
-                }
-                case PACKET_ID_RECEIPT: {
-                    uint32_t msgid;
-                    if (data_length < sizeof(msgid))
+
+                    case PACKET_ID_MESSAGE: {
+                        uint8_t *message_id = data;
+                        uint8_t message_id_length = 4;
+                        uint8_t *message = data + message_id_length;
+                        uint16_t message_length = data_length - message_id_length;
+
+                        if (m->friendlist[i].receives_read_receipts) {
+                            write_cryptpacket_id(m, i, PACKET_ID_RECEIPT, message_id, message_id_length);
+                        }
+
+                        if (m->friend_message)
+                            (*m->friend_message)(m, i, message, message_length, m->friend_message_userdata);
+
                         break;
-                    memcpy(&msgid, data, sizeof(msgid));
-                    msgid = ntohl(msgid);
-                    if (m->read_receipt)
-                        (*m->read_receipt)(m, i, msgid, m->read_receipt_userdata);
-                    break;
-                }
+                    }
+
+                    case PACKET_ID_ACTION: {
+                        if (m->friend_action)
+                            (*m->friend_action)(m, i, data, data_length, m->friend_action_userdata);
+
+                        break;
+                    }
+
+                    case PACKET_ID_RECEIPT: {
+                        uint32_t msgid;
+
+                        if (data_length < sizeof(msgid))
+                            break;
+
+                        memcpy(&msgid, data, sizeof(msgid));
+                        msgid = ntohl(msgid);
+
+                        if (m->read_receipt)
+                            (*m->read_receipt)(m, i, msgid, m->read_receipt_userdata);
+
+                        break;
+                    }
                 }
             } else {
                 if (is_cryptoconnected(m->friendlist[i].crypt_connection_id) == 4) { /* if the connection timed out, kill it */
@@ -709,6 +800,7 @@ void doFriends(Messenger *m)
                     m->friendlist[i].crypt_connection_id = -1;
                     set_friend_status(m, i, FRIEND_CONFIRMED);
                 }
+
                 break;
             }
         }
@@ -721,8 +813,10 @@ void doInbound(Messenger *m)
     uint8_t public_key[crypto_box_PUBLICKEYBYTES];
     uint8_t session_key[crypto_box_PUBLICKEYBYTES];
     int inconnection = crypto_inbound(public_key, secret_nonce, session_key);
+
     if (inconnection != -1) {
         int friend_id = getfriend_id(m, public_key);
+
         if (friend_id != -1) {
             crypto_kill(m->friendlist[friend_id].crypt_connection_id);
             m->friendlist[friend_id].crypt_connection_id =
@@ -775,12 +869,14 @@ void Messenger_save(Messenger *m, uint8_t *data)
 }
 
 /* load the messenger from data of size length. */
-int Messenger_load(Messenger *m, uint8_t * data, uint32_t length)
+int Messenger_load(Messenger *m, uint8_t *data, uint32_t length)
 {
     if (length == ~0)
         return -1;
+
     if (length < crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES + sizeof(uint32_t) * 3)
         return -1;
+
     length -= crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES + sizeof(uint32_t) * 3;
     load_keys(data);
     data += crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES;
@@ -794,23 +890,28 @@ int Messenger_load(Messenger *m, uint8_t * data, uint32_t length)
 
     if (length < size)
         return -1;
+
     length -= size;
+
     if (DHT_load(data, size) == -1)
         return -1;
+
     data += size;
     memcpy(&size, data, sizeof(size));
     data += sizeof(size);
+
     if (length != size || length % sizeof(Friend) != 0)
         return -1;
 
-    Friend * temp = malloc(size);
+    Friend *temp = malloc(size);
     memcpy(temp, data, size);
 
     uint16_t num = size / sizeof(Friend);
 
     uint32_t i;
+
     for (i = 0; i < num; ++i) {
-        if(temp[i].status >= 3) {
+        if (temp[i].status >= 3) {
             int fnum = m_addfriend_norequest(m, temp[i].client_id);
             setfriendname(m, fnum, temp[i].name);
             /* set_friend_statusmessage(fnum, temp[i].statusmessage, temp[i].statusmessage_length); */
@@ -824,6 +925,7 @@ int Messenger_load(Messenger *m, uint8_t * data, uint32_t length)
             m_addfriend(m, address, temp[i].info, temp[i].info_size);
         }
     }
+
     free(temp);
     return 0;
 }