Squashed 'external/toxcore/c-toxcore/' changes from 1828c5356..c9cdae001

c9cdae001 fix(toxav): remove extra copy of video frame on encode
4f6d4546b test: Improve the fake network library.
a2581e700 refactor(toxcore): generate `Friend_Request` and `Dht_Nodes_Response`
2aaa11770 refactor(toxcore): use Tox_Memory in generated events
5c367452b test(toxcore): fix incorrect mutex in tox_scenario_get_time
8f92e710f perf: Add a timed limit of number of cookie requests.
695b6417a test: Add some more simulated network support.
815ae9ce9 test(toxcore): fix thread-safety in scenario framework
6d85c754e test(toxcore): add unit tests for net_crypto
9c22e79cc test(support): add SimulatedEnvironment for deterministic testing
f34fcb195 chore: Update windows Dockerfile to debian stable (trixie).
ece0e8980 fix(group_moderation): allow validating unsorted sanction list signatures
a4fa754d7 refactor: rename struct Packet to struct Net_Packet
d6f330f85 cleanup: Fix some warnings from coverity.
e206bffa2 fix(group_chats): fix sync packets reverting topics
0e4715598 test: Add new scenario testing framework.
668291f44 refactor(toxcore): decouple Network_Funcs from sockaddr via IP_Port
fc4396cef fix: potential division by zero in toxav and unsafe hex parsing
8e8b352ab refactor: Add nullable annotations to struct members.
7740bb421 refactor: decouple net_crypto from DHT
1936d4296 test: add benchmark for toxav audio and video
46bfdc2df fix: correct printf format specifiers for unsigned integers
REVERT: 1828c5356 fix(toxav): remove extra copy of video frame on encode

git-subtree-dir: external/toxcore/c-toxcore
git-subtree-split: c9cdae001341e701fca980c9bb9febfeb95d2902

auto_tests/scenarios/scenario_conference_test.c

