Use per-instance `Mono_Time` for Messenger and onion.

4 files changed, 170 insertions, 134 deletions

diff --git a/auto_tests/TCP_test.c b/auto_tests/TCP_test.c
index 52ecad77..3c5d56b9 100644
--- a/auto_tests/TCP_test.c
+++ b/auto_tests/TCP_test.c
@@ -36,17 +36,19 @@ static inline IP get_loopback()
     return ip;
 }
 
-static void do_TCP_server_delay(TCP_Server *tcp_s, int delay)
+static void do_TCP_server_delay(TCP_Server *tcp_s, Mono_Time *mono_time, int delay)
 {
     c_sleep(delay);
-    unix_time_update();
-    do_TCP_server(tcp_s);
+    mono_time_update(mono_time);
+    do_TCP_server(tcp_s, mono_time);
     c_sleep(delay);
 }
 static uint16_t ports[NUM_PORTS] = {13215, 33445, 25643};
 
 START_TEST(test_basic)
 {
+    Mono_Time *mono_time = mono_time_new();
+
     // Attempt to create a new TCP_Server instance.
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
@@ -99,12 +101,12 @@ START_TEST(test_basic)
     ck_assert_msg(net_send(sock, handshake, TCP_CLIENT_HANDSHAKE_SIZE - 1) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
                   "An attempt to send the initial handshake minus last byte failed.");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     ck_assert_msg(net_send(sock, handshake + (TCP_CLIENT_HANDSHAKE_SIZE - 1), 1) == 1,
                   "The attempt to send the last byte of handshake failed.");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     // Receiving server response and decrypting it
     uint8_t response[TCP_SERVER_HANDSHAKE_SIZE];
@@ -142,8 +144,8 @@ START_TEST(test_basic)
         i += msg_length;
 
         c_sleep(50);
-        unix_time_update();
-        do_TCP_server(tcp_s);
+        mono_time_update(mono_time);
+        do_TCP_server(tcp_s, mono_time);
     }
 
     // Receiving the second response and verifying its validity
@@ -167,6 +169,8 @@ START_TEST(test_basic)
     // Closing connections.
     kill_sock(sock);
     kill_TCP_server(tcp_s);
+
+    mono_time_free(mono_time);
 }
 END_TEST
 
@@ -178,7 +182,7 @@ struct sec_TCP_con {
     uint8_t shared_key[CRYPTO_SHARED_KEY_SIZE];
 };
 
