Merge branch 'master' into harden

1 files changed, 270 insertions, 69 deletions

diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 08e3c70c..32234784 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -26,9 +26,11 @@
 #endif
 
 #include "Messenger.h"
+#include "assoc.h"
 #include "network.h"
 #include "util.h"
 
+
 #define MIN(a,b) (((a)<(b))?(a):(b))
 
 
@@ -435,6 +437,10 @@ int setname(Messenger *m, uint8_t *name, uint16_t length)
     for (i = 0; i < m->numfriends; ++i)
         m->friendlist[i].name_sent = 0;
 
+    for (i = 0; i < m->numchats; i++)
+        if (m->chats[i] != NULL)
+            set_nick(m->chats[i], name, length); /* TODO: remove this (group nicks should not be tied to the global one) */
+
     return 0;
 }
 
@@ -701,6 +707,23 @@ int write_cryptpacket_id(Messenger *m, int friendnumber, uint8_t packet_id, uint
 
 /**********GROUP CHATS************/
 
+/* return 1 if the groupnumber is not valid.
+ * return 0 if the groupnumber is valid.
+ */
+static uint8_t groupnumber_not_valid(Messenger *m, int groupnumber)
+{
+    if ((unsigned int)groupnumber >= m->numchats)
+        return 1;
+
+    if (m->chats == NULL)
+        return 1;
+
+    if (m->chats[groupnumber] == NULL)
+        return 1;
+    return 0;
+}
+
+
 /* returns valid ip port of connected friend on success
  * returns zeroed out IP_Port on failure
  */
@@ -728,8 +751,9 @@ static int group_num(Messenger *m, uint8_t *group_public_key)
     uint32_t i;
 
     for (i = 0; i < m->numchats; ++i) {
-        if (id_equal(m->chats[i]->self_public_key, group_public_key))
-            return i;
+        if (m->chats[i] != NULL)
+            if (id_equal(m->chats[i]->self_public_key, group_public_key))
+                return i;
     }
 
     return -1;
@@ -755,20 +779,51 @@ void m_callback_group_message(Messenger *m, void (*function)(Messenger *m, int,
     m->group_message = function;
     m->group_message_userdata = userdata;
 }
-static void group_message_function(Group_Chat *chat, int peer_number, uint8_t *message, uint16_t length, void *userdata)
+
+/* Set callback function for peer name list changes.
+ *
+ * It gets called every time the name list changes(new peer/name, deleted peer)
+ *  Function(Tox *tox, int groupnumber, void *userdata)
+ */
+void m_callback_group_namelistchange(Messenger *m, void (*function)(Messenger *m, int, int, uint8_t, void *), void *userdata)
 {
-    Messenger *m = userdata;
-    uint32_t i;
+    m->group_namelistchange = function;
+    m->group_namelistchange_userdata = userdata;
+}
 
+static int get_chat_num(Messenger *m, Group_Chat *chat)
+{
+    uint32_t i;
     for (i = 0; i < m->numchats; ++i) { //TODO: remove this
         if (m->chats[i] == chat)
-            break;
+            return i;
     }
+    return -1;
+}
+
+static void group_message_function(Group_Chat *chat, int peer_number, uint8_t *message, uint16_t length, void *userdata)
+{
+    Messenger *m = userdata;
+    int i = get_chat_num(m, chat);
+    if (i == -1)
+        return;
 
     if (m->group_message)
         (*m->group_message)(m, i, peer_number, message, length, m->group_message_userdata);
 }
 
+static void group_namelistchange_function(Group_Chat *chat, int peer, uint8_t change, void *userdata)
+{
+    Messenger *m = userdata;
+    int i = get_chat_num(m, chat);
+    if (i == -1)
+        return;
+
+    if (m->group_namelistchange)
+        (*m->group_namelistchange)(m, i, peer, change, m->group_namelistchange_userdata);
+}
+
+
 /* Creates a new groupchat and puts it in the chats array.
  *
  * return group number on success.
@@ -786,6 +841,9 @@ int add_groupchat(Messenger *m)
                 return -1;
 
             callback_groupmessage(newchat, &group_message_function, m);
+            callback_namelistchange(newchat, &group_namelistchange_function, m);
+            /* TODO: remove this (group nicks should not be tied to the global one) */
+            set_nick(newchat, m->name, m->name_length);
             m->chats[i] = newchat;
             return i;
         }
@@ -804,6 +862,9 @@ int add_groupchat(Messenger *m)
 
     m->chats = temp;
     callback_groupmessage(temp[m->numchats], &group_message_function, m);
+    callback_namelistchange(temp[m->numchats], &group_namelistchange_function, m);
+    /* TODO: remove this (group nicks should not be tied to the global one) */
+    set_nick(temp[m->numchats], m->name, m->name_length);
     ++m->numchats;
     return (m->numchats - 1);
 }