@@ -0,0 +1,148 @@
+#include "framework/framework.h"
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define NUM_PEERS 16
+#define GROUP_MESSAGE "Install Gentoo"
+
+typedef struct {
+    bool joined;
+    bool connected;
+    uint32_t conference;
+    uint32_t peer_count;
+    uint32_t messages_received;
+} PeerState;
+
+static void on_conference_invite(const Tox_Event_Conference_Invite *event, void *user_data)
+{
+    ToxNode *self = (ToxNode *)user_data;
+    PeerState *state = (PeerState *)tox_node_get_script_ctx(self);
+
+    state->conference = tox_conference_join(tox_node_get_tox(self),
+                                            tox_event_conference_invite_get_friend_number(event),
+                                            tox_event_conference_invite_get_cookie(event),
+                                            tox_event_conference_invite_get_cookie_length(event),
+                                            nullptr);
+    tox_node_log(self, "Joined conference %u", state->conference);
+    state->joined = true;
+}
+
+static void on_conference_connected(const Tox_Event_Conference_Connected *event, void *user_data)
+{
+    ToxNode *self = (ToxNode *)user_data;
+    PeerState *state = (PeerState *)tox_node_get_script_ctx(self);
+    state->connected = true;
+    tox_node_log(self, "Connected to conference %u", tox_event_conference_connected_get_conference_number(event));
+}
+
+static void on_peer_list_changed(const Tox_Event_Conference_Peer_List_Changed *event, void *user_data)
+{
+    ToxNode *self = (ToxNode *)user_data;
+    PeerState *state = (PeerState *)tox_node_get_script_ctx(self);
+    state->peer_count = tox_conference_peer_count(tox_node_get_tox(self), tox_event_conference_peer_list_changed_get_conference_number(event), nullptr);
+    tox_node_log(self, "Peer count changed: %u", state->peer_count);
+}
+
+static void on_conference_message(const Tox_Event_Conference_Message *event, void *user_data)
+{
+    ToxNode *self = (ToxNode *)user_data;
+    PeerState *state = (PeerState *)tox_node_get_script_ctx(self);
+    const uint8_t *msg = tox_event_conference_message_get_message(event);
+    if (memcmp(msg, GROUP_MESSAGE, sizeof(GROUP_MESSAGE) - 1) == 0) {
+        state->messages_received++;
+        tox_node_log(self, "Received message %u", state->messages_received);
+    }
+}
+
+static void peer_script(ToxNode *self, void *ctx)
+{
+    Tox *tox = tox_node_get_tox(self);
+    PeerState *state = (PeerState *)ctx;
+    uint32_t my_index = tox_node_get_index(self);
+
+    tox_events_callback_conference_invite(tox_node_get_dispatch(self), on_conference_invite);
+    tox_events_callback_conference_connected(tox_node_get_dispatch(self), on_conference_connected);
+    tox_events_callback_conference_peer_list_changed(tox_node_get_dispatch(self), on_peer_list_changed);
+    tox_events_callback_conference_message(tox_node_get_dispatch(self), on_conference_message);
+
+    WAIT_UNTIL(tox_node_is_self_connected(self));
+    tox_node_log(self, "Self connected");
+
+    // Founder (Node 0) creates group
+    if (my_index == 0) {
+        state->conference = tox_conference_new(tox, nullptr);
+        tox_node_log(self, "Created conference %u", state->conference);
+        state->joined = true;
+        state->connected = true;
+
+        // Invite friend 0 (Node 1)
+        WAIT_UNTIL(tox_node_is_friend_connected(self, 0));
+        tox_node_log(self, "Friend 0 (Node 1) connected, inviting...");
+        tox_conference_invite(tox, 0, state->conference, nullptr);
+    } else {
+        WAIT_UNTIL(state->joined);
+        WAIT_UNTIL(state->connected);
+
+        // Invite next friends if any
+        // In linear topology, each node has 2 friends (except ends)
+        // We invite friend 1 (the next node in line)
+        if (my_index < NUM_PEERS - 1) {
+            WAIT_UNTIL(tox_node_is_friend_connected(self, 1));
+            tox_node_log(self, "Friend 1 (Node %u) connected, inviting...", my_index + 1);
+            Tox_Err_Conference_Invite err;
+            if (!tox_conference_invite(tox, 1, state->conference, &err)) {
+                tox_node_log(self, "Failed to invite Node %u: %u", my_index + 1, err);
+            }
+        }
+    }
+
+    // Wait for all to join
+    WAIT_UNTIL(state->peer_count == NUM_PEERS);
+    tox_node_log(self, "All peers joined");
+
+    // One peer sends a message
+    if (my_index == 0) {
+        tox_node_log(self, "Sending message");
+        tox_conference_send_message(tox, state->conference, TOX_MESSAGE_TYPE_NORMAL, (const uint8_t *)GROUP_MESSAGE, sizeof(GROUP_MESSAGE) - 1, nullptr);
+    }
+
+    // Wait for message propagation
+    WAIT_UNTIL(state->messages_received > 0);
+    tox_node_log(self, "Done");
+}
+
+int main(int argc, char *argv[])
+{
+    ToxScenario *s = tox_scenario_new(argc, argv, 300000);
+    PeerState states[NUM_PEERS] = {0};
+
+    ToxNode *nodes[NUM_PEERS];
+    for (int i = 0; i < NUM_PEERS; ++i) {
+        char alias[16];
+        snprintf(alias, sizeof(alias), "Peer%d", i);
+        nodes[i] = tox_scenario_add_node(s, alias, peer_script, &states[i], sizeof(PeerState));
+    }
+
+    // Linear topology
+    for (int i = 0; i < NUM_PEERS; ++i) {
+        if (i > 0) {
+            tox_node_friend_add(nodes[i], nodes[i - 1]);
+            tox_node_bootstrap(nodes[i], nodes[i - 1]);
+        }
+        if (i < NUM_PEERS - 1) {
+            tox_node_friend_add(nodes[i], nodes[i + 1]);
+        }
+    }
+
+    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 NUM_PEERS