Green-Sky/tomato
1
0
Fork 1
Code Issues Pull Requests 1 Actions Packages Projects Releases 1 Wiki Activity

Squashed 'external/toxcore/c-toxcore/' changes from c9cdae001..9ed2fa80d

Browse Source 
9ed2fa80d fix(toxav): remove extra copy of video frame on encode
de30cf3ad docs: Add new file kinds, that should be useful to all clients.
d5b5e879d fix(DHT): Correct node skipping logic timed out nodes.
30e71fe97 refactor: Generate event dispatch functions and add tox_events_dispatch.
8fdbb0b50 style: Format parameter lists in event handlers.
d00dee12b refactor: Add warning logs when losing chat invites.
b144e8db1 feat: Add a way to look up a file number by ID.
849281ea0 feat: Add a way to fetch groups by chat ID.
a2c177396 refactor: Harden event system and improve type safety.
8f5caa656 refactor: Add MessagePack string support to bin_pack.
34e8d5ad5 chore: Add GitHub CodeQL workflow and local Docker runner.
f7b068010 refactor: Add nullability annotations to event headers.
788abe651 refactor(toxav): Use system allocator for mutexes.
2e4b423eb refactor: Use specific typedefs for public API arrays.
2baf34775 docs(toxav): update idle iteration interval see 679444751876fa3882a717772918ebdc8f083354
2f87ac67b feat: Add Event Loop abstraction (Ev).
f8dfc38d8 test: Fix data race in ToxScenario virtual_clock.
38313921e test(TCP): Add regression test for TCP priority queue integrity.
f94a50d9a refactor(toxav): Replace mutable_mutex with dynamically allocated mutex.
ad054511e refactor: Internalize DHT structs and add debug helpers.
8b467cc96 fix: Prevent potential integer overflow in group chat handshake.
4962bdbb8 test: Improve TCP simulation and add tests
5f0227093 refactor: Allow nullable data in group chat handlers.
e97b18ea9 chore: Improve Windows Docker support.
b14943bbd refactor: Move Logger out of Messenger into Tox.
dd3136250 cleanup: Apply nullability qualifiers to C++ codebase.
1849f70fc refactor: Extract low-level networking code to net and os_network.
8fec75421 refactor: Delete tox_random, align on rng and os_random.
a03ae8051 refactor: Delete tox_memory, align on mem and os_memory.
4c88fed2c refactor: Use `std::` prefixes more consistently in C++ code.
72452f2ae test: Add some more tests for onion and shared key cache.
d5a51b09a cleanup: Use tox_attributes.h in tox_private.h and install it.
b6f5b9fc5 test: Add some benchmarks for various high level things.
8a8d02785 test(support): Introduce threaded Tox runner and simulation barrier
d68d1d095 perf(toxav): optimize audio and video intermediate buffers by keeping them around
REVERT: c9cdae001 fix(toxav): remove extra copy of video frame on encode

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: 9ed2fa80d582c714d6bdde6a7648220a92cddff8
This commit is contained in:
Green Sky
2026-02-01 14:26:52 +01:00
parent 565efa4f39
commit 9b36dd9d99
274 changed files with 11891 additions and 4292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

273
testing/support/tox_network_test.cc
View File

