8 files changed, 544 insertions, 380 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8bba3519..9acb97d2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -524,6 +524,7 @@ auto_test(conference)
 auto_test(crypto                        MSVC_DONT_BUILD)
 auto_test(dht                           MSVC_DONT_BUILD)
 auto_test(encryptsave)
+auto_test(file_transfer)
 auto_test(lan_discovery)
 auto_test(messenger                     MSVC_DONT_BUILD)
 auto_test(network)
diff --git a/auto_tests/file_transfer_test.c b/auto_tests/file_transfer_test.c
new file mode 100644
index 00000000..7247a188
--- /dev/null
+++ b/auto_tests/file_transfer_test.c
@@ -0,0 +1,429 @@
+/* File transfer test.
+ */
+
+#ifndef _XOPEN_SOURCE
+#define _XOPEN_SOURCE 600
+#endif
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "check_compat.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#include "../toxcore/ccompat.h"
+#include "../toxcore/tox.h"
+#include "../toxcore/util.h"
+
+#include "helpers.h"
+
+/* The Travis-CI container responds poorly to ::1 as a localhost address
+ * You're encouraged to -D FORCE_TESTS_IPV6 on a local test  */
+#ifdef FORCE_TESTS_IPV6
+#define TOX_LOCALHOST "::1"
+#else
+#define TOX_LOCALHOST "127.0.0.1"
+#endif
+
+static void accept_friend_request(Tox *m, const uint8_t *public_key, const uint8_t *data, size_t length, void *userdata)
+{
+    if (length == 7 && memcmp("Gentoo", data, 7) == 0) {
+        tox_friend_add_norequest(m, public_key, nullptr);
+    }
+}
+
+static uint64_t size_recv;
+static uint64_t sending_pos;
+
+static uint8_t file_cmp_id[TOX_FILE_ID_LENGTH];
+static uint32_t file_accepted;
+static uint64_t file_size;
+static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_number, uint32_t kind, uint64_t filesize,
+                             const uint8_t *filename, size_t filename_length, void *userdata)
+{
+    if (kind != TOX_FILE_KIND_DATA) {
+        ck_abort_msg("Bad kind");
+    }
+
+    if (!(filename_length == sizeof("Gentoo.exe") && memcmp(filename, "Gentoo.exe", sizeof("Gentoo.exe")) == 0)) {
+        ck_abort_msg("Bad filename");
+    }
+
+    uint8_t file_id[TOX_FILE_ID_LENGTH];
+
+    if (!tox_file_get_file_id(tox, friend_number, file_number, file_id, nullptr)) {
+        ck_abort_msg("tox_file_get_file_id error");
+    }
+
+    if (memcmp(file_id, file_cmp_id, TOX_FILE_ID_LENGTH) != 0) {
+        ck_abort_msg("bad file_id");
+    }
+
+    uint8_t empty[TOX_FILE_ID_LENGTH] = {0};
+
+    if (memcmp(empty, file_cmp_id, TOX_FILE_ID_LENGTH) == 0) {
+        ck_abort_msg("empty file_id");
+    }
+
+    file_size = filesize;
+
+    if (filesize) {
+        sending_pos = size_recv = 1337;
+
+        TOX_ERR_FILE_SEEK err_s;
+
+        if (!tox_file_seek(tox, friend_number, file_number, 1337, &err_s)) {
+            ck_abort_msg("tox_file_seek error");
+        }
+
+        ck_assert_msg(err_s == TOX_ERR_FILE_SEEK_OK, "tox_file_seek wrong error");
+    } else {
+        sending_pos = size_recv = 0;
+    }
+
+    TOX_ERR_FILE_CONTROL error;
+
+    if (tox_file_control(tox, friend_number, file_number, TOX_FILE_CONTROL_RESUME, &error)) {
+        ++file_accepted;
+    } else {
+        ck_abort_msg("tox_file_control failed. %i", error);
+    }
+
+    TOX_ERR_FILE_SEEK err_s;
+
+    if (tox_file_seek(tox, friend_number, file_number, 1234, &err_s)) {
+        ck_abort_msg("tox_file_seek no error");
+    }
+
+    ck_assert_msg(err_s == TOX_ERR_FILE_SEEK_DENIED, "tox_file_seek wrong error");
+}
+
+static uint32_t sendf_ok;
+static void file_print_control(Tox *tox, uint32_t friend_number, uint32_t file_number, TOX_FILE_CONTROL control,
+                               void *userdata)
+{
+    /* First send file num is 0.*/
+    if (file_number == 0 && control == TOX_FILE_CONTROL_RESUME) {
+        sendf_ok = 1;
+    }
+}
+
+static uint64_t max_sending;
+static bool m_send_reached;
+static uint8_t sending_num;
+static bool file_sending_done;
+static void tox_file_chunk_request(Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position,
+                                   size_t length, void *user_data)
+{
+    if (!sendf_ok) {
+        ck_abort_msg("Didn't get resume control");
+    }
+
+    if (sending_pos != position) {
+        ck_abort_msg("Bad position %llu", (unsigned long long)position);
+    }
+
+    if (length == 0) {
+        if (file_sending_done) {
+            ck_abort_msg("File sending already done.");
+        }
+
+        file_sending_done = 1;
+        return;
+    }
+
+    if (position + length > max_sending) {
+        if (m_send_reached) {
+            ck_abort_msg("Requested done file transfer.");
+        }
+
+        length = max_sending - position;
+        m_send_reached = 1;
+    }
+
+    TOX_ERR_FILE_SEND_CHUNK error;
+    VLA(uint8_t, f_data, length);
+    memset(f_data, sending_num, length);
+
+    if (tox_file_send_chunk(tox, friend_number, file_number, position, f_data, length, &error)) {
+        ++sending_num;
+        sending_pos += length;
+    } else {
+        ck_abort_msg("Could not send chunk, error num=%d pos=%d len=%d", (int)error, (int)position, (int)length);
+    }
+
+    if (error != TOX_ERR_FILE_SEND_CHUNK_OK) {
+        ck_abort_msg("Wrong error code");
+    }
+}
+
+
+static uint8_t num;
+static bool file_recv;
+static void write_file(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data,
+                       size_t length, void *user_data)
+{
+    if (size_recv != position) {
+        ck_abort_msg("Bad position");
+    }
+
+    if (length == 0) {
+        file_recv = 1;
+        return;
+    }
+
+    VLA(uint8_t, f_data, length);
+    memset(f_data, num, length);
+    ++num;
+
+    if (memcmp(f_data, data, length) == 0) {
+        size_recv += length;
+    } else {
+        ck_abort_msg("FILE_CORRUPTED");
+    }
+}
+
+START_TEST(test_few_clients)
+{
+    printf("Starting test: few_clients\n");
+    uint32_t index[] = { 1, 2, 3 };
+    long long unsigned int cur_time = time(nullptr);
+    TOX_ERR_NEW t_n_error;
+    Tox *tox1 = tox_new_log(nullptr, &t_n_error, &index[0]);
+    ck_assert_msg(t_n_error == TOX_ERR_NEW_OK, "wrong error");
+    Tox *tox2 = tox_new_log(nullptr, &t_n_error, &index[1]);
+    ck_assert_msg(t_n_error == TOX_ERR_NEW_OK, "wrong error");
+    Tox *tox3 = tox_new_log(nullptr, &t_n_error, &index[2]);
+    ck_assert_msg(t_n_error == TOX_ERR_NEW_OK, "wrong error");
+
+    ck_assert_msg(tox1 && tox2 && tox3, "Failed to create 3 tox instances");
+
+    {
+        TOX_ERR_GET_PORT error;
+        uint16_t first_port = tox_self_get_udp_port(tox1, &error);
+        ck_assert_msg(33445 <= first_port && first_port <= 33545 - 2,
+                      "First Tox instance did not bind to udp port inside [33445, 33543].\n");
+        ck_assert_msg(error == TOX_ERR_GET_PORT_OK, "wrong error");
+
+        ck_assert_msg(tox_self_get_udp_port(tox2, &error) == first_port + 1,
+                      "Second Tox instance did not bind to udp port %d.\n", first_port + 1);
+        ck_assert_msg(error == TOX_ERR_GET_PORT_OK, "wrong error");
+
+        ck_assert_msg(tox_self_get_udp_port(tox3, &error) == first_port + 2,
+                      "Third Tox instance did not bind to udp port %d.\n", first_port + 2);
+        ck_assert_msg(error == TOX_ERR_GET_PORT_OK, "wrong error");
+    }
+
+    tox_callback_friend_request(tox2, accept_friend_request);
+    uint8_t address[TOX_ADDRESS_SIZE];
+    tox_self_get_address(tox2, address);
+    uint32_t test = tox_friend_add(tox3, address, (const uint8_t *)"Gentoo", 7, nullptr);
+    ck_assert_msg(test == 0, "Failed to add friend error code: %i", test);
+
+    uint8_t dhtKey[TOX_PUBLIC_KEY_SIZE];
+    tox_self_get_dht_id(tox1, dhtKey);
+    uint16_t dhtPort = tox_self_get_udp_port(tox1, nullptr);
+
+    tox_bootstrap(tox2, TOX_LOCALHOST, dhtPort, dhtKey, nullptr);
+    tox_bootstrap(tox3, TOX_LOCALHOST, dhtPort, dhtKey, nullptr);
+
+    printf("Waiting for toxes to come online\n");
+
+    while (tox_self_get_connection_status(tox1) == TOX_CONNECTION_NONE ||
+            tox_self_get_connection_status(tox2) == TOX_CONNECTION_NONE ||
+            tox_self_get_connection_status(tox3) == TOX_CONNECTION_NONE ||
+            tox_friend_get_connection_status(tox2, 0, nullptr) == TOX_CONNECTION_NONE ||
+            tox_friend_get_connection_status(tox3, 0, nullptr) == TOX_CONNECTION_NONE) {
+        tox_iterate(tox1, nullptr);
+        tox_iterate(tox2, nullptr);
+        tox_iterate(tox3, nullptr);
+
+        printf("Connections: self (%d, %d, %d), friends (%d, %d)\n",
+               tox_self_get_connection_status(tox1),
+               tox_self_get_connection_status(tox2),
+               tox_self_get_connection_status(tox3),
+               tox_friend_get_connection_status(tox2, 0, nullptr),
+               tox_friend_get_connection_status(tox3, 0, nullptr));
+        c_sleep(1000);
+    }
+
+    printf("Starting file transfer test.\n");
+
+    file_accepted = file_size = sendf_ok = size_recv = 0;
+    file_recv = 0;
+    max_sending = UINT64_MAX;
+    long long unsigned int f_time = time(nullptr);
+    tox_callback_file_recv_chunk(tox3, write_file);
+    tox_callback_file_recv_control(tox2, file_print_control);
+    tox_callback_file_chunk_request(tox2, tox_file_chunk_request);
+    tox_callback_file_recv_control(tox3, file_print_control);
+    tox_callback_file_recv(tox3, tox_file_receive);
+    uint64_t totalf_size = 100 * 1024 * 1024;
+    uint32_t fnum = tox_file_send(tox2, 0, TOX_FILE_KIND_DATA, totalf_size, nullptr, (const uint8_t *)"Gentoo.exe",
+                                  sizeof("Gentoo.exe"), nullptr);
+    ck_assert_msg(fnum != UINT32_MAX, "tox_new_file_sender fail");
+
+    TOX_ERR_FILE_GET gfierr;
+    ck_assert_msg(!tox_file_get_file_id(tox2, 1, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_FRIEND_NOT_FOUND, "wrong error");
+    ck_assert_msg(!tox_file_get_file_id(tox2, 0, fnum + 1, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_NOT_FOUND, "wrong error");
+    ck_assert_msg(tox_file_get_file_id(tox2, 0, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id failed");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_OK, "wrong error");
+
+    while (1) {
+        tox_iterate(tox1, nullptr);
+        tox_iterate(tox2, nullptr);
+        tox_iterate(tox3, nullptr);
+
+        if (file_sending_done) {
+            if (sendf_ok && file_recv && totalf_size == file_size && size_recv == file_size && sending_pos == size_recv
+                    && file_accepted == 1) {
+                break;
+            }
+
+            ck_abort_msg("Something went wrong in file transfer %u %u %u %u %u %u %llu %llu %llu", sendf_ok, file_recv,
+                         totalf_size == file_size, size_recv == file_size, sending_pos == size_recv, file_accepted == 1,
+                         (unsigned long long)totalf_size, (unsigned long long)size_recv,
+                         (unsigned long long)sending_pos);
+        }
+
+        uint32_t tox1_interval = tox_iteration_interval(tox1);
+        uint32_t tox2_interval = tox_iteration_interval(tox2);
+        uint32_t tox3_interval = tox_iteration_interval(tox3);
+
+        c_sleep(MIN(tox1_interval, MIN(tox2_interval, tox3_interval)));
+    }
+
+    printf("100MB file sent in %llu seconds\n", time(nullptr) - f_time);
+
+    printf("Starting file streaming transfer test.\n");
+
+    file_sending_done = file_accepted = file_size = sendf_ok = size_recv = 0;
+    file_recv = 0;
+    tox_callback_file_recv_chunk(tox3, write_file);
+    tox_callback_file_recv_control(tox2, file_print_control);
+    tox_callback_file_chunk_request(tox2, tox_file_chunk_request);
+    tox_callback_file_recv_control(tox3, file_print_control);
+    tox_callback_file_recv(tox3, tox_file_receive);
+    totalf_size = UINT64_MAX;
+    fnum = tox_file_send(tox2, 0, TOX_FILE_KIND_DATA, totalf_size, nullptr,
+                         (const uint8_t *)"Gentoo.exe", sizeof("Gentoo.exe"), nullptr);
+    ck_assert_msg(fnum != UINT32_MAX, "tox_new_file_sender fail");
+
+    ck_assert_msg(!tox_file_get_file_id(tox2, 1, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_FRIEND_NOT_FOUND, "wrong error");
+    ck_assert_msg(!tox_file_get_file_id(tox2, 0, fnum + 1, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_NOT_FOUND, "wrong error");
+    ck_assert_msg(tox_file_get_file_id(tox2, 0, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id failed");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_OK, "wrong error");
+
+    max_sending = 100 * 1024;
+    m_send_reached = 0;
+
+    while (1) {
+        tox_iterate(tox1, nullptr);
+        tox_iterate(tox2, nullptr);
+        tox_iterate(tox3, nullptr);
+
+        if (file_sending_done) {
+            if (sendf_ok && file_recv && m_send_reached && totalf_size == file_size && size_recv == max_sending
+                    && sending_pos == size_recv && file_accepted == 1) {
+                break;
+            }
+
+            ck_abort_msg("Something went wrong in file transfer %u %u %u %u %u %u %u %llu %llu %llu %llu", sendf_ok, file_recv,
+                         m_send_reached, totalf_size == file_size, size_recv == max_sending, sending_pos == size_recv, file_accepted == 1,
+                         (unsigned long long)totalf_size, (unsigned long long)file_size,
+                         (unsigned long long)size_recv, (unsigned long long)sending_pos);
+        }
+
+        uint32_t tox1_interval = tox_iteration_interval(tox1);
+        uint32_t tox2_interval = tox_iteration_interval(tox2);
+        uint32_t tox3_interval = tox_iteration_interval(tox3);
+
+        c_sleep(MIN(tox1_interval, MIN(tox2_interval, tox3_interval)));
+    }
+
+    printf("Starting file 0 transfer test.\n");
+
+    file_sending_done = file_accepted = file_size = sendf_ok = size_recv = 0;
+    file_recv = 0;
+    tox_callback_file_recv_chunk(tox3, write_file);
+    tox_callback_file_recv_control(tox2, file_print_control);
+    tox_callback_file_chunk_request(tox2, tox_file_chunk_request);
+    tox_callback_file_recv_control(tox3, file_print_control);
+    tox_callback_file_recv(tox3, tox_file_receive);
+    totalf_size = 0;
+    fnum = tox_file_send(tox2, 0, TOX_FILE_KIND_DATA, totalf_size, nullptr,
+                         (const uint8_t *)"Gentoo.exe", sizeof("Gentoo.exe"), nullptr);
+    ck_assert_msg(fnum != UINT32_MAX, "tox_new_file_sender fail");
+
+    ck_assert_msg(!tox_file_get_file_id(tox2, 1, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_FRIEND_NOT_FOUND, "wrong error");
+    ck_assert_msg(!tox_file_get_file_id(tox2, 0, fnum + 1, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_NOT_FOUND, "wrong error");
+    ck_assert_msg(tox_file_get_file_id(tox2, 0, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id failed");
+    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_OK, "wrong error");
+
+    while (1) {
+        tox_iterate(tox1, nullptr);
+        tox_iterate(tox2, nullptr);
+        tox_iterate(tox3, nullptr);
+
+        if (file_sending_done) {
+            if (sendf_ok && file_recv && totalf_size == file_size && size_recv == file_size && sending_pos == size_recv
+                    && file_accepted == 1) {
+                break;
+            }
+
+            ck_abort_msg("Something went wrong in file transfer %u %u %u %u %u %u %llu %llu %llu", sendf_ok, file_recv,
+                         totalf_size == file_size, size_recv == file_size, sending_pos == size_recv, file_accepted == 1,
+                         (unsigned long long)totalf_size, (unsigned long long)size_recv,
+                         (unsigned long long)sending_pos);
+        }
+
+        uint32_t tox1_interval = tox_iteration_interval(tox1);
+        uint32_t tox2_interval = tox_iteration_interval(tox2);
+        uint32_t tox3_interval = tox_iteration_interval(tox3);
+
+        c_sleep(MIN(tox1_interval, MIN(tox2_interval, tox3_interval)));
+    }
+
+    printf("test_few_clients succeeded, took %llu seconds\n", time(nullptr) - cur_time);
+
+    tox_kill(tox1);
+    tox_kill(tox2);
+    tox_kill(tox3);
+}
+END_TEST
+
+static Suite *tox_suite(void)
+{
+    Suite *s = suite_create("Tox few clients");
+
+    DEFTESTCASE(few_clients);
+
+    return s;
+}
+
+int main(int argc, char *argv[])
+{
+    setvbuf(stdout, nullptr, _IONBF, 0);
+    srand((unsigned int) time(nullptr));
+
+    Suite *tox = tox_suite();
+    SRunner *test_runner = srunner_create(tox);
+
+    int number_failed = 0;
+    srunner_run_all(test_runner, CK_NORMAL);
+    number_failed = srunner_ntests_failed(test_runner);
+
+    srunner_free(test_runner);
+
+    return number_failed;
+}
diff --git a/auto_tests/helpers.h b/auto_tests/helpers.h
index ac58684d..0c88f4a1 100644
--- a/auto_tests/helpers.h
+++ b/auto_tests/helpers.h
@@ -42,18 +42,10 @@ static const char *tox_log_level_name(TOX_LOG_LEVEL level)
 static void print_debug_log(Tox *m, TOX_LOG_LEVEL level, const char *path, uint32_t line, const char *func,
                             const char *message, void *user_data)
 {
-    if (level == TOX_LOG_LEVEL_TRACE) {
-        return;
-    }
-
-    if (strncmp(message, "Bound successfully to ", strlen("Bound successfully to "))) {
-        return;
-    }
-
     uint32_t index = user_data ? *(uint32_t *)user_data : 0;
     const char *file = strrchr(path, '/');
     file = file ? file + 1 : path;
-    printf("[#%d] %s %s:%d\t%s:\t%s\n", index, tox_log_level_name(level), file, line, func, message);
+    fprintf(stderr, "[#%d] %s %s:%d\t%s:\t%s\n", index, tox_log_level_name(level), file, line, func, message);
 }
 
 Tox *tox_new_log(struct Tox_Options *options, TOX_ERR_NEW *err, void *log_user_data)
diff --git a/auto_tests/tox_test.c b/auto_tests/tox_test.c
index 82c18b37..d6613a9a 100644
--- a/auto_tests/tox_test.c
+++ b/auto_tests/tox_test.c
@@ -133,174 +133,6 @@ static void handle_custom_packet(Tox *m, uint32_t friend_num, const uint8_t *dat
     return;
 }
 
-static uint64_t size_recv;
-static uint64_t sending_pos;
-
-static uint8_t file_cmp_id[TOX_FILE_ID_LENGTH];
-static uint32_t file_accepted;
-static uint64_t file_size;
-static void tox_file_receive(Tox *tox, uint32_t friend_number, uint32_t file_number, uint32_t kind, uint64_t filesize,
-                             const uint8_t *filename, size_t filename_length, void *userdata)
-{
-    if (*((uint32_t *)userdata) != 974536) {
-        return;
-    }
-
-    if (kind != TOX_FILE_KIND_DATA) {
-        ck_abort_msg("Bad kind");
-    }
-
-    if (!(filename_length == sizeof("Gentoo.exe") && memcmp(filename, "Gentoo.exe", sizeof("Gentoo.exe")) == 0)) {
-        ck_abort_msg("Bad filename");
-    }
-
-    uint8_t file_id[TOX_FILE_ID_LENGTH];
-
-    if (!tox_file_get_file_id(tox, friend_number, file_number, file_id, nullptr)) {
-        ck_abort_msg("tox_file_get_file_id error");
-    }
-
-    if (memcmp(file_id, file_cmp_id, TOX_FILE_ID_LENGTH) != 0) {
-        ck_abort_msg("bad file_id");
-    }
-
-    uint8_t empty[TOX_FILE_ID_LENGTH] = {0};
-
-    if (memcmp(empty, file_cmp_id, TOX_FILE_ID_LENGTH) == 0) {
-        ck_abort_msg("empty file_id");
-    }
-
-    file_size = filesize;
-
-    if (filesize) {
-        sending_pos = size_recv = 1337;
-
-        TOX_ERR_FILE_SEEK err_s;
-
-        if (!tox_file_seek(tox, friend_number, file_number, 1337, &err_s)) {
-            ck_abort_msg("tox_file_seek error");
-        }
-
-        ck_assert_msg(err_s == TOX_ERR_FILE_SEEK_OK, "tox_file_seek wrong error");
-    } else {
-        sending_pos = size_recv = 0;
-    }
-
-    TOX_ERR_FILE_CONTROL error;
-
-    if (tox_file_control(tox, friend_number, file_number, TOX_FILE_CONTROL_RESUME, &error)) {
-        ++file_accepted;
-    } else {
-        ck_abort_msg("tox_file_control failed. %i", error);
-    }
-
-    TOX_ERR_FILE_SEEK err_s;
-
-    if (tox_file_seek(tox, friend_number, file_number, 1234, &err_s)) {
-        ck_abort_msg("tox_file_seek no error");
-    }
-
-    ck_assert_msg(err_s == TOX_ERR_FILE_SEEK_DENIED, "tox_file_seek wrong error");
-}
-
-static uint32_t sendf_ok;
-static void file_print_control(Tox *tox, uint32_t friend_number, uint32_t file_number, TOX_FILE_CONTROL control,
-                               void *userdata)
-{
-    if (*((uint32_t *)userdata) != 974536) {
-        return;
-    }
-
-    /* First send file num is 0.*/
-    if (file_number == 0 && control == TOX_FILE_CONTROL_RESUME) {
-        sendf_ok = 1;
-    }
-}
-
-static uint64_t max_sending;
-static bool m_send_reached;
-static uint8_t sending_num;
-static bool file_sending_done;
-static void tox_file_chunk_request(Tox *tox, uint32_t friend_number, uint32_t file_number, uint64_t position,
-                                   size_t length,
-                                   void *user_data)
-{
-    if (*((uint32_t *)user_data) != 974536) {
-        return;
-    }
-
-    if (!sendf_ok) {
-        ck_abort_msg("Didn't get resume control");
-    }
-
-    if (sending_pos != position) {
-        ck_abort_msg("Bad position %llu", (unsigned long long)position);
-    }
-
-    if (length == 0) {
-        if (file_sending_done) {
-            ck_abort_msg("File sending already done.");
-        }
-
-        file_sending_done = 1;
-        return;
-    }
-
-    if (position + length > max_sending) {
-        if (m_send_reached) {
-            ck_abort_msg("Requested done file transfer.");
-        }
-
-        length = max_sending - position;
-        m_send_reached = 1;
-    }
-
-    TOX_ERR_FILE_SEND_CHUNK error;
-    VLA(uint8_t, f_data, length);
-    memset(f_data, sending_num, length);
-
-    if (tox_file_send_chunk(tox, friend_number, file_number, position, f_data, length, &error)) {
-        ++sending_num;
-        sending_pos += length;
-    } else {
-        ck_abort_msg("Could not send chunk %i", error);
-    }
-
-    if (error != TOX_ERR_FILE_SEND_CHUNK_OK) {
-        ck_abort_msg("Wrong error code");
-    }
-}
-
-
-static uint8_t num;
-static bool file_recv;
-static void write_file(Tox *tox, uint32_t friendnumber, uint32_t filenumber, uint64_t position, const uint8_t *data,
-                       size_t length, void *user_data)
-{
-    if (*((uint32_t *)user_data) != 974536) {
-        return;
-    }
-
-    if (size_recv != position) {
-        ck_abort_msg("Bad position");
-    }
-
-    if (length == 0) {
-        file_recv = 1;
-        return;
-    }
-
-    VLA(uint8_t, f_data, length);
-    memset(f_data, num, length);
-    ++num;
-
-    if (memcmp(f_data, data, length) == 0) {
-        size_recv += length;
-    } else {
-        ck_abort_msg("FILE_CORRUPTED");
-    }
-}
-
 static unsigned int connected_t1;
 static void tox_connection_status(Tox *tox, TOX_CONNECTION connection_status, void *user_data)
 {
@@ -578,149 +410,6 @@ START_TEST(test_few_clients)
         c_sleep(50);
     }
 
-    printf("Starting file transfer test.\n");
-
-    file_accepted = file_size = sendf_ok = size_recv = 0;
-    file_recv = 0;
-    max_sending = UINT64_MAX;
-    long long unsigned int f_time = time(nullptr);
-    tox_callback_file_recv_chunk(tox3, write_file);
-    tox_callback_file_recv_control(tox2, file_print_control);
-    tox_callback_file_chunk_request(tox2, tox_file_chunk_request);
-    tox_callback_file_recv_control(tox3, file_print_control);
-    tox_callback_file_recv(tox3, tox_file_receive);
-    uint64_t totalf_size = 100 * 1024 * 1024;
-    uint32_t fnum = tox_file_send(tox2, 0, TOX_FILE_KIND_DATA, totalf_size, nullptr, (const uint8_t *)"Gentoo.exe",
-                                  sizeof("Gentoo.exe"), nullptr);
-    ck_assert_msg(fnum != UINT32_MAX, "tox_new_file_sender fail");
-
-    TOX_ERR_FILE_GET gfierr;
-    ck_assert_msg(!tox_file_get_file_id(tox2, 1, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_FRIEND_NOT_FOUND, "wrong error");
-    ck_assert_msg(!tox_file_get_file_id(tox2, 0, fnum + 1, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_NOT_FOUND, "wrong error");
-    ck_assert_msg(tox_file_get_file_id(tox2, 0, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id failed");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_OK, "wrong error");
-
-    while (1) {
-        tox_iterate(tox1, &to_compare);
-        tox_iterate(tox2, &to_compare);
-        tox_iterate(tox3, &to_compare);
-
-        if (file_sending_done) {
-            if (sendf_ok && file_recv && totalf_size == file_size && size_recv == file_size && sending_pos == size_recv
-                    && file_accepted == 1) {
-                break;
-            }
-
-            ck_abort_msg("Something went wrong in file transfer %u %u %u %u %u %u %llu %llu %llu", sendf_ok, file_recv,
-                         totalf_size == file_size, size_recv == file_size, sending_pos == size_recv, file_accepted == 1,
-                         (unsigned long long)totalf_size, (unsigned long long)size_recv,
-                         (unsigned long long)sending_pos);
-        }
-
-        uint32_t tox1_interval = tox_iteration_interval(tox1);
-        uint32_t tox2_interval = tox_iteration_interval(tox2);
-        uint32_t tox3_interval = tox_iteration_interval(tox3);
-
-        c_sleep(MIN(tox1_interval, MIN(tox2_interval, tox3_interval)));
-    }
-
-    printf("100MB file sent in %llu seconds\n", time(nullptr) - f_time);
-
-    printf("Starting file streaming transfer test.\n");
-
-    file_sending_done = file_accepted = file_size = sendf_ok = size_recv = 0;
-    file_recv = 0;
-    tox_callback_file_recv_chunk(tox3, write_file);
-    tox_callback_file_recv_control(tox2, file_print_control);
-    tox_callback_file_chunk_request(tox2, tox_file_chunk_request);
-    tox_callback_file_recv_control(tox3, file_print_control);
-    tox_callback_file_recv(tox3, tox_file_receive);
-    totalf_size = UINT64_MAX;
-    fnum = tox_file_send(tox2, 0, TOX_FILE_KIND_DATA, totalf_size, nullptr,
-                         (const uint8_t *)"Gentoo.exe", sizeof("Gentoo.exe"), nullptr);
-    ck_assert_msg(fnum != UINT32_MAX, "tox_new_file_sender fail");
-
-    ck_assert_msg(!tox_file_get_file_id(tox2, 1, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_FRIEND_NOT_FOUND, "wrong error");
-    ck_assert_msg(!tox_file_get_file_id(tox2, 0, fnum + 1, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_NOT_FOUND, "wrong error");
-    ck_assert_msg(tox_file_get_file_id(tox2, 0, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id failed");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_OK, "wrong error");
-
-    max_sending = 100 * 1024;
-    m_send_reached = 0;
-
-    while (1) {
-        tox_iterate(tox1, &to_compare);
-        tox_iterate(tox2, &to_compare);
-        tox_iterate(tox3, &to_compare);
-
-        if (file_sending_done) {
-            if (sendf_ok && file_recv && m_send_reached && totalf_size == file_size && size_recv == max_sending
-                    && sending_pos == size_recv && file_accepted == 1) {
-                break;
-            }
-
-            ck_abort_msg("Something went wrong in file transfer %u %u %u %u %u %u %u %llu %llu %llu %llu", sendf_ok, file_recv,
-                         m_send_reached, totalf_size == file_size, size_recv == max_sending, sending_pos == size_recv, file_accepted == 1,
-                         (unsigned long long)totalf_size, (unsigned long long)file_size,
-                         (unsigned long long)size_recv, (unsigned long long)sending_pos);
-        }
-
-        uint32_t tox1_interval = tox_iteration_interval(tox1);
-        uint32_t tox2_interval = tox_iteration_interval(tox2);
-        uint32_t tox3_interval = tox_iteration_interval(tox3);
-
-        c_sleep(MIN(tox1_interval, MIN(tox2_interval, tox3_interval)));
-    }
-
-    printf("Starting file 0 transfer test.\n");
-
-    file_sending_done = file_accepted = file_size = sendf_ok = size_recv = 0;
-    file_recv = 0;
-    tox_callback_file_recv_chunk(tox3, write_file);
-    tox_callback_file_recv_control(tox2, file_print_control);
-    tox_callback_file_chunk_request(tox2, tox_file_chunk_request);
-    tox_callback_file_recv_control(tox3, file_print_control);
-    tox_callback_file_recv(tox3, tox_file_receive);
-    totalf_size = 0;
-    fnum = tox_file_send(tox2, 0, TOX_FILE_KIND_DATA, totalf_size, nullptr,
-                         (const uint8_t *)"Gentoo.exe", sizeof("Gentoo.exe"), nullptr);
-    ck_assert_msg(fnum != UINT32_MAX, "tox_new_file_sender fail");
-
-    ck_assert_msg(!tox_file_get_file_id(tox2, 1, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_FRIEND_NOT_FOUND, "wrong error");
-    ck_assert_msg(!tox_file_get_file_id(tox2, 0, fnum + 1, file_cmp_id, &gfierr), "tox_file_get_file_id didn't fail");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_NOT_FOUND, "wrong error");
-    ck_assert_msg(tox_file_get_file_id(tox2, 0, fnum, file_cmp_id, &gfierr), "tox_file_get_file_id failed");
-    ck_assert_msg(gfierr == TOX_ERR_FILE_GET_OK, "wrong error");
-
-    while (1) {
-        tox_iterate(tox1, &to_compare);
-        tox_iterate(tox2, &to_compare);
-        tox_iterate(tox3, &to_compare);
-
-        if (file_sending_done) {
-            if (sendf_ok && file_recv && totalf_size == file_size && size_recv == file_size && sending_pos == size_recv
-                    && file_accepted == 1) {
-                break;
-            }
-
-            ck_abort_msg("Something went wrong in file transfer %u %u %u %u %u %u %llu %llu %llu", sendf_ok, file_recv,
-                         totalf_size == file_size, size_recv == file_size, sending_pos == size_recv, file_accepted == 1,
-                         (unsigned long long)totalf_size, (unsigned long long)size_recv,
-                         (unsigned long long)sending_pos);
-        }
-
-        uint32_t tox1_interval = tox_iteration_interval(tox1);
-        uint32_t tox2_interval = tox_iteration_interval(tox2);
-        uint32_t tox3_interval = tox_iteration_interval(tox3);
-
-        c_sleep(MIN(tox1_interval, MIN(tox2_interval, tox3_interval)));
-    }
-
     printf("test_few_clients succeeded, took %llu seconds\n", time(nullptr) - cur_time);
 
     tox_options_free(options);
diff --git a/toxcore/Messenger.c b/toxcore/Messenger.c
index 3baf7401..a6bccfdc 100644
--- a/toxcore/Messenger.c
+++ b/toxcore/Messenger.c
@@ -1482,119 +1482,159 @@ uint64_t file_dataremaining(const Messenger *m, int32_t friendnumber, uint8_t fi
         return 0;
     }
 
+    const struct File_Transfers *const sending = &m->friendlist[friendnumber].file_sending[filenumber];
+
     if (send_receive == 0) {
-        if (m->friendlist[friendnumber].file_sending[filenumber].status == FILESTATUS_NONE) {
+        if (sending->status == FILESTATUS_NONE) {
             return 0;
         }
 
-        return m->friendlist[friendnumber].file_sending[filenumber].size -
-               m->friendlist[friendnumber].file_sending[filenumber].transferred;
+        return sending->size - sending->transferred;
     }
 
-    if (m->friendlist[friendnumber].file_receiving[filenumber].status == FILESTATUS_NONE) {
+    const struct File_Transfers *const receiving = &m->friendlist[friendnumber].file_receiving[filenumber];
+
+    if (receiving->status == FILESTATUS_NONE) {
         return 0;
     }
 
-    return m->friendlist[friendnumber].file_receiving[filenumber].size -
-           m->friendlist[friendnumber].file_receiving[filenumber].transferred;
+    return receiving->size - receiving->transferred;
 }
 
-static void do_reqchunk_filecb(Messenger *m, int32_t friendnumber, void *userdata)
+/**
+ * Iterate over all file transfers and request chunks (from the client) for each
+ * of them.
+ *
+ * The free_slots parameter is updated by this function.
+ *
+ * @param m Our messenger object.
+ * @param friendnumber The friend we're sending files to.
+ * @param userdata The client userdata to pass along to chunk request callbacks.
+ * @param free_slots A pointer to the number of free send queue slots in the
+ *   crypto connection.
+ *
+ * @return true if there are still file transfers ongoing, false if all file
+ *   transfers are complete.
+ */
+static bool do_all_filetransfers(Messenger *m, int32_t friendnumber, void *userdata, uint32_t *free_slots)
 {
-    if (!m->friendlist[friendnumber].num_sending_files) {
-        return;
-    }
+    Friend *const friendcon = &m->friendlist[friendnumber];
+    uint32_t num = friendcon->num_sending_files;
 
-    int free_slots = crypto_num_free_sendqueue_slots(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
-                     m->friendlist[friendnumber].friendcon_id));
-
-    if (free_slots < MIN_SLOTS_FREE) {
-        free_slots = 0;
-    } else {
-        free_slots -= MIN_SLOTS_FREE;
-    }
+    bool any_active_fts = false;
 
-    unsigned int i, num = m->friendlist[friendnumber].num_sending_files;
-
-    for (i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
-        struct File_Transfers *ft = &m->friendlist[friendnumber].file_sending[i];
+    // Iterate over all file transfers, including inactive ones. I.e. we always
+    // iterate exactly MAX_CONCURRENT_FILE_PIPES times.
+    for (uint32_t i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
+        struct File_Transfers *const ft = &friendcon->file_sending[i];
 
+        // Any status other than NONE means the file transfer is active.
         if (ft->status != FILESTATUS_NONE) {
+            any_active_fts = true;
             --num;
 
-            if (ft->status == FILESTATUS_FINISHED) {
-                /* Check if file was entirely sent. */
-                if (friend_received_packet(m, friendnumber, ft->last_packet_number) == 0) {
-                    if (m->file_reqchunk) {
-                        (*m->file_reqchunk)(m, friendnumber, i, ft->transferred, 0, userdata);
-                    }
-
-                    ft->status = FILESTATUS_NONE;
-                    --m->friendlist[friendnumber].num_sending_files;
+            // If the file transfer is complete, we request a chunk of size 0.
+            if (ft->status == FILESTATUS_FINISHED && friend_received_packet(m, friendnumber, ft->last_packet_number) == 0) {
+                if (m->file_reqchunk) {
+                    m->file_reqchunk(m, friendnumber, i, ft->transferred, 0, userdata);
                 }
-            }
 
-            /* TODO(irungentoo): if file is too slow, switch to the next. */
-            if (ft->slots_allocated > (unsigned int)free_slots) {
-                free_slots = 0;
-            } else {
-                free_slots -= ft->slots_allocated;
+                // Now it's inactive, we're no longer sending this.
+                ft->status = FILESTATUS_NONE;
+                --friendcon->num_sending_files;
             }
+
+            // Decrease free slots by the number of slots this FT uses.
+            *free_slots = max_s32(0, (int32_t) * free_slots - ft->slots_allocated);
         }
 
-        while (ft->status == FILESTATUS_TRANSFERRING && (ft->paused == FILE_PAUSE_NOT)) {
-            if (max_speed_reached(m->net_crypto, friend_connection_crypt_connection_id(m->fr_c,
-                                  m->friendlist[friendnumber].friendcon_id))) {
-                free_slots = 0;
+        if (ft->status == FILESTATUS_TRANSFERRING && ft->paused == FILE_PAUSE_NOT) {
+            if (max_speed_reached(m->net_crypto, friend_connection_crypt_connection_id(
+                                      m->fr_c, friendcon->friendcon_id))) {
+                *free_slots = 0;
             }
 
-            if (free_slots == 0) {
-                break;
+            if (*free_slots == 0) {
+                continue;
             }
 
-            uint16_t length = MAX_FILE_DATA_SIZE;
-
             if (ft->size == 0) {
                 /* Send 0 data to friend if file is 0 length. */
                 file_data(m, friendnumber, i, 0, nullptr, 0);
-                break;
+                continue;
             }
 
             if (ft->size == ft->requested) {
-                break;
-            }
-
-            if (ft->size - ft->requested < length) {
-                length = ft->size - ft->requested;
+                // This file transfer is done.
+                continue;
             }
 
-            ++ft->slots_allocated;
+            // Allocate 1 slot to this file transfer.
+            ft->slots_allocated++;
 
-            uint64_t position = ft->requested;
+            const uint16_t length = min_u64(ft->size - ft->requested, MAX_FILE_DATA_SIZE);
+            const uint64_t position = ft->requested;
             ft->requested += length;
 
             if (m->file_reqchunk) {
-                (*m->file_reqchunk)(m, friendnumber, i, position, length, userdata);
+                m->file_reqchunk(m, friendnumber, i, position, length, userdata);
             }
 
-            --free_slots;
+            // The allocated slot is no longer free.
+            --*free_slots;
         }
 
         if (num == 0) {
-            break;
+            continue;
         }
     }
+
+    return any_active_fts;
 }
 
+static void do_reqchunk_filecb(Messenger *m, int32_t friendnumber, void *userdata)
+{
+    // We're not currently doing any file transfers.
+    if (m->friendlist[friendnumber].num_sending_files == 0) {
+        return;
+    }
+
+    // The number of packet slots left in the sendbuffer.
+    // This is a per friend count (CRYPTO_PACKET_BUFFER_SIZE).
+    uint32_t free_slots = crypto_num_free_sendqueue_slots(
+                              m->net_crypto,
+                              friend_connection_crypt_connection_id(
+                                  m->fr_c,
+                                  m->friendlist[friendnumber].friendcon_id));
+
+    // We keep MIN_SLOTS_FREE slots free for other packets, otherwise file
+    // transfers might block other traffic for a long time.
+    free_slots = max_s32(0, (int32_t)free_slots - MIN_SLOTS_FREE);
+
+    bool any_active_fts = true;
+    uint32_t loop_counter = 0;
+    // Maximum number of outer loops below. If the client doesn't send file
+    // chunks from within the chunk request callback handler, we never realise
+    // that the file transfer has finished and may end up in an infinite loop.
+    //
+    // TODO(zoff99): Fix this to exit the loop properly when we're done
+    // requesting all chunks for all file transfers.
+    const uint32_t MAX_FT_LOOPS = 4;
+
+    while (((free_slots > 0) || loop_counter == 0) && any_active_fts && (loop_counter < MAX_FT_LOOPS)) {
+        any_active_fts = do_all_filetransfers(m, friendnumber, userdata, &free_slots);
+        loop_counter++;
+    }
+}
+
+
 /* Run this when the friend disconnects.
  *  Kill all current file transfers.
  */
 static void break_files(const Messenger *m, int32_t friendnumber)
 {
-    uint32_t i;
-
     // TODO(irungentoo): Inform the client which file transfers get killed with a callback?
-    for (i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
+    for (uint32_t i = 0; i < MAX_CONCURRENT_FILE_PIPES; ++i) {
         if (m->friendlist[friendnumber].file_sending[i].status != FILESTATUS_NONE) {
             m->friendlist[friendnumber].file_sending[i].status = FILESTATUS_NONE;
         }
diff --git a/toxcore/Messenger.h b/toxcore/Messenger.h
index 6bf1bce8..956f8ac5 100644
--- a/toxcore/Messenger.h
+++ b/toxcore/Messenger.h
@@ -206,7 +206,7 @@ typedef struct {
     uint64_t last_seen_time;
     uint8_t last_connection_udp_tcp;
     struct File_Transfers file_sending[MAX_CONCURRENT_FILE_PIPES];
-    unsigned int num_sending_files;
+    uint32_t num_sending_files;
     struct File_Transfers file_receiving[MAX_CONCURRENT_FILE_PIPES];
 
     struct {
diff --git a/toxcore/util.c b/toxcore/util.c
index ff612b1a..e19808a2 100644
--- a/toxcore/util.c
+++ b/toxcore/util.c
@@ -195,3 +195,13 @@ int create_recursive_mutex(pthread_mutex_t *mutex)
 
     return 0;
 }
+
+int32_t max_s32(int32_t a, int32_t b)
+{
+    return a > b ? a : b;
+}
+
+uint64_t min_u64(uint64_t a, uint64_t b)
+{
+    return a < b ? a : b;
+}
diff --git a/toxcore/util.h b/toxcore/util.h
index 8c86158b..a9faa863 100644
--- a/toxcore/util.h
+++ b/toxcore/util.h
@@ -65,6 +65,9 @@ int load_state(load_state_callback_func load_state_callback, Logger *log, void *
 /* Returns -1 if failed or 0 if success */
 int create_recursive_mutex(pthread_mutex_t *mutex);
 
+int32_t max_s32(int32_t a, int32_t b);
+uint64_t min_u64(uint64_t a, uint64_t b);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif