test(TCP): Add regression test for TCP priority queue integrity.

This test ensures that multiple priority packets added to a
`TCP_Connection` while the socket is busy are correctly queued in the
linked list without dropping intermediate packets.

Specifically, it protects against regressions where updating the tail
pointer incorrectly (e.g., using the head pointer as a base for append)
would result in data loss. This was identified as a risk in PR TokTok#2387.

Author: iphydf

toxcore/BUILD.bazel

@@ -911,6 +911,21 @@ cc_test(
     ],
 )
 
+cc_test(
+    name = "TCP_common_test",
+    size = "small",
+    srcs = ["TCP_common_test.cc"],
+    deps = [
+        ":TCP_common",
+        ":crypto_core",
+        ":logger",
+        ":os_memory",
+        ":os_random",
+        "@com_google_googletest//:gtest",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
 cc_library(
     name = "net_crypto",
     srcs = ["net_crypto.c"],

toxcore/TCP_common.h

@@ -18,6 +18,10 @@
 #include "network.h"
 #include "rng.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef struct TCP_Priority_List TCP_Priority_List;
 struct TCP_Priority_List {
     TCP_Priority_List *_Nullable next;
@@ -114,4 +118,8 @@ int read_tcp_packet(const Logger *_Nonnull logger, const Memory *_Nonnull mem, c
 int read_packet_tcp_secure_connection(const Logger *_Nonnull logger, const Memory *_Nonnull mem, const Network *_Nonnull ns, Socket sock, uint16_t *_Nonnull next_packet_length,
                                       const uint8_t *_Nonnull shared_key, uint8_t *_Nonnull recv_nonce, uint8_t *_Nonnull data, uint16_t max_len, const IP_Port *_Nonnull ip_port);
 
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
 #endif /* C_TOXCORE_TOXCORE_TCP_COMMON_H */

toxcore/TCP_common_test.cc

@@ -0,0 +1,101 @@
+#include "TCP_common.h"
+
+#include <gtest/gtest.h>
+
+#include "logger.h"
+#include "os_memory.h"
+#include "os_random.h"
+
+namespace {
+
+// Mock net_send to simulate a full buffer (returns 0)
+// This forces packets into the priority queue.
+int mock_send(void *obj, Socket sock, const uint8_t *buf, size_t len)
+{
+    (void)obj;
+    (void)sock;
+    (void)buf;
+    (void)len;
+    return 0;
+}
+
+const Network_Funcs mock_funcs = {
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    mock_send,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+};
+
+TEST(TCP_common, PriorityQueueOrderingAndIntegrity)
+{
+    TCP_Connection con;
+    memset(&con, 0, sizeof(con));
+    con.mem = os_memory();
+    con.rng = os_random();
+    Network ns = {&mock_funcs, nullptr};
+    con.ns = &ns;
+
+    Logger *logger = logger_new(con.mem);
+    ASSERT_NE(logger, nullptr);
+
+    // Minimal initialization to make write_packet_tcp_secure_connection happy
+    // It calls encrypt_data_symmetric which needs shared_key and sent_nonce
+    memset(con.shared_key, 0x42, sizeof(con.shared_key));
+    memset(con.sent_nonce, 0x12, sizeof(con.sent_nonce));
+
+    uint8_t data1[] = "packet1";
+    uint8_t data2[] = "packet2";
+    uint8_t data3[] = "packet3";
+
+    // First packet: will fail net_send (mocked to 0) and go to add_priority
+    // Queue: [packet1]
+    int ret1 = write_packet_tcp_secure_connection(logger, &con, data1, sizeof(data1), true);
+    ASSERT_EQ(ret1, 1);
+    ASSERT_NE(con.priority_queue_start, nullptr);
+    ASSERT_EQ(con.priority_queue_start, con.priority_queue_end);
+
+    // Second packet: will go to add_priority
+    // Queue: [packet1] -> [packet2]
+    int ret2 = write_packet_tcp_secure_connection(logger, &con, data2, sizeof(data2), true);
+    ASSERT_EQ(ret2, 1);
+    ASSERT_NE(con.priority_queue_start->next, nullptr);
+    ASSERT_EQ(con.priority_queue_start->next, con.priority_queue_end);
+
+    // Third packet: will go to add_priority
+    // WITH BUG: Queue becomes [packet1] -> [packet3], packet2 is LOST
+    // WITHOUT BUG: Queue: [packet1] -> [packet2] -> [packet3]
+    int ret3 = write_packet_tcp_secure_connection(logger, &con, data3, sizeof(data3), true);
+    ASSERT_EQ(ret3, 1);
+
+    // Verify integrity
+    TCP_Priority_List *p = con.priority_queue_start;
+    int count = 0;
+    while (p) {
+        count++;
+        p = p->next;
+    }
+
+    // This is where it will fail if the change in
+    // https://github.com/TokTok/c-toxcore/pull/2387 is applied.
+    // The count will be 2 instead of 3.
+    EXPECT_EQ(count, 3)
+        << "Priority queue lost packets! (likely due to incorrect tail pointer usage)";
+
+    // Clean up
+    wipe_priority_list(con.mem, con.priority_queue_start);
+    logger_kill(logger);
+}
+
+}