@@ -6,6 +6,13 @@
#include <gtest/gtest.h>
#include <atomic>
#include <iomanip>
#include <sstream>
#include "../../toxcore/attributes.h"
#include "../../toxcore/network.h"
namespace tox::test {
namespace {
@@ -22,6 +29,8 @@ namespace {
ASSERT_EQ(friends.size(), num_friends);
// Verification of connection status is done inside setup_connected_friends now,
// but we can double check main_tox's view.
for (const auto &f : friends) {
EXPECT_NE(tox_friend_get_connection_status(main_tox.get(), f.friend_number, nullptr),
TOX_CONNECTION_NONE);
@@ -29,25 +38,22 @@ namespace {
// Verify they can actually communicate
struct Context {
int count = 0;
std::atomic<int> count{0};
} ctx;
tox_callback_friend_message(main_tox.get(),
[](Tox *, uint32_t, Tox_Message_Type, const uint8_t *, size_t, void *user_data) {
static_cast<Context *>(user_data)->count++;
});
[](Tox *_Nonnull, uint32_t, Tox_Message_Type, const uint8_t *_Nonnull, size_t,
void *_Nullable user_data) { static_cast<Context *>(user_data)->count++; });
for (const auto &f : friends) {
const uint8_t msg[] = "hello";
tox_friend_send_message(
f.tox.get(), 0, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), nullptr);
f.runner->execute([](Tox *tox) {
const uint8_t msg[] = "hello";
tox_friend_send_message(tox, 0, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), nullptr);
});
}
sim.run_until([&]() {
tox_iterate(main_tox.get(), &ctx);
for (auto &f : friends) {
tox_iterate(f.tox.get(), nullptr);
}
return ctx.count == num_friends;
});
@@ -68,26 +74,23 @@ namespace {
ASSERT_EQ(friends.size(), num_friends);
struct Context {
int count = 0;
std::atomic<int> count{0};
} ctx;
tox_callback_friend_message(main_tox.get(),
[](Tox *, uint32_t, Tox_Message_Type, const uint8_t *, size_t, void *user_data) {
static_cast<Context *>(user_data)->count++;
});
[](Tox *_Nonnull, uint32_t, Tox_Message_Type, const uint8_t *_Nonnull, size_t,
void *_Nullable user_data) { static_cast<Context *>(user_data)->count++; });
for (const auto &f : friends) {
const uint8_t msg[] = "hello";
tox_friend_send_message(
f.tox.get(), 0, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), nullptr);
f.runner->execute([](Tox *tox) {
const uint8_t msg[] = "hello";
tox_friend_send_message(tox, 0, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), nullptr);
});
}
sim.run_until(
[&]() {
tox_iterate(main_tox.get(), &ctx);
for (auto &f : friends) {
tox_iterate(f.tox.get(), nullptr);
}
return ctx.count == num_friends;
},
60000);
@@ -113,10 +116,11 @@ namespace {
EXPECT_NE(tox_friend_get_connection_status(tox2.get(), 0, nullptr), TOX_CONNECTION_NONE);
// Verify communication
bool received = false;
std::atomic<bool> received{false};
tox_callback_friend_message(tox2.get(),
[](Tox *, uint32_t, Tox_Message_Type, const uint8_t *, size_t, void *user_data) {
*static_cast<bool *>(user_data) = true;
[](Tox *_Nonnull, uint32_t, Tox_Message_Type, const uint8_t *_Nonnull, size_t,
void *_Nullable user_data) {
*static_cast<std::atomic<bool> *>(user_data) = true;
});
const uint8_t msg[] = "hello";
@@ -125,7 +129,7 @@ namespace {
sim.run_until([&]() {
tox_iterate(tox1.get(), nullptr);
tox_iterate(tox2.get(), &received);
return received;
return received.load();
});
EXPECT_TRUE(received);
@@ -148,28 +152,27 @@ namespace {
// Verify we can send a group message
struct Context {
int count = 0;
std::atomic<int> count{0};
} ctx;
tox_callback_group_message(main_tox.get(),
[](Tox *, uint32_t, uint32_t, Tox_Message_Type, const uint8_t *, size_t, uint32_t,
void *user_data) { static_cast<Context *>(user_data)->count++; });
[](Tox *_Nonnull, uint32_t, uint32_t, Tox_Message_Type, const uint8_t *_Nonnull, size_t,
uint32_t,
void *_Nullable user_data) { static_cast<Context *>(user_data)->count++; });
for (const auto &f : friends) {
const uint8_t msg[] = "hello";
uint32_t f_gn = 0; // It should be 0 since it's the first group.
Tox_Err_Group_Send_Message err_send;
tox_group_send_message(
f.tox.get(), f_gn, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), &err_send);
EXPECT_EQ(err_send, TOX_ERR_GROUP_SEND_MESSAGE_OK);
f.runner->execute([](Tox *tox) {
const uint8_t msg[] = "hello";
uint32_t f_gn = 0; // First group
Tox_Err_Group_Send_Message err_send;
tox_group_send_message(
tox, f_gn, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), &err_send);
});
}
sim.run_until(
[&]() {
tox_iterate(main_tox.get(), &ctx);
for (auto &f : friends) {
tox_iterate(f.tox.get(), nullptr);
}
return ctx.count == num_friends;
},
10000);
@@ -193,28 +196,27 @@ namespace {
EXPECT_NE(group_number, UINT32_MAX);
struct Context {
int count = 0;
std::atomic<int> count{0};
} ctx;
tox_callback_group_message(main_tox.get(),
[](Tox *, uint32_t, uint32_t, Tox_Message_Type, const uint8_t *, size_t, uint32_t,
void *user_data) { static_cast<Context *>(user_data)->count++; });
[](Tox *_Nonnull, uint32_t, uint32_t, Tox_Message_Type, const uint8_t *_Nonnull, size_t,
uint32_t,
void *_Nullable user_data) { static_cast<Context *>(user_data)->count++; });
for (const auto &f : friends) {
const uint8_t msg[] = "hello";
uint32_t f_gn = 0;
Tox_Err_Group_Send_Message err_send;
tox_group_send_message(
f.tox.get(), f_gn, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), &err_send);
EXPECT_EQ(err_send, TOX_ERR_GROUP_SEND_MESSAGE_OK);
f.runner->execute([](Tox *tox) {
const uint8_t msg[] = "hello";
uint32_t f_gn = 0;
Tox_Err_Group_Send_Message err_send;
tox_group_send_message(
tox, f_gn, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), &err_send);
});
}
sim.run_until(
[&]() {
tox_iterate(main_tox.get(), &ctx);
for (auto &f : friends) {
tox_iterate(f.tox.get(), nullptr);
}
return ctx.count == num_friends;
},
120000);
@@ -222,5 +224,180 @@ namespace {
EXPECT_EQ(ctx.count, num_friends);
}
TEST(ToxNetworkTest, TcpRelayChaining)
{
constexpr bool kDebug = false;
Simulation sim;
sim.net().set_verbose(false);
if (kDebug) {
using namespace log_filter;
sim.set_log_filter(level(TOX_LOG_LEVEL_DEBUG)
|| (level(TOX_LOG_LEVEL_TRACE)
&& (file("TCP") || file("onion.c") || func("dht_isconnected"))
&& !message("not sending repeated announce request")));
}
struct ToxOptionsDeleter {
void operator()(Tox_Options *opts) { tox_options_free(opts); }
};
std::unique_ptr<Tox_Options, ToxOptionsDeleter> opts(tox_options_new(nullptr));
tox_options_set_udp_enabled(opts.get(), false);
tox_options_set_ipv6_enabled(opts.get(), false);
tox_options_set_local_discovery_enabled(opts.get(), false);
auto create = [&](const char *name, uint16_t port, bool udp_enabled = false) {
tox_options_set_tcp_port(opts.get(), port);
if (udp_enabled) {
tox_options_set_start_port(opts.get(), port);
tox_options_set_end_port(opts.get(), port);
}
tox_options_set_udp_enabled(opts.get(), udp_enabled);
auto node = sim.create_node();
auto tox = node->create_tox(opts.get());
if (!tox) {
std::cerr << "Failed to create node " << name << " on port " << port << std::endl;
std::abort();
}
return std::make_pair(std::move(node), std::move(tox));
};
// Servers (Enable UDP for relays so they can talk to each other)
auto [nodeA, toxA] = create("A", 20001, true);
auto [nodeB, toxB] = create("B", 20002, true);
// Clients
auto [nodeC, toxC] = create("C", 0);
auto [nodeD, toxD] = create("D", 0);
auto [nodeE, toxE] = create("E", 0);
auto [nodeF, toxF] = create("F", 0);
auto get_info = [](SimulatedNode &node, Tox *tox) {
uint8_t pk[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(tox, pk);
uint8_t dht_id[TOX_PUBLIC_KEY_SIZE];
tox_self_get_dht_id(tox, dht_id);
char ip[TOX_INET_ADDRSTRLEN];
ip_parse_addr(&node.ip, ip, sizeof(ip));
uint16_t port = tox_self_get_tcp_port(tox, nullptr);
if (kDebug) {
std::cout << "Node Info: IP=" << ip << " Port=" << port << std::endl;
auto to_hex = [](const uint8_t *data) {
std::stringstream ss;
ss << std::hex << std::setfill('0');
for (int i = 0; i < TOX_PUBLIC_KEY_SIZE; ++i)
ss << std::setw(2) << static_cast<int>(data[i]);
return ss.str();
};
std::cout << "PK: " << to_hex(pk) << std::endl;
std::cout << "DHT ID: " << to_hex(dht_id) << std::endl;
}
return std::make_tuple(std::vector<uint8_t>(pk, pk + TOX_PUBLIC_KEY_SIZE),
std::vector<uint8_t>(dht_id, dht_id + TOX_PUBLIC_KEY_SIZE), std::string(ip), port);
};
auto [pkA, dhtIdA, ipA, portA] = get_info(*nodeA, toxA.get());
auto [pkB, dhtIdB, ipB, portB] = get_info(*nodeB, toxB.get());
// Helper to connect to a relay (bootstrap + add_tcp_relay)
auto connect_to_relay
= [](Tox *tox, const std::string &ip, uint16_t port, const std::vector<uint8_t> &pk,
const std::vector<uint8_t> &dht_id) {
Tox_Err_Bootstrap err_bs;
tox_bootstrap(tox, ip.c_str(), port, dht_id.data(), &err_bs);
if (err_bs != TOX_ERR_BOOTSTRAP_OK) {
std::cout << "tox_bootstrap failed with " << err_bs << " for " << ip << ":"
<< port << std::endl;
}
Tox_Err_Bootstrap err_relay;
// Use dht_id for TCP relay as well, as server uses DHT key
tox_add_tcp_relay(tox, ip.c_str(), port, dht_id.data(), &err_relay);
if (err_relay != TOX_ERR_BOOTSTRAP_OK) {
std::cout << "tox_add_tcp_relay failed with " << err_relay << " for " << ip
<< ":" << port << std::endl;
}
};
// Connect {C,D} -> A, {E,F} -> B
connect_to_relay(toxC.get(), ipA, portA, pkA, dhtIdA);
connect_to_relay(toxD.get(), ipA, portA, pkA, dhtIdA);
connect_to_relay(toxE.get(), ipB, portB, pkB, dhtIdB);
connect_to_relay(toxF.get(), ipB, portB, pkB, dhtIdB);
// B -> A (Connect the two TCP relays, but only one initial link)
connect_to_relay(toxB.get(), ipA, portA, pkA, dhtIdA);
// Connect C and F
uint8_t pkF[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(toxF.get(), pkF);
uint8_t pkC[TOX_PUBLIC_KEY_SIZE];
tox_self_get_public_key(toxC.get(), pkC);
Tox_Err_Friend_Add err;
const uint32_t fC = tox_friend_add_norequest(toxC.get(), pkF, &err);
ASSERT_EQ(err, TOX_ERR_FRIEND_ADD_OK);
const uint32_t fF = tox_friend_add_norequest(toxF.get(), pkC, &err);
ASSERT_EQ(err, TOX_ERR_FRIEND_ADD_OK);
struct Context {
bool received = false;
} ctx;
tox_callback_friend_message(toxF.get(),
[](Tox *, uint32_t, Tox_Message_Type, const uint8_t *, size_t, void *user_data) {
static_cast<Context *>(user_data)->received = true;
});
bool sent = false;
sim.run_until(
[&]() {
tox_iterate(toxA.get(), nullptr);
tox_iterate(toxB.get(), nullptr);
tox_iterate(toxC.get(), nullptr);
tox_iterate(toxD.get(), nullptr);
tox_iterate(toxE.get(), nullptr);
tox_iterate(toxF.get(), &ctx);
Tox_Connection statusC = tox_friend_get_connection_status(toxC.get(), fC, nullptr);
Tox_Connection statusF = tox_friend_get_connection_status(toxF.get(), fF, nullptr);
if (kDebug) {
static int loop_counter = 0;
if (loop_counter++ % 100 == 0) {
std::cout << "Conn Status: "
<< "A=" << tox_self_get_connection_status(toxA.get()) << " "
<< "B=" << tox_self_get_connection_status(toxB.get()) << " "
<< "C=" << tox_self_get_connection_status(toxC.get()) << " "
<< "D=" << tox_self_get_connection_status(toxC.get()) << " "
<< "E=" << tox_self_get_connection_status(toxC.get()) << " "
<< "F=" << tox_self_get_connection_status(toxF.get()) << " "
<< " Friend Status C->F: " << statusC << ", F->C: " << statusF
<< std::endl;
}
}
if (!sent && statusC != TOX_CONNECTION_NONE) {
const uint8_t msg[] = "hello";
Tox_Err_Friend_Send_Message send_err;
tox_friend_send_message(
toxC.get(), fC, TOX_MESSAGE_TYPE_NORMAL, msg, sizeof(msg), &send_err);
if (kDebug) {
std::cout << "Message sent from C to F, err=" << send_err << std::endl;
}
sent = true;
}
return ctx.received;
},
120000);
EXPECT_TRUE(ctx.received);
}
} // namespace
} // namespace tox::test