Add a test for double conference invite.

In Persistent Group Chats (PGC), this will cause a use-after-free. This
test ensures that we fix this bug before merging PGC.

2 files changed, 174 insertions, 25 deletions

diff --git a/auto_tests/conference_double_invite_test.c b/auto_tests/conference_double_invite_test.c
new file mode 100644
index 00000000..ea85de10
--- /dev/null
+++ b/auto_tests/conference_double_invite_test.c
@@ -0,0 +1,154 @@
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 600
+#endif
+
+#include "../toxcore/tox.h"
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "helpers.h"
+
+typedef struct State {
+    uint32_t id;
+    bool self_online;
+    bool friend_online;
+
+    bool joined;
+    uint32_t conference;
+} State;
+
+static void handle_self_connection_status(Tox *tox, TOX_CONNECTION connection_status, void *user_data)
+{
+    State *state = (State *)user_data;
+
+    fprintf(stderr, "self_connection_status(#%u, %d, _)\n", state->id, connection_status);
+    state->self_online = connection_status != TOX_CONNECTION_NONE;
+}
+
+static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, TOX_CONNECTION connection_status,
+        void *user_data)
+{
+    State *state = (State *)user_data;
+
+    fprintf(stderr, "handle_friend_connection_status(#%u, %u, %d, _)\n", state->id, friend_number, connection_status);
+    state->friend_online = connection_status != TOX_CONNECTION_NONE;
+}
+
+static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFERENCE_TYPE type, const uint8_t *cookie,
+                                     size_t length, void *user_data)
+{
+    State *state = (State *)user_data;
+
+    fprintf(stderr, "handle_conference_invite(#%u, %u, %d, uint8_t[%u], _)\n",
+            state->id, friend_number, type, (unsigned)length);
+    fprintf(stderr, "tox%u joining conference\n", state->id);
+
+    if (friend_number != -1) {
+        TOX_ERR_CONFERENCE_JOIN err;
+        state->conference = tox_conference_join(tox, friend_number, cookie, length, &err);
+        assert(err == TOX_ERR_CONFERENCE_JOIN_OK);
+        fprintf(stderr, "tox%u Joined conference %u\n", state->id, state->conference);
+        state->joined = true;
+    }
+}
+
+int main(void)
+{
+    setvbuf(stdout, nullptr, _IONBF, 0);
+
+    State state1 = {1};
+    State state2 = {2};
+
+    // Create toxes.
+    Tox *tox1 = tox_new_log(nullptr, nullptr, &state1.id);
+    Tox *tox2 = tox_new_log(nullptr, nullptr, &state2.id);
+
+    // tox1 <-> tox2
+    uint8_t key[TOX_PUBLIC_KEY_SIZE];
+    tox_self_get_public_key(tox2, key);
+    tox_friend_add_norequest(tox1, key, nullptr);  // tox1 -> tox2
+    tox_self_get_public_key(tox1, key);
+    tox_friend_add_norequest(tox2, key, nullptr);  // tox2 -> tox1
+
+    printf("bootstrapping tox2 off tox1\n");
+    uint8_t dht_key[TOX_PUBLIC_KEY_SIZE];
+    tox_self_get_dht_id(tox1, dht_key);
+    const uint16_t dht_port = tox_self_get_udp_port(tox1, nullptr);
+
+    tox_bootstrap(tox2, "localhost", dht_port, dht_key, nullptr);
+
+    // Connection callbacks.
+    tox_callback_self_connection_status(tox1, handle_self_connection_status);
+    tox_callback_self_connection_status(tox2, handle_self_connection_status);
+
+    tox_callback_friend_connection_status(tox1, handle_friend_connection_status);
+    tox_callback_friend_connection_status(tox2, handle_friend_connection_status);
+
+    // Conference callbacks.
+    tox_callback_conference_invite(tox1, handle_conference_invite);
+    tox_callback_conference_invite(tox2, handle_conference_invite);
+
+    // Wait for self connection.
+    fprintf(stderr, "Waiting for toxes to come online\n");
+
+    while (!state1.self_online || !state2.self_online) {
+        tox_iterate(tox1, &state1);
+        tox_iterate(tox2, &state2);
+
+        c_sleep(100);
+    }
+
+    fprintf(stderr, "Toxes are online\n");
+
+    // Wait for friend connection.
+    fprintf(stderr, "Waiting for friends to connect\n");
+
+    while (!state1.friend_online || !state2.friend_online) {
+        tox_iterate(tox1, &state1);
+        tox_iterate(tox2, &state2);
+
+        c_sleep(100);
+    }
+
+    fprintf(stderr, "Friends are connected\n");
+
+    {
+        // Create new conference, tox1 is the founder.
+        TOX_ERR_CONFERENCE_NEW err;
+        state1.conference = tox_conference_new(tox1, &err);
+        state1.joined = true;
+        assert(err == TOX_ERR_CONFERENCE_NEW_OK);
+        fprintf(stderr, "Created conference: id=%u\n", state1.conference);
+    }
+
+    {
+        // Invite friend.
+        TOX_ERR_CONFERENCE_INVITE err;
+        tox_conference_invite(tox1, 0, state1.conference, &err);
+        assert(err == TOX_ERR_CONFERENCE_INVITE_OK);
+        fprintf(stderr, "tox1 invited tox2\n");
+    }
+
+    fprintf(stderr, "Waiting for invitation to arrive\n");
+
+    while (!state1.joined || !state2.joined) {
+        tox_iterate(tox1, &state1);
+        tox_iterate(tox2, &state2);
+
+        c_sleep(100);
+    }
+
+    fprintf(stderr, "Invitations accepted\n");
+
+    // Invite one more time, resulting in friend -1 inviting tox2.
+    tox_conference_invite(tox1, 0, state1.conference, 0);
+
+    tox_iterate(tox1, &state1);
+    tox_iterate(tox2, &state2);
+
+    tox_kill(tox2);
+    tox_kill(tox1);
+
+    return 0;
+}
diff --git a/auto_tests/simple_conference_test.c b/auto_tests/simple_conference_test.c
index c1c6e730..3e2f0f94 100644
--- a/auto_tests/simple_conference_test.c
+++ b/auto_tests/simple_conference_test.c
@@ -26,7 +26,7 @@ static void handle_self_connection_status(Tox *tox, TOX_CONNECTION connection_st
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "\nself_connection_status(#%d, %d, _)\n", state->id, connection_status);
+    fprintf(stderr, "self_connection_status(#%d, %d, _)\n", state->id, connection_status);
     state->self_online = connection_status != TOX_CONNECTION_NONE;
 }
 