@@ -953,6 +1014,7 @@ int join_groupchat(Messenger *m, int friendnumber, uint8_t *friend_group_public_
     return -1;
 }
 
+
 /* send a group message
  * return 0 on success
  * return -1 on failure
@@ -960,13 +1022,7 @@ int join_groupchat(Messenger *m, int friendnumber, uint8_t *friend_group_public_
 
 int group_message_send(Messenger *m, int groupnumber, uint8_t *message, uint32_t length)
 {
-    if ((unsigned int)groupnumber >= m->numchats)
-        return -1;
-
-    if (m->chats == NULL)
-        return -1;
-
-    if (m->chats[groupnumber] == NULL)
+    if (groupnumber_not_valid(m, groupnumber))
         return -1;
 
     if (group_sendmessage(m->chats[groupnumber], message, length) > 0)
@@ -975,6 +1031,33 @@ int group_message_send(Messenger *m, int groupnumber, uint8_t *message, uint32_t
     return -1;
 }
 
+/* Return the number of peers in the group chat on success.
+ * return -1 on failure
+ */
+int group_number_peers(Messenger *m, int groupnumber)
+{
+    if (groupnumber_not_valid(m, groupnumber))
+        return -1;
+
+    return group_numpeers(m->chats[groupnumber]);
+}
+
+/* List all the peers in the group chat.
+ *
+ * Copies the names of the peers to the name[length][MAX_NICK_BYTES] array.
+ *
+ * returns the number of peers on success.
+ *
+ * return -1 on failure.
+ */
+int group_names(Messenger *m, int groupnumber, uint8_t names[][MAX_NICK_BYTES], uint16_t length)
+{
+    if (groupnumber_not_valid(m, groupnumber))
+        return -1;
+
+    return group_client_names(m->chats[groupnumber], names, length);
+}
+
 static int handle_group(void *object, IP_Port source, uint8_t *packet, uint32_t length)
 {
     Messenger *m = object;
@@ -1078,7 +1161,7 @@ int file_sendrequest(Messenger *m, int friendnumber, uint8_t filenumber, uint64_
 int new_filesender(Messenger *m, int friendnumber, uint64_t filesize, uint8_t *filename, uint16_t filename_length)
 {
     if (friend_not_valid(m, friendnumber))
-        return 0;
+        return -1;
 
     uint32_t i;
 
@@ -1102,28 +1185,28 @@ int new_filesender(Messenger *m, int friendnumber, uint64_t filesize, uint8_t *f
 /* Send a file control request.
  * send_receive is 0 if we want the control packet to target a sending file, 1 if it targets a receiving file.
  *
- *  return 1 on success
- *  return 0 on failure
+ *  return 0 on success
+ *  return -1 on failure
  */
 int file_control(Messenger *m, int friendnumber, uint8_t send_receive, uint8_t filenumber, uint8_t message_id,
                  uint8_t *data, uint16_t length)
 {
     if (length > MAX_DATA_SIZE - 3)
-        return 0;
+        return -1;
 
     if (friend_not_valid(m, friendnumber))
-        return 0;
+        return -1;
 
     if (send_receive == 1) {
         if (m->friendlist[friendnumber].file_receiving[filenumber].status == FILESTATUS_NONE)
-            return 0;
+            return -1;
     } else {
         if (m->friendlist[friendnumber].file_sending[filenumber].status == FILESTATUS_NONE)
-            return 0;
+            return -1;
     }
 
     if (send_receive > 1)
-        return 0;
+        return -1;
 
     uint8_t packet[MAX_DATA_SIZE];
     packet[0] = send_receive;
@@ -1133,7 +1216,7 @@ int file_control(Messenger *m, int friendnumber, uint8_t send_receive, uint8_t f
 
     if (message_id ==  FILECONTROL_RESUME_BROKEN) {
         if (length != sizeof(uint64_t))
-            return 0;
+            return -1;
 
         uint8_t remaining[sizeof(uint64_t)];
         memcpy(remaining, data, sizeof(uint64_t));
@@ -1181,32 +1264,32 @@ int file_control(Messenger *m, int friendnumber, uint8_t send_receive, uint8_t f
                     break;
             }
 
-        return 1;
-    } else {
         return 0;
+    } else {
+        return -1;
     }
 }
 
 #define MIN_SLOTS_FREE 4
 /* Send file data.
  *
- *  return 1 on success
- *  return 0 on failure
+ *  return 0 on success
+ *  return -1 on failure
  */
 int file_data(Messenger *m, int friendnumber, uint8_t filenumber, uint8_t *data, uint16_t length)
 {
     if (length > MAX_DATA_SIZE - 1)
-        return 0;
+        return -1;
 
     if (friend_not_valid(m, friendnumber))
-        return 0;
+        return -1;
 
     if (m->friendlist[friendnumber].file_sending[filenumber].status != FILESTATUS_TRANSFERRING)
-        return 0;
+        return -1;
 
     /* Prevent file sending from filling up the entire buffer preventing messages from being sent. */
     if (crypto_num_free_sendqueue_slots(m->net_crypto, m->friendlist[friendnumber].crypt_connection_id) < MIN_SLOTS_FREE)
-        return 0;
+        return -1;
 
     uint8_t packet[MAX_DATA_SIZE];
     packet[0] = filenumber;
@@ -1214,10 +1297,10 @@ int file_data(Messenger *m, int friendnumber, uint8_t filenumber, uint8_t *data,
 
     if (write_cryptpacket_id(m, friendnumber, PACKET_ID_FILE_DATA, packet, length + 1)) {
         m->friendlist[friendnumber].file_sending[filenumber].transferred += length;
-        return 1;
+        return 0;
     }
 
-    return 0;
+    return -1;
 
 }
 
@@ -1371,6 +1454,17 @@ int m_msi_packet(Messenger *m, int friendnumber, uint8_t *data, uint16_t length)
     return write_cryptpacket_id(m, friendnumber, PACKET_ID_MSI, data, length);
 }
 
+/* Function to filter out some friend requests*/
+static int friend_already_added(uint8_t *client_id, void *data)
+{
+    Messenger *m = data;
+
+    if (getfriend_id(m, client_id) == -1)
+        return 0;
+
+    return -1;
+}
+
 /* Send a LAN discovery packet every LAN_DISCOVERY_INTERVAL seconds. */
 static void LANdiscovery(Messenger *m)
 {
@@ -1420,6 +1514,8 @@ Messenger *new_messenger(uint8_t ipv6enabled)
     friendreq_init(&(m->fr), m->net_crypto);
     LANdiscovery_init(m->dht);
     set_nospam(&(m->fr), random_int());
+    set_filter_function(&(m->fr), &friend_already_added, m);
+
     networking_registerhandler(m->net, NET_PACKET_GROUP_CHATS, &handle_group, m);
 
     return m;
@@ -1431,6 +1527,10 @@ void kill_messenger(Messenger *m)
     /* FIXME TODO: ideally cleanupMessenger will mirror initMessenger.
      * This requires the other modules to expose cleanup functions.
      */
+    uint32_t i, numchats = m->numchats;
+    for (i = 0; i < numchats; ++i)
+        del_groupchat(m, i);
+
     kill_DHT(m->dht);
     kill_net_crypto(m->net_crypto);
     kill_networking(m->net);
@@ -1438,6 +1538,24 @@ void kill_messenger(Messenger *m)
     free(m);
 }
 
+/* Check for and handle a timed-out friend request. If the request has
+ * timed-out then the friend status is set back to FRIEND_ADDED.
+ *   i: friendlist index of the timed-out friend
+ *   t: time
+ */
+static void check_friend_request_timed_out(Messenger *m, uint32_t i, uint64_t t)
+{
+    Friend *f = &m->friendlist[i];
+
+    if (f->friendrequest_lastsent + f->friendrequest_timeout < t) {
+        set_friend_status(m, i, FRIEND_ADDED);
+        /* Double the default timeout everytime if friendrequest is assumed
+         * to have been sent unsuccessfully.
+         */
+        f->friendrequest_timeout *= 2;
+    }
+}
+
 /* TODO: Make this function not suck. */
 void do_friends(Messenger *m)
 {
@@ -1465,13 +1583,7 @@ void do_friends(Messenger *m)
                 /* If we didn't connect to friend after successfully sending him a friend request the request is deemed
                  * unsuccessful so we set the status back to FRIEND_ADDED and try again.
                  */
-                if (m->friendlist[i].friendrequest_lastsent + m->friendlist[i].friendrequest_timeout < temp_time) {
-                    set_friend_status(m, i, FRIEND_ADDED);
-                    /* Double the default timeout everytime if friendrequest is assumed to have been
-                     * sent unsuccessfully.
-                     */
-                    m->friendlist[i].friendrequest_timeout *= 2;
-                }
+                check_friend_request_timed_out(m, i, temp_time);
             }
 
             IP_Port friendip;
@@ -1539,12 +1651,15 @@ void do_friends(Messenger *m)
                         if (data_length >= MAX_NAME_LENGTH || data_length == 0)
                             break;
 
-                        memcpy(m->friendlist[i].name, data, data_length);
-                        m->friendlist[i].name_length = data_length;
-                        m->friendlist[i].name[data_length - 1] = 0; /* Make sure the NULL terminator is present. */
+                        /* Make sure the NULL terminator is present. */
+                        data[data_length - 1] = 0;
 
+                        /* inform of namechange before we overwrite the old name */
                         if (m->friend_namechange)
-                            m->friend_namechange(m, i, m->friendlist[i].name, data_length, m->friend_namechange_userdata);
+                            m->friend_namechange(m, i, data, data_length, m->friend_namechange_userdata);
+
+                        memcpy(m->friendlist[i].name, data, data_length);
+                        m->friendlist[i].name_length = data_length;
 
                         break;
                     }
@@ -1658,7 +1773,7 @@ void do_friends(Messenger *m)
                             break;
 
                         group_newpeer(m->chats[groupnum], data + crypto_box_PUBLICKEYBYTES);
-
+                        chat_bootstrap(m->chats[groupnum], get_friend_ipport(m, i), data + crypto_box_PUBLICKEYBYTES);
                         break;
                     }
 
@@ -1808,6 +1923,18 @@ void do_messenger(Messenger *m)
 
     if (unix_time() > lastdump + DUMPING_CLIENTS_FRIENDS_EVERY_N_SECONDS) {
         loglog(" = = = = = = = = \n");
+        Assoc_status(m->dht->assoc);
+
+        if (m->numchats > 0) {
+            size_t c;
+
+            for (c = 0; c < m->numchats; c++) {
+                loglog("---------------- \n");
+                Assoc_status(m->chats[c]->assoc);
+            }
+        }
+
+        loglog(" = = = = = = = = \n");
 
         lastdump = unix_time();
         uint32_t client, last_pinged;
@@ -1833,7 +1960,30 @@ void do_messenger(Messenger *m)
 
         loglog(" = = = = = = = = \n");
 
-        uint32_t num_friends = MIN(m->numfriends, m->dht->num_friends);
+        uint32_t friend, dhtfriend;
+
+        /* dht contains additional "friends" (requests) */
+        uint32_t num_dhtfriends = m->dht->num_friends;
+        int32_t m2dht[num_dhtfriends];
+        int32_t dht2m[num_dhtfriends];
+
+        for (friend = 0; friend < num_dhtfriends; friend++) {
+            m2dht[friend] = -1;
+            dht2m[friend] = -1;
+
+            if (friend >= m->numfriends)
+                continue;
+
+            for (dhtfriend = 0; dhtfriend < m->dht->num_friends; dhtfriend++)
+                if (id_equal(m->friendlist[friend].client_id, m->dht->friends_list[dhtfriend].client_id)) {
+                    m2dht[friend] = dhtfriend;
+                    break;
+                }
+        }
+
+        for (friend = 0; friend < num_dhtfriends; friend++)
+            if (m2dht[friend] >= 0)
+                dht2m[m2dht[friend]] = friend;
 
         if (m->numfriends != m->dht->num_friends) {
             sprintf(logbuffer, "Friend num in DHT %u != friend num in msger %u\n",
@@ -1841,33 +1991,33 @@ void do_messenger(Messenger *m)
             loglog(logbuffer);
         }
 
-        uint32_t friend, ping_lastrecv;
-
-        for (friend = 0; friend < num_friends; friend++) {
-            Friend *msgfptr = &m->friendlist[friend];
-            DHT_Friend *dhtfptr = &m->dht->friends_list[friend];
+        uint32_t ping_lastrecv;
+        Friend *msgfptr;
+        DHT_Friend *dhtfptr;
 
-            if (memcmp(msgfptr->client_id, dhtfptr->client_id, CLIENT_ID_SIZE)) {
-                if (sizeof(logbuffer) > 2 * CLIENT_ID_SIZE + 64) {
-                    sprintf(logbuffer, "F[%2u] ID(m) %s != ID(d) ", friend,
-                            ID2String(msgfptr->client_id));
-                    strcat(logbuffer + strlen(logbuffer), ID2String(dhtfptr->client_id));
-                    strcat(logbuffer + strlen(logbuffer), "\n");
-                } else
-                    sprintf(logbuffer, "F[%2u] ID(m) != ID(d) ", friend);
+        for (friend = 0; friend < num_dhtfriends; friend++) {
+            if (dht2m[friend] >= 0)
+                msgfptr = &m->friendlist[dht2m[friend]];
+            else
+                msgfptr = NULL;
 
-                loglog(logbuffer);
-            }
+            dhtfptr = &m->dht->friends_list[friend];
 
-            ping_lastrecv = lastdump - msgfptr->ping_lastrecv;
+            if (msgfptr) {
+                ping_lastrecv = lastdump - msgfptr->ping_lastrecv;
 
-            if (ping_lastrecv > 999)
-                ping_lastrecv = 999;
+                if (ping_lastrecv > 999)
+                    ping_lastrecv = 999;
 
-            snprintf(logbuffer, sizeof(logbuffer), "F[%2u] <%s> %02u [%03u] %s\n",
-                     friend, msgfptr->name, msgfptr->crypt_connection_id,
-                     ping_lastrecv, ID2String(msgfptr->client_id));
-            loglog(logbuffer);
+                snprintf(logbuffer, sizeof(logbuffer), "F[%2u:%2u] <%s> %02i [%03u] %s\n",
+                         dht2m[friend], friend, msgfptr->name, msgfptr->crypt_connection_id,
+                         ping_lastrecv, ID2String(msgfptr->client_id));
+                loglog(logbuffer);
+            } else {
+                snprintf(logbuffer, sizeof(logbuffer), "F[--:%2u] %s\n",
+                         friend, ID2String(dhtfptr->client_id));
+                loglog(logbuffer);
+            }
 
             for (client = 0; client < MAX_FRIEND_CLIENTS; client++) {
                 Client_data *cptr = &dhtfptr->client_list[client];
@@ -1995,6 +2145,9 @@ static int messenger_load_state_callback(void *outer, uint8_t *data, uint32_t le
             if (length == crypto_box_PUBLICKEYBYTES + crypto_box_SECRETKEYBYTES + sizeof(uint32_t)) {
                 set_nospam(&(m->fr), *(uint32_t *)data);
                 load_keys(m->net_crypto, &data[sizeof(uint32_t)]);
+
+                if (m->dht->assoc)
+                    Assoc_self_client_id_changed(m->dht->assoc, m->net_crypto->self_public_key);
             } else
                 return -1;    /* critical */
 
@@ -2100,12 +2253,12 @@ uint32_t copy_friendlist(Messenger *m, int *out_list, uint32_t list_size)
     uint32_t ret = 0;
 
     for (i = 0; i < m->numfriends; i++) {
-        if (i >= list_size) {
+        if (ret >= list_size) {
             break; /* Abandon ship */
         }
 
         if (m->friendlist[i].status > 0) {
-            out_list[i] = i;
+            out_list[ret] = i;
             ret++;
         }
     }
@@ -2146,3 +2299,51 @@ int get_friendlist(Messenger *m, int **out_list, uint32_t *out_list_length)
     return 0;
 }
 
+/* Return the number of chats in the instance m.
+ * You should use this to determine how much memory to allocate
+ * for copy_chatlist. */
+uint32_t count_chatlist(Messenger *m)
+{
+    uint32_t ret = 0;
+    uint32_t i;
+
+    for (i = 0; i < m->numchats; i++) {
+        if (m->chats[i]) {
+            ret++;
+        }
+    }
+
+    return ret;
+}
+
+/* Copy a list of valid chat IDs into the array out_list.
+ * If out_list is NULL, returns 0.
+ * Otherwise, returns the number of elements copied.
+ * If the array was too small, the contents
+ * of out_list will be truncated to list_size. */
+uint32_t copy_chatlist(Messenger *m, int *out_list, uint32_t list_size)
+{
+    if (!out_list)
+        return 0;
+
+    if (m->numchats == 0) {
+        return 0;
+    }
+
+    uint32_t i;
+    uint32_t ret = 0;
+
+    for (i = 0; i < m->numchats; i++) {
+        if (ret >= list_size) {
+            break; /* Abandon ship */
+        }
+
+        if (m->chats[i]) {
+            out_list[ret] = i;
+            ret++;
+        }
+    }
+
+    return ret;
+}
+