-static struct sec_TCP_con *new_TCP_con(TCP_Server *tcp_s)
+static struct sec_TCP_con *new_TCP_con(TCP_Server *tcp_s, Mono_Time *mono_time)
 {
     struct sec_TCP_con *sec_c = (struct sec_TCP_con *)malloc(sizeof(struct sec_TCP_con));
     Socket sock = net_socket(net_family_ipv6, TOX_SOCK_STREAM, TOX_PROTO_TCP);
@@ -210,12 +214,12 @@ static struct sec_TCP_con *new_TCP_con(TCP_Server *tcp_s)
     ck_assert_msg(net_send(sock, handshake, TCP_CLIENT_HANDSHAKE_SIZE - 1) == TCP_CLIENT_HANDSHAKE_SIZE - 1,
                   "Failed to send the first portion of the handshake to the TCP relay server.");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     ck_assert_msg(net_send(sock, handshake + (TCP_CLIENT_HANDSHAKE_SIZE - 1), 1) == 1,
                   "Failed to send last byte of handshake.");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     uint8_t response[TCP_SERVER_HANDSHAKE_SIZE];
     uint8_t response_plain[TCP_HANDSHAKE_PLAIN_SIZE];
@@ -266,6 +270,8 @@ static int read_packet_sec_TCP(struct sec_TCP_con *con, uint8_t *data, uint16_t
 
 START_TEST(test_some)
 {
+    Mono_Time *mono_time = mono_time_new();
+
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(self_public_key, self_secret_key);
@@ -273,9 +279,9 @@ START_TEST(test_some)
     ck_assert_msg(tcp_s != nullptr, "Failed to create TCP relay server");
     ck_assert_msg(tcp_server_listen_count(tcp_s) == NUM_PORTS, "Failed to bind to all ports.");
 
-    struct sec_TCP_con *con1 = new_TCP_con(tcp_s);
-    struct sec_TCP_con *con2 = new_TCP_con(tcp_s);
-    struct sec_TCP_con *con3 = new_TCP_con(tcp_s);
+    struct sec_TCP_con *con1 = new_TCP_con(tcp_s, mono_time);
+    struct sec_TCP_con *con2 = new_TCP_con(tcp_s, mono_time);
+    struct sec_TCP_con *con3 = new_TCP_con(tcp_s, mono_time);
 
     uint8_t requ_p[1 + CRYPTO_PUBLIC_KEY_SIZE];
     requ_p[0] = 0;
@@ -286,7 +292,7 @@ START_TEST(test_some)
     memcpy(requ_p + 1, con1->public_key, CRYPTO_PUBLIC_KEY_SIZE);
     write_packet_TCP_secure_connection(con3, requ_p, sizeof(requ_p));
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     // Testing response from connection 1
     uint8_t data[2048];
@@ -309,7 +315,7 @@ START_TEST(test_some)
     write_packet_TCP_secure_connection(con3, test_packet, sizeof(test_packet));
     write_packet_TCP_secure_connection(con3, test_packet, sizeof(test_packet));
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     len = read_packet_sec_TCP(con1, data, 2 + 2 + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == 2, "wrong len %d", len);
@@ -334,7 +340,7 @@ START_TEST(test_some)
     write_packet_TCP_secure_connection(con1, test_packet, sizeof(test_packet));
     write_packet_TCP_secure_connection(con1, test_packet, sizeof(test_packet));
     write_packet_TCP_secure_connection(con1, test_packet, sizeof(test_packet));
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
     len = read_packet_sec_TCP(con3, data, 2 + sizeof(test_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(test_packet), "wrong len %d", len);
     ck_assert_msg(memcmp(data, test_packet, sizeof(test_packet)) == 0, "packet is wrong %u %u %u %u", data[0], data[1],
@@ -351,7 +357,7 @@ START_TEST(test_some)
     uint8_t ping_packet[1 + sizeof(uint64_t)] = {4, 8, 6, 9, 67};
     write_packet_TCP_secure_connection(con1, ping_packet, sizeof(ping_packet));
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     len = read_packet_sec_TCP(con1, data, 2 + sizeof(ping_packet) + CRYPTO_MAC_SIZE);
     ck_assert_msg(len == sizeof(ping_packet), "wrong len %d", len);
@@ -363,6 +369,8 @@ START_TEST(test_some)
     kill_TCP_con(con1);
     kill_TCP_con(con2);
     kill_TCP_con(con3);
+
+    mono_time_free(mono_time);
 }
 END_TEST
 
@@ -449,7 +457,8 @@ static int oob_data_callback(void *object, const uint8_t *public_key, const uint
 
 START_TEST(test_client)
 {
-    unix_time_update();
+    Mono_Time *mono_time = mono_time_new();
+
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(self_public_key, self_secret_key);
@@ -465,8 +474,9 @@ START_TEST(test_client)
     ip_port_tcp_s.port = net_htons(ports[random_u32() % NUM_PORTS]);
     ip_port_tcp_s.ip = get_loopback();
 
-    TCP_Client_Connection *conn = new_TCP_connection(ip_port_tcp_s, self_public_key, f_public_key, f_secret_key, nullptr);
-    do_TCP_connection(conn, nullptr);
+    TCP_Client_Connection *conn = new_TCP_connection(mono_time, ip_port_tcp_s, self_public_key, f_public_key, f_secret_key,
+                                  nullptr);
+    do_TCP_connection(mono_time, conn, nullptr);
     c_sleep(50);
 
     // The connection status should be unconfirmed here because we have finished
@@ -474,13 +484,13 @@ START_TEST(test_client)
     ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_UNCONFIRMED, "Wrong connection status. Expected: %d, is: %d.",
                   TCP_CLIENT_UNCONFIRMED, tcp_con_status(conn));
 
-    do_TCP_server_delay(tcp_s, 50); // Now let the server handle requests...
+    do_TCP_server_delay(tcp_s, mono_time, 50); // Now let the server handle requests...
 
     const uint8_t LOOP_SIZE = 3;
 
     for (uint8_t i = 0; i < LOOP_SIZE; i++) {
-        unix_time_update();
-        do_TCP_connection(conn, nullptr); // Run the connection loop.
+        mono_time_update(mono_time);
+        do_TCP_connection(mono_time, conn, nullptr); // Run the connection loop.
 
         // The status of the connection should continue to be TCP_CLIENT_CONFIRMED after multiple subsequent do_TCP_connection() calls.
         ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_CONFIRMED, "Wrong connection status. Expected: %d, is: %d",
@@ -489,7 +499,7 @@ START_TEST(test_client)
         c_sleep(i == LOOP_SIZE - 1 ? 0 : 500); // Sleep for 500ms on all except third loop.
     }
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     // And still after the server runs again.
     ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_CONFIRMED, "Wrong status. Expected: %d, is: %d", TCP_CLIENT_CONFIRMED,
@@ -499,8 +509,8 @@ START_TEST(test_client)
     uint8_t f2_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(f2_public_key, f2_secret_key);
     ip_port_tcp_s.port = net_htons(ports[random_u32() % NUM_PORTS]);
-    TCP_Client_Connection *conn2 = new_TCP_connection(
-                                       ip_port_tcp_s, self_public_key, f2_public_key, f2_secret_key, nullptr);
+    TCP_Client_Connection *conn2 = new_TCP_connection(mono_time, ip_port_tcp_s, self_public_key, f2_public_key,
+                                   f2_secret_key, nullptr);
 
     // The client should call this function (defined earlier) during the routing process.
     routing_response_handler(conn, response_callback, (char *)conn + 2);
@@ -514,13 +524,13 @@ START_TEST(test_client)
     // These integers will increment per successful callback.
     oob_data_callback_good = response_callback_good = status_callback_good = data_callback_good = 0;
 
-    do_TCP_connection(conn, nullptr);
-    do_TCP_connection(conn2, nullptr);
+    do_TCP_connection(mono_time, conn, nullptr);
+    do_TCP_connection(mono_time, conn2, nullptr);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
-    do_TCP_connection(conn, nullptr);
-    do_TCP_connection(conn2, nullptr);
+    do_TCP_connection(mono_time, conn, nullptr);
+    do_TCP_connection(mono_time, conn2, nullptr);
     c_sleep(50);
 
     uint8_t data[5] = {1, 2, 3, 4, 5};
@@ -529,10 +539,10 @@ START_TEST(test_client)
     send_routing_request(conn, f2_public_key);
     send_routing_request(conn2, f_public_key);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
-    do_TCP_connection(conn, nullptr);
-    do_TCP_connection(conn2, nullptr);
+    do_TCP_connection(mono_time, conn, nullptr);
+    do_TCP_connection(mono_time, conn2, nullptr);
 
     // All callback methods save data should have run during the above network prodding.
     ck_assert_msg(oob_data_callback_good == 1, "OOB callback not called");
@@ -543,22 +553,22 @@ START_TEST(test_client)
     ck_assert_msg(status_callback_connection_id == response_callback_connection_id,
                   "Status and response callback connection IDs are not equal.");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     ck_assert_msg(send_data(conn2, 0, data, 5) == 1, "Failed a send_data() call.");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
-    do_TCP_connection(conn, nullptr);
-    do_TCP_connection(conn2, nullptr);
+    do_TCP_connection(mono_time, conn, nullptr);
+    do_TCP_connection(mono_time, conn2, nullptr);
     ck_assert_msg(data_callback_good == 1, "Data callback was not called.");
     status_callback_good = 0;
     send_disconnect_request(conn2, 0);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
-    do_TCP_connection(conn, nullptr);
-    do_TCP_connection(conn2, nullptr);
+    do_TCP_connection(mono_time, conn, nullptr);
+    do_TCP_connection(mono_time, conn2, nullptr);
     ck_assert_msg(status_callback_good == 1, "Status callback not called");
     ck_assert_msg(status_callback_status == 1, "Wrong status callback status.");
 
@@ -566,13 +576,16 @@ START_TEST(test_client)
     kill_TCP_server(tcp_s);
     kill_TCP_connection(conn);
     kill_TCP_connection(conn2);
+
+    mono_time_free(mono_time);
 }
 END_TEST
 
 // Test how the client handles servers that don't respond.
 START_TEST(test_client_invalid)
 {
-    unix_time_update();
+    Mono_Time *mono_time = mono_time_new();
+
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(self_public_key, self_secret_key);
@@ -584,11 +597,12 @@ START_TEST(test_client_invalid)
 
     ip_port_tcp_s.port = net_htons(ports[random_u32() % NUM_PORTS]);
     ip_port_tcp_s.ip = get_loopback();
-    TCP_Client_Connection *conn = new_TCP_connection(ip_port_tcp_s, self_public_key, f_public_key, f_secret_key, nullptr);
+    TCP_Client_Connection *conn = new_TCP_connection(mono_time, ip_port_tcp_s, self_public_key, f_public_key, f_secret_key,
+                                  nullptr);
 
     // Run the client's main loop but not the server.
-    unix_time_update();
-    do_TCP_connection(conn, nullptr);
+    mono_time_update(mono_time);
+    do_TCP_connection(mono_time, conn, nullptr);
     c_sleep(50);
 
     // After 50ms of no response...
@@ -596,18 +610,20 @@ START_TEST(test_client_invalid)
                   TCP_CLIENT_CONNECTING, tcp_con_status(conn));
     // After 5s...
     c_sleep(5000);
-    unix_time_update();
-    do_TCP_connection(conn, nullptr);
+    mono_time_update(mono_time);
+    do_TCP_connection(mono_time, conn, nullptr);
     ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_CONNECTING, "Wrong status. Expected: %d, is: %d.",
                   TCP_CLIENT_CONNECTING, tcp_con_status(conn));
     // 11s... (Should wait for 10 before giving up.)
     c_sleep(6000);
-    unix_time_update();
-    do_TCP_connection(conn, nullptr);
+    mono_time_update(mono_time);
+    do_TCP_connection(mono_time, conn, nullptr);
     ck_assert_msg(tcp_con_status(conn) == TCP_CLIENT_DISCONNECTED, "Wrong status. Expected: %d, is: %d.",
                   TCP_CLIENT_DISCONNECTED, tcp_con_status(conn));
 
     kill_TCP_connection(conn);
+
+    mono_time_free(mono_time);
 }
 END_TEST
 
@@ -639,8 +655,9 @@ static int tcp_data_callback(void *object, int id, const uint8_t *data, uint16_t
 
 START_TEST(test_tcp_connection)
 {
+    Mono_Time *mono_time = mono_time_new();
+
     tcp_data_callback_called = 0;
-    unix_time_update();
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(self_public_key, self_secret_key);
@@ -650,11 +667,11 @@ START_TEST(test_tcp_connection)
     TCP_Proxy_Info proxy_info;
     proxy_info.proxy_type = TCP_PROXY_NONE;
     crypto_new_keypair(self_public_key, self_secret_key);
-    TCP_Connections *tc_1 = new_tcp_connections(self_secret_key, &proxy_info);
+    TCP_Connections *tc_1 = new_tcp_connections(mono_time, self_secret_key, &proxy_info);
     ck_assert_msg(public_key_cmp(tcp_connections_public_key(tc_1), self_public_key) == 0, "Wrong public key");
 
     crypto_new_keypair(self_public_key, self_secret_key);
-    TCP_Connections *tc_2 = new_tcp_connections(self_secret_key, &proxy_info);
+    TCP_Connections *tc_2 = new_tcp_connections(mono_time, self_secret_key, &proxy_info);
     ck_assert_msg(public_key_cmp(tcp_connections_public_key(tc_2), self_public_key) == 0, "Wrong public key");
 
     IP_Port ip_port_tcp_s;
@@ -676,17 +693,17 @@ START_TEST(test_tcp_connection)
     ck_assert_msg(new_tcp_connection_to(tc_2, tcp_connections_public_key(tc_1), 123) == -1,
                   "Managed to readd same connection\n");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
@@ -695,7 +712,7 @@ START_TEST(test_tcp_connection)
     ck_assert_msg(ret == 0, "could not send packet.");
     set_packet_tcp_connection_callback(tc_2, &tcp_data_callback, (void *) 120397);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
@@ -704,7 +721,7 @@ START_TEST(test_tcp_connection)
     ck_assert_msg(tcp_connection_to_online_tcp_relays(tc_1, 0) == 1, "Wrong number of connected relays");
     ck_assert_msg(kill_tcp_connection_to(tc_1, 0) == 0, "could not kill connection to\n");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
@@ -715,6 +732,8 @@ START_TEST(test_tcp_connection)
     kill_TCP_server(tcp_s);
     kill_tcp_connections(tc_1);
     kill_tcp_connections(tc_2);
+
+    mono_time_free(mono_time);
 }
 END_TEST
 
@@ -741,10 +760,11 @@ static int tcp_oobdata_callback(void *object, const uint8_t *public_key, unsigne
 
 START_TEST(test_tcp_connection2)
 {
+    Mono_Time *mono_time = mono_time_new();
+
     tcp_oobdata_callback_called = 0;
     tcp_data_callback_called = 0;
 
-    unix_time_update();
     uint8_t self_public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t self_secret_key[CRYPTO_SECRET_KEY_SIZE];
     crypto_new_keypair(self_public_key, self_secret_key);
@@ -754,11 +774,11 @@ START_TEST(test_tcp_connection2)
     TCP_Proxy_Info proxy_info;
     proxy_info.proxy_type = TCP_PROXY_NONE;
     crypto_new_keypair(self_public_key, self_secret_key);
-    TCP_Connections *tc_1 = new_tcp_connections(self_secret_key, &proxy_info);
+    TCP_Connections *tc_1 = new_tcp_connections(mono_time, self_secret_key, &proxy_info);
     ck_assert_msg(public_key_cmp(tcp_connections_public_key(tc_1), self_public_key) == 0, "Wrong public key");
 
     crypto_new_keypair(self_public_key, self_secret_key);
-    TCP_Connections *tc_2 = new_tcp_connections(self_secret_key, &proxy_info);
+    TCP_Connections *tc_2 = new_tcp_connections(mono_time, self_secret_key, &proxy_info);
     ck_assert_msg(public_key_cmp(tcp_connections_public_key(tc_2), self_public_key) == 0, "Wrong public key");
 
     IP_Port ip_port_tcp_s;
@@ -774,17 +794,17 @@ START_TEST(test_tcp_connection2)
     ck_assert_msg(add_tcp_relay_global(tc_2, ip_port_tcp_s, tcp_server_public_key(tcp_s)) == 0,
                   "Could not add global relay");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
@@ -794,14 +814,14 @@ START_TEST(test_tcp_connection2)
     set_oob_packet_tcp_connection_callback(tc_2, &tcp_oobdata_callback, tc_2);
     set_packet_tcp_connection_callback(tc_1, &tcp_data_callback, (void *) 120397);
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
 
     ck_assert_msg(tcp_oobdata_callback_called, "could not recv packet.");
 
-    do_TCP_server_delay(tcp_s, 50);
+    do_TCP_server_delay(tcp_s, mono_time, 50);
 
     do_tcp_connections(tc_1, nullptr);
     do_tcp_connections(tc_2, nullptr);
@@ -812,6 +832,8 @@ START_TEST(test_tcp_connection2)
     kill_TCP_server(tcp_s);
     kill_tcp_connections(tc_1);
     kill_tcp_connections(tc_2);
+
+    mono_time_free(mono_time);
 }
 END_TEST
 
diff --git a/auto_tests/dht_test.c b/auto_tests/dht_test.c
index 2f273727..009c0bbd 100644
--- a/auto_tests/dht_test.c
+++ b/auto_tests/dht_test.c
@@ -32,39 +32,39 @@ static inline IP get_loopback()
     return ip;
 }
 
-static void mark_bad(IPPTsPng *ipptp)
+static void mark_bad(const Mono_Time *mono_time, IPPTsPng *ipptp)
 {
-    ipptp->timestamp = unix_time() - 2 * BAD_NODE_TIMEOUT;
+    ipptp->timestamp = mono_time_get(mono_time) - 2 * BAD_NODE_TIMEOUT;
     ipptp->hardening.routes_requests_ok = 0;
     ipptp->hardening.send_nodes_ok = 0;
     ipptp->hardening.testing_requests = 0;
 }
 
-static void mark_possible_bad(IPPTsPng *ipptp)
+static void mark_possible_bad(const Mono_Time *mono_time, IPPTsPng *ipptp)
 {
-    ipptp->timestamp = unix_time();
+    ipptp->timestamp = mono_time_get(mono_time);
     ipptp->hardening.routes_requests_ok = 0;
     ipptp->hardening.send_nodes_ok = 0;
     ipptp->hardening.testing_requests = 0;
 }
 
-static void mark_good(IPPTsPng *ipptp)
+static void mark_good(const Mono_Time *mono_time, IPPTsPng *ipptp)
 {
-    ipptp->timestamp = unix_time();
+    ipptp->timestamp = mono_time_get(mono_time);
     ipptp->hardening.routes_requests_ok = (HARDENING_ALL_OK >> 0) & 1;
     ipptp->hardening.send_nodes_ok = (HARDENING_ALL_OK >> 1) & 1;
     ipptp->hardening.testing_requests = (HARDENING_ALL_OK >> 2) & 1;
 }
 
-static void mark_all_good(Client_data *list, uint32_t length, uint8_t ipv6)
+static void mark_all_good(const Mono_Time *mono_time, Client_data *list, uint32_t length, uint8_t ipv6)
 {
     uint32_t i;
 
     for (i = 0; i < length; ++i) {
         if (ipv6) {
-            mark_good(&list[i].assoc6);
+            mark_good(mono_time, &list[i].assoc6);
         } else {
-            mark_good(&list[i].assoc4);
+            mark_good(mono_time, &list[i].assoc4);
         }
     }
 }
@@ -183,7 +183,7 @@ static void test_addto_lists_bad(DHT            *dht,
     uint8_t ipv6 = net_family_is_ipv6(ip_port->ip.family) ? 1 : 0;
 
     random_bytes(public_key, sizeof(public_key));
-    mark_all_good(list, length, ipv6);
+    mark_all_good(dht->mono_time, list, length, ipv6);
 
     test1 = random_u32() % (length / 3);
     test2 = random_u32() % (length / 3) + length / 3;
@@ -196,13 +196,13 @@ static void test_addto_lists_bad(DHT            *dht,
 
     // mark nodes as "bad"
     if (ipv6) {
-        mark_bad(&list[test1].assoc6);
-        mark_bad(&list[test2].assoc6);
-        mark_bad(&list[test3].assoc6);
+        mark_bad(dht->mono_time, &list[test1].assoc6);
+        mark_bad(dht->mono_time, &list[test2].assoc6);
+        mark_bad(dht->mono_time, &list[test3].assoc6);
     } else {
-        mark_bad(&list[test1].assoc4);
-        mark_bad(&list[test2].assoc4);
-        mark_bad(&list[test3].assoc4);
+        mark_bad(dht->mono_time, &list[test1].assoc4);
+        mark_bad(dht->mono_time, &list[test2].assoc4);
+        mark_bad(dht->mono_time, &list[test3].assoc4);
     }
 
     ip_port->port += 1;
@@ -227,7 +227,7 @@ static void test_addto_lists_possible_bad(DHT            *dht,
     uint8_t ipv6 = net_family_is_ipv6(ip_port->ip.family) ? 1 : 0;
 
     random_bytes(public_key, sizeof(public_key));
-    mark_all_good(list, length, ipv6);
+    mark_all_good(dht->mono_time, list, length, ipv6);
 
     test1 = random_u32() % (length / 3);
     test2 = random_u32() % (length / 3) + length / 3;
@@ -240,13 +240,13 @@ static void test_addto_lists_possible_bad(DHT            *dht,
 
     // mark nodes as "possibly bad"
     if (ipv6) {
-        mark_possible_bad(&list[test1].assoc6);
-        mark_possible_bad(&list[test2].assoc6);
-        mark_possible_bad(&list[test3].assoc6);
+        mark_possible_bad(dht->mono_time, &list[test1].assoc6);
+        mark_possible_bad(dht->mono_time, &list[test2].assoc6);
+        mark_possible_bad(dht->mono_time, &list[test3].assoc6);
     } else {
-        mark_possible_bad(&list[test1].assoc4);
-        mark_possible_bad(&list[test2].assoc4);
-        mark_possible_bad(&list[test3].assoc4);
+        mark_possible_bad(dht->mono_time, &list[test1].assoc4);
+        mark_possible_bad(dht->mono_time, &list[test2].assoc4);
+        mark_possible_bad(dht->mono_time, &list[test3].assoc4);
     }
 
     ip_port->port += 1;
@@ -288,7 +288,7 @@ static void test_addto_lists_good(DHT            *dht,
     uint8_t public_key[CRYPTO_PUBLIC_KEY_SIZE];
     uint8_t ipv6 = net_family_is_ipv6(ip_port->ip.family) ? 1 : 0;
 
-    mark_all_good(list, length, ipv6);
+    mark_all_good(dht->mono_time, list, length, ipv6);
 
     // check "good" client id replacement
     do {
@@ -319,10 +319,13 @@ static void test_addto_lists(IP ip)
     uint32_t index = 1;
     logger_callback_log(log, (logger_cb *)print_debug_log, nullptr, &index);
 
+    Mono_Time *mono_time = mono_time_new();
+    ck_assert_msg(mono_time != nullptr, "Failed to create Mono_Time");
+
     Networking_Core *net = new_networking(log, ip, TOX_PORT_DEFAULT);
     ck_assert_msg(net != nullptr, "Failed to create Networking_Core");
 
-    DHT *dht = new_dht(log, net, true);
+    DHT *dht = new_dht(log, mono_time, net, true);
     ck_assert_msg(dht != nullptr, "Failed to create DHT");
 
     IP_Port ip_port;
@@ -451,6 +454,7 @@ static void test_list_main(void)
 {
     DHT *dhts[NUM_DHT];
     Logger *logs[NUM_DHT];
+    Mono_Time *mono_times[NUM_DHT];
     uint32_t index[NUM_DHT];
 
     uint8_t cmp_list1[NUM_DHT][MAX_FRIEND_CLIENTS][CRYPTO_PUBLIC_KEY_SIZE + 1];
@@ -466,7 +470,9 @@ static void test_list_main(void)
         index[i] = i + 1;
         logger_callback_log(logs[i], (logger_cb *)print_debug_log, nullptr, &index[i]);
 
-        dhts[i] = new_dht(logs[i], new_networking(logs[i], ip, DHT_DEFAULT_PORT + i), true);
+        mono_times[i] = mono_time_new();
+
+        dhts[i] = new_dht(logs[i], mono_times[i], new_networking(logs[i], ip, DHT_DEFAULT_PORT + i), true);
         ck_assert_msg(dhts[i] != nullptr, "Failed to create dht instances %u", i);
         ck_assert_msg(net_port(dhts[i]->net) != DHT_DEFAULT_PORT + i,
                       "Bound to wrong port: %d", net_port(dhts[i]->net));
@@ -573,6 +579,7 @@ static void test_list_main(void)
         Networking_Core *n = dhts[i]->net;
         kill_dht(dhts[i]);
         kill_networking(n);
+        mono_time_free(mono_times[i]);
         logger_kill(logs[i]);
     }
 }
@@ -598,10 +605,9 @@ static void test_DHT_test(void)
     uint32_t to_comp = 8394782;
     DHT *dhts[NUM_DHT];
     Logger *logs[NUM_DHT];
+    Mono_Time *mono_times[NUM_DHT];
     uint32_t index[NUM_DHT];
 
-    unix_time_update();
-
     uint32_t i, j;
 
     for (i = 0; i < NUM_DHT; ++i) {
@@ -612,7 +618,9 @@ static void test_DHT_test(void)
         index[i] = i + 1;
         logger_callback_log(logs[i], (logger_cb *)print_debug_log, nullptr, &index[i]);
 
-        dhts[i] = new_dht(logs[i], new_networking(logs[i], ip, DHT_DEFAULT_PORT + i), true);
+        mono_times[i] = mono_time_new();
+
+        dhts[i] = new_dht(logs[i], mono_times[i], new_networking(logs[i], ip, DHT_DEFAULT_PORT + i), true);
         ck_assert_msg(dhts[i] != nullptr, "Failed to create dht instances %u", i);
         ck_assert_msg(net_port(dhts[i]->net) != DHT_DEFAULT_PORT + i, "Bound to wrong port");
     }
@@ -663,7 +671,7 @@ loop_top:
         }
 
         for (i = 0; i < NUM_DHT; ++i) {
-            unix_time_update();
+            mono_time_update(mono_times[i]);
             networking_poll(dhts[i]->net, nullptr);
             do_dht(dhts[i]);
         }
@@ -675,6 +683,7 @@ loop_top:
         Networking_Core *n = dhts[i]->net;
         kill_dht(dhts[i]);
         kill_networking(n);
+        mono_time_free(mono_times[i]);
         logger_kill(logs[i]);
     }
 }
@@ -792,8 +801,6 @@ int main(void)
 {
     setvbuf(stdout, nullptr, _IONBF, 0);
 
-    unix_time_update();
-
     test_dht_create_packet();
     test_dht_node_packing();
 
diff --git a/auto_tests/messenger_test.c b/auto_tests/messenger_test.c
index b8fbbc1f..dd644e50 100644
--- a/auto_tests/messenger_test.c
+++ b/auto_tests/messenger_test.c
@@ -341,13 +341,15 @@ int main(void)
     good_id   = hex_string_to_bin(good_id_str);
     bad_id    = hex_string_to_bin(bad_id_str);
 
+    Mono_Time *mono_time = mono_time_new();
+
     /* IPv6 status from global define */
     Messenger_Options options = {0};
     options.ipv6enabled = TOX_ENABLE_IPV6_DEFAULT;
     options.port_range[0] = 41234;
     options.port_range[1] = 44234;
     options.log_callback = (logger_cb *)print_debug_log;
-    m = new_messenger(&options, nullptr);
+    m = new_messenger(mono_time, &options, nullptr);
 
     /* setup a default friend and friendnum */
     if (m_addfriend_norequest(m, friend_id) < 0) {
@@ -375,6 +377,7 @@ int main(void)
     free(bad_id);
 
     kill_messenger(m);
+    mono_time_free(mono_time);
 
     return number_failed;
 }
diff --git a/auto_tests/onion_test.c b/auto_tests/onion_test.c
index 0a9a0577..a11fb807 100644
--- a/auto_tests/onion_test.c
+++ b/auto_tests/onion_test.c
@@ -31,7 +31,7 @@ static inline IP get_loopback()
 }
 static void do_onion(Onion *onion)
 {
-    unix_time_update();
+    mono_time_update(onion->mono_time);
 
     networking_poll(onion->net, nullptr);
     do_dht(onion->dht);
@@ -152,7 +152,7 @@ static int handle_test_4(void *object, IP_Port source, const uint8_t *packet, ui
     return 0;
 }
 
-START_TEST(test_basic)
+static void test_basic(void)
 {
     uint32_t index[] = { 1, 2, 3 };
     Logger *log1 = logger_new();
@@ -160,9 +160,12 @@ START_TEST(test_basic)
     Logger *log2 = logger_new();
     logger_callback_log(log2, (logger_cb *)print_debug_log, nullptr, &index[1]);
 
+    Mono_Time *mono_time1 = mono_time_new();
+    Mono_Time *mono_time2 = mono_time_new();
+
     IP ip = get_loopback();
-    Onion *onion1 = new_onion(new_dht(log1, new_networking(log1, ip, 36567), true));
-    Onion *onion2 = new_onion(new_dht(log2, new_networking(log2, ip, 36568), true));
+    Onion *onion1 = new_onion(mono_time1, new_dht(log1, mono_time1, new_networking(log1, ip, 36567), true));
+    Onion *onion2 = new_onion(mono_time2, new_dht(log2, mono_time2, new_networking(log2, ip, 36568), true));
     ck_assert_msg((onion1 != nullptr) && (onion2 != nullptr), "Onion failed initializing.");
     networking_registerhandler(onion2->net, NET_PACKET_ANNOUNCE_REQUEST, &handle_test_1, onion2);
 
@@ -202,8 +205,8 @@ START_TEST(test_basic)
         do_onion(onion2);
     }
 
-    Onion_Announce *onion1_a = new_onion_announce(onion1->dht);
-    Onion_Announce *onion2_a = new_onion_announce(onion2->dht);
+    Onion_Announce *onion1_a = new_onion_announce(mono_time1, onion1->dht);
+    Onion_Announce *onion2_a = new_onion_announce(mono_time2, onion2->dht);
     networking_registerhandler(onion1->net, NET_PACKET_ANNOUNCE_RESPONSE, &handle_test_3, onion1);
     ck_assert_msg((onion1_a != nullptr) && (onion2_a != nullptr), "Onion_Announce failed initializing.");
     uint8_t zeroes[64] = {0};
@@ -229,7 +232,7 @@ START_TEST(test_basic)
     random_bytes(sb_data, sizeof(sb_data));
     memcpy(&s, sb_data, sizeof(uint64_t));
     memcpy(onion_announce_entry_public_key(onion2_a, 1), dht_get_self_public_key(onion2->dht), CRYPTO_PUBLIC_KEY_SIZE);
-    onion_announce_entry_set_time(onion2_a, 1, unix_time());
+    onion_announce_entry_set_time(onion2_a, 1, mono_time_get(mono_time2));
     networking_registerhandler(onion1->net, NET_PACKET_ONION_DATA_RESPONSE, &handle_test_4, onion1);
     send_announce_request(onion1->net, &path, nodes[3],
                           dht_get_self_public_key(onion1->dht),
@@ -250,7 +253,9 @@ START_TEST(test_basic)
     Logger *log3 = logger_new();
     logger_callback_log(log3, (logger_cb *)print_debug_log, nullptr, &index[2]);
 
-    Onion *onion3 = new_onion(new_dht(log3, new_networking(log3, ip, 36569), true));
+    Mono_Time *mono_time3 = mono_time_new();
+
+    Onion *onion3 = new_onion(mono_time3, new_dht(log3, mono_time3, new_networking(log3, ip, 36569), true));
     ck_assert_msg((onion3 != nullptr), "Onion failed initializing.");
 
     random_nonce(nonce);
@@ -278,6 +283,7 @@ START_TEST(test_basic)
         kill_onion(onion);
         kill_dht(dht);
         kill_networking(net);
+        mono_time_free(mono_time3);
         logger_kill(log3);
     }
 
@@ -289,6 +295,7 @@ START_TEST(test_basic)
         kill_onion(onion);
         kill_dht(dht);
         kill_networking(net);
+        mono_time_free(mono_time2);
         logger_kill(log2);
     }
 
@@ -300,13 +307,14 @@ START_TEST(test_basic)
         kill_onion(onion);
         kill_dht(dht);
         kill_networking(net);
+        mono_time_free(mono_time1);
         logger_kill(log1);
     }
 }
-END_TEST
 
 typedef struct {
     Logger *log;
+    Mono_Time *mono_time;
     Onion *onion;
     Onion_Announce *onion_a;
     Onion_Client *onion_c;
@@ -329,56 +337,67 @@ static Onions *new_onions(uint16_t port, uint32_t *index)
         return nullptr;
     }
 
-    unix_time_update();
-
     logger_callback_log(on->log, (logger_cb *)print_debug_log, nullptr, index);
 
+    on->mono_time = mono_time_new();
+
+    if (!on->mono_time) {
+        logger_kill(on->log);
+        free(on);
+        return nullptr;
+    }
+
     Networking_Core *net = new_networking(on->log, ip, port);
 
     if (!net) {
+        mono_time_free(on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
     }
 
-    DHT *dht = new_dht(on->log, net, true);
+    DHT *dht = new_dht(on->log, on->mono_time, net, true);
 
     if (!dht) {
         kill_networking(net);
+        mono_time_free(on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
     }
 
-    on->onion = new_onion(dht);
+    on->onion = new_onion(on->mono_time, dht);
 
     if (!on->onion) {
         kill_dht(dht);
         kill_networking(net);
+        mono_time_free(on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
     }
 
-    on->onion_a = new_onion_announce(dht);
+    on->onion_a = new_onion_announce(on->mono_time, dht);
 
     if (!on->onion_a) {
         kill_onion(on->onion);
         kill_dht(dht);
         kill_networking(net);
+        mono_time_free(on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
     }
 
     TCP_Proxy_Info inf = {{{{0}}}};
-    on->onion_c = new_onion_client(new_net_crypto(on->log, dht, &inf));
+    on->onion_c = new_onion_client(on->mono_time, new_net_crypto(on->log, on->mono_time, dht, &inf));
 
     if (!on->onion_c) {
         kill_onion_announce(on->onion_a);
         kill_onion(on->onion);
         kill_dht(dht);
         kill_networking(net);
+        mono_time_free(on->mono_time);
         logger_kill(on->log);
         free(on);
         return nullptr;
@@ -389,7 +408,7 @@ static Onions *new_onions(uint16_t port, uint32_t *index)
 
 static void do_onions(Onions *on)
 {
-    unix_time_update();
+    mono_time_update(on->mono_time);
 
     networking_poll(on->onion->net, nullptr);
     do_dht(on->onion->dht);
@@ -407,6 +426,7 @@ static void kill_onions(Onions *on)
     kill_net_crypto(c);
     kill_dht(dht);
     kill_networking(net);
+    mono_time_free(on->mono_time);
     logger_kill(on->log);
     free(on);
 }
@@ -468,7 +488,7 @@ static void dht_pk_callback(void *object, int32_t number, const uint8_t *dht_pub
     }
 }
 
-START_TEST(test_announce)
+static void test_announce(void)
 {
     uint32_t i, j;
     uint32_t index[NUM_ONIONS];
@@ -553,29 +573,13 @@ START_TEST(test_announce)
         kill_onions(onions[i]);
     }
 }
-END_TEST
-
-static Suite *onion_suite(void)
-{
-    Suite *s = suite_create("Onion");
-
-    DEFTESTCASE_SLOW(basic, 5);
-    DEFTESTCASE_SLOW(announce, 70);
-    return s;
-}
 
 int main(void)
 {
     setvbuf(stdout, nullptr, _IONBF, 0);
 
-    Suite *onion = onion_suite();
-    SRunner *test_runner = srunner_create(onion);
-
-    int number_failed = 0;
-    srunner_run_all(test_runner, CK_NORMAL);
-    number_failed = srunner_ntests_failed(test_runner);
+    test_basic();
+    test_announce();
 
-    srunner_free(test_runner);
-
-    return number_failed;
+    return 0;
 }