@@ -35,7 +35,7 @@ static void handle_friend_connection_status(Tox *tox, uint32_t friend_number, TO
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "\nhandle_friend_connection_status(#%d, %d, %d, _)\n", state->id, friend_number, connection_status);
+    fprintf(stderr, "handle_friend_connection_status(#%d, %d, %d, _)\n", state->id, friend_number, connection_status);
     state->friend_online = connection_status != TOX_CONNECTION_NONE;
 }
 
@@ -44,7 +44,7 @@ static void handle_conference_invite(Tox *tox, uint32_t friend_number, TOX_CONFE
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "\nhandle_conference_invite(#%d, %d, %d, uint8_t[%u], _)\n",
+    fprintf(stderr, "handle_conference_invite(#%d, %d, %d, uint8_t[%u], _)\n",
             state->id, friend_number, type, (unsigned)length);
     fprintf(stderr, "tox%d joining conference\n", state->id);
 
@@ -75,7 +75,7 @@ static void handle_conference_message(Tox *tox, uint32_t conference_number, uint
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "\nhandle_conference_message(#%d, %d, %d, %d, uint8_t[%u], _)\n",
+    fprintf(stderr, "handle_conference_message(#%d, %d, %d, %d, uint8_t[%u], _)\n",
             state->id, conference_number, peer_number, type, (unsigned)length);
 
     fprintf(stderr, "tox%d got message: %s\n", state->id, (const char *)message);
@@ -86,7 +86,7 @@ static void handle_conference_peer_list_changed(Tox *tox, uint32_t conference_nu
 {
     State *state = (State *)user_data;
 
-    fprintf(stderr, "\nhandle_conference_peer_list_changed(#%d, %d, _)\n",
+    fprintf(stderr, "handle_conference_peer_list_changed(#%d, %d, _)\n",
             state->id, conference_number);
 
     TOX_ERR_CONFERENCE_PEER_QUERY err;
@@ -156,32 +156,30 @@ int main(void)
     tox_callback_conference_peer_list_changed(tox3, handle_conference_peer_list_changed);
 
     // Wait for self connection.
-    fprintf(stderr, "Waiting for toxes to come online");
+    fprintf(stderr, "Waiting for toxes to come online\n");
 
     while (!state1.self_online || !state2.self_online || !state3.self_online) {
         tox_iterate(tox1, &state1);
         tox_iterate(tox2, &state2);
         tox_iterate(tox3, &state3);
 
-        c_sleep(1000);
-        fprintf(stderr, ".");
+        c_sleep(100);
     }
 
-    fprintf(stderr, "\nToxes are online\n");
+    fprintf(stderr, "Toxes are online\n");
 
     // Wait for friend connection.
-    fprintf(stderr, "Waiting for friends to connect");
+    fprintf(stderr, "Waiting for friends to connect\n");
 
     while (!state1.friend_online || !state2.friend_online || !state3.friend_online) {
         tox_iterate(tox1, &state1);
         tox_iterate(tox2, &state2);
         tox_iterate(tox3, &state3);
 
-        c_sleep(1000);
-        fprintf(stderr, ".");
+        c_sleep(100);
     }
 
-    fprintf(stderr, "\nFriends are connected\n");
+    fprintf(stderr, "Friends are connected\n");
 
     {
         // Create new conference, tox1 is the founder.
@@ -200,31 +198,29 @@ int main(void)
         fprintf(stderr, "tox1 invited tox2\n");
     }
 
-    fprintf(stderr, "Waiting for invitation to arrive");
+    fprintf(stderr, "Waiting for invitation to arrive\n");
 
     while (!state1.joined || !state2.joined || !state3.joined) {
         tox_iterate(tox1, &state1);
         tox_iterate(tox2, &state2);
         tox_iterate(tox3, &state3);
 
-        c_sleep(1000);
-        fprintf(stderr, ".");
+        c_sleep(100);
     }
 
-    fprintf(stderr, "\nInvitations accepted\n");
+    fprintf(stderr, "Invitations accepted\n");
 
-    fprintf(stderr, "Waiting for peers to come online");
+    fprintf(stderr, "Waiting for peers to come online\n");
 
     while (state1.peers == 0 || state2.peers == 0 || state3.peers == 0) {
         tox_iterate(tox1, &state1);
         tox_iterate(tox2, &state2);
         tox_iterate(tox3, &state3);
 
-        c_sleep(1000);
-        fprintf(stderr, ".");
+        c_sleep(100);
     }
 
-    fprintf(stderr, "\nAll peers are online\n");
+    fprintf(stderr, "All peers are online\n");
 
     {
         fprintf(stderr, "tox1 sends a message to the group: \"hello!\"\n");
@@ -238,18 +234,17 @@ int main(void)
         }
     }
 
-    fprintf(stderr, "Waiting for messages to arrive");
+    fprintf(stderr, "Waiting for messages to arrive\n");
 
     while (!state2.received || !state3.received) {
         tox_iterate(tox1, &state1);
         tox_iterate(tox2, &state2);
         tox_iterate(tox3, &state3);
 
-        c_sleep(1000);
-        fprintf(stderr, ".");
+        c_sleep(100);
     }
 
-    fprintf(stderr, "\nMessages received. Test complete.\n");
+    fprintf(stderr, "Messages received. Test complete.\n");
 
     tox_kill(tox3);
     tox_kill(tox2);