tomato/auto_tests/scenarios/scenario_file_transfer_test.c

#include "framework/framework.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define FILE_SIZE (1024 * 1024)
#define FILENAME "Gentoo.exe"

typedef struct {
    bool file_received;
    bool file_sending_done;
    uint64_t size_recv;
    uint64_t sending_pos;
    uint8_t file_id[TOX_FILE_ID_LENGTH];
    uint32_t file_accepted;
    uint64_t file_size;
    bool sendf_ok;
    uint8_t num;
    uint8_t sending_num;
    bool m_send_reached;
} FileTransferState;

static void on_file_receive(const Tox_Event_File_Recv *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    FileTransferState *state = (FileTransferState *)tox_node_get_script_ctx(self);

    const uint32_t friend_number = tox_event_file_recv_get_friend_number(event);
    const uint32_t file_number = tox_event_file_recv_get_file_number(event);
    const uint64_t filesize = tox_event_file_recv_get_file_size(event);

    state->file_size = filesize;
    state->sending_pos = state->size_recv = 0;

    Tox_Err_File_Control error;
    tox_file_control(tox_node_get_tox(self), friend_number, file_number, TOX_FILE_CONTROL_RESUME, &error);
    state->file_accepted++;
    tox_node_log(self, "File receive: %u bytes, accepted", (uint32_t)filesize);
}

static void on_file_recv_control(const Tox_Event_File_Recv_Control *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    FileTransferState *state = (FileTransferState *)tox_node_get_script_ctx(self);
    const Tox_File_Control control = tox_event_file_recv_control_get_control(event);

    if (control == TOX_FILE_CONTROL_RESUME) {
        state->sendf_ok = true;
        tox_node_log(self, "Received RESUME control");
    }
}

static void on_file_chunk_request(const Tox_Event_File_Chunk_Request *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    FileTransferState *state = (FileTransferState *)tox_node_get_script_ctx(self);

    const uint32_t friend_number = tox_event_file_chunk_request_get_friend_number(event);
    const uint32_t file_number = tox_event_file_chunk_request_get_file_number(event);
    const uint64_t position = tox_event_file_chunk_request_get_position(event);
    size_t length = tox_event_file_chunk_request_get_length(event);

    if (length == 0) {
        state->file_sending_done = true;
        tox_node_log(self, "File sending done");
        return;
    }

    uint8_t *f_data = (uint8_t *)malloc(length);
    memset(f_data, state->sending_num, length);

    tox_file_send_chunk(tox_node_get_tox(self), friend_number, file_number, position, f_data, length, nullptr);
    free(f_data);

    state->sending_num++;
    state->sending_pos += length;
}

static void on_file_recv_chunk(const Tox_Event_File_Recv_Chunk *event, void *user_data)
{
    ToxNode *self = (ToxNode *)user_data;
    FileTransferState *state = (FileTransferState *)tox_node_get_script_ctx(self);

    const size_t length = tox_event_file_recv_chunk_get_data_length(event);

    if (length == 0) {
        state->file_received = true;
        tox_node_log(self, "File reception done");
        return;
    }

    state->num++;
    state->size_recv += length;
}

static void sender_script(ToxNode *self, void *ctx)
{
    const FileTransferState *state = (const FileTransferState *)ctx;

    tox_events_callback_file_recv_control(tox_node_get_dispatch(self), on_file_recv_control);
    tox_events_callback_file_chunk_request(tox_node_get_dispatch(self), on_file_chunk_request);

    WAIT_UNTIL(tox_node_is_self_connected(self));
    WAIT_UNTIL(tox_node_is_friend_connected(self, 0));

    uint32_t fnum = tox_file_send(tox_node_get_tox(self), 0, TOX_FILE_KIND_DATA, FILE_SIZE, nullptr, (const uint8_t *)FILENAME, sizeof(FILENAME), nullptr);
    tox_node_log(self, "Started sending file %u", fnum);

    Tox_File_Id file_id;
    if (!tox_file_get_file_id(tox_node_get_tox(self), 0, fnum, file_id, nullptr)) {
        tox_node_log(self, "Failed to get file id for file %u", fnum);
        abort();
    }

    Tox_Err_File_By_Id err;
    Tox_File_Number found_fnum = tox_file_by_id(tox_node_get_tox(self), 0, file_id, &err);
    if (found_fnum != fnum) {
        tox_node_log(self, "tox_file_by_id failed: expected %u, got %u, error %u", fnum, found_fnum, err);
        abort();
    }

    /* Test with invalid friend number */
    found_fnum = tox_file_by_id(tox_node_get_tox(self), 1234, file_id, &err);
    if (found_fnum != UINT32_MAX || err != TOX_ERR_FILE_BY_ID_FRIEND_NOT_FOUND) {
        tox_node_log(self, "tox_file_by_id with invalid friend failed: expected UINT32_MAX and FRIEND_NOT_FOUND, got %u and error %u", found_fnum, err);
        abort();
    }

    /* Test with invalid file id */
    Tox_File_Id invalid_id = {0};
    found_fnum = tox_file_by_id(tox_node_get_tox(self), 0, invalid_id, &err);
    if (found_fnum != UINT32_MAX || err != TOX_ERR_FILE_BY_ID_NOT_FOUND) {
        tox_node_log(self, "tox_file_by_id with invalid id failed: expected UINT32_MAX and NOT_FOUND, got %u and error %u", found_fnum, err);
        abort();
    }

    WAIT_UNTIL(state->file_sending_done);
    tox_node_log(self, "Done");
}

static void receiver_script(ToxNode *self, void *ctx)
{
    const FileTransferState *state = (const FileTransferState *)ctx;

    tox_events_callback_file_recv(tox_node_get_dispatch(self), on_file_receive);
    tox_events_callback_file_recv_chunk(tox_node_get_dispatch(self), on_file_recv_chunk);

    WAIT_UNTIL(tox_node_is_self_connected(self));

    WAIT_UNTIL(state->file_received);
    tox_node_log(self, "Done");
}

int main(int argc, char *argv[])
{
    ToxScenario *s = tox_scenario_new(argc, argv, 300000);
    FileTransferState state_sender = {0};
    FileTransferState state_receiver = {0};

    ToxNode *sender = tox_scenario_add_node(s, "Sender", sender_script, &state_sender, sizeof(FileTransferState));
    ToxNode *receiver = tox_scenario_add_node(s, "Receiver", receiver_script, &state_receiver, sizeof(FileTransferState));

    tox_node_friend_add(sender, receiver);
    tox_node_friend_add(receiver, sender);
    tox_node_bootstrap(sender, receiver);
    tox_node_bootstrap(receiver, sender);

    ToxScenarioStatus res = tox_scenario_run(s);
    if (res != TOX_SCENARIO_DONE) {
        tox_scenario_log(s, "Test failed with status %u", res);
        return 1;
    }

    tox_scenario_free(s);
    return 0;
}

#undef FILE_SIZE