make Mono_Time an argument to current_time_monotonic

3 files changed, 30 insertions, 33 deletions

diff --git a/toxcore/mono_time.c b/toxcore/mono_time.c
index 3c415420..7d881b09 100644
--- a/toxcore/mono_time.c
+++ b/toxcore/mono_time.c
@@ -39,7 +39,7 @@ Mono_Time *mono_time_new(void)
     }
 
     monotime->time = 0;
-    monotime->base_time = 0;
+    monotime->base_time = (uint64_t)time(nullptr) - (current_time_monotonic(monotime) / 1000ULL);
 
     mono_time_update(monotime);
 
@@ -53,11 +53,7 @@ void mono_time_free(Mono_Time *monotime)
 
 void mono_time_update(Mono_Time *monotime)
 {
-    if (monotime->base_time == 0) {
-        monotime->base_time = ((uint64_t)time(nullptr) - (current_time_monotonic() / 1000ULL));
-    }
-
-    monotime->time = (current_time_monotonic() / 1000ULL) + monotime->base_time;
+    monotime->time = (current_time_monotonic(monotime) / 1000ULL) + monotime->base_time;
 }
 
 uint64_t mono_time_get(const Mono_Time *monotime)
@@ -74,34 +70,34 @@ bool mono_time_is_timeout(const Mono_Time *monotime, uint64_t timestamp, uint64_
 //!TOKSTYLE-
 // No global mutable state in Tokstyle.
 #ifdef OS_WIN32
-static uint64_t last_monotime;
-static uint64_t add_monotime;
+static uint64_t last_clock_mono;
+static uint64_t add_clock_mono;
 #endif
 //!TOKSTYLE+
 
 /* return current monotonic time in milliseconds (ms). */
-uint64_t current_time_monotonic(void)
+uint64_t current_time_monotonic(const Mono_Time *monotime)
 {
     uint64_t time;
 #ifdef OS_WIN32
-    uint64_t old_add_monotime = add_monotime;
-    time = (uint64_t)GetTickCount() + add_monotime;
+    uint64_t old_add_clock_mono = add_clock_mono;
+    time = (uint64_t)GetTickCount() + add_clock_mono;
 
     /* Check if time has decreased because of 32 bit wrap from GetTickCount(), while avoiding false positives from race
      * conditions when multiple threads call this function at once */
-    if (time + 0x10000 < last_monotime) {
+    if (time + 0x10000 < last_clock_mono) {
         uint32_t add = ~0;
-        /* use old_add_monotime rather than simply incrementing add_monotime, to handle the case that many threads
+        /* use old_add_clock_mono rather than simply incrementing add_clock_mono, to handle the case that many threads
          * simultaneously detect an overflow */
-        add_monotime = old_add_monotime + add;
+        add_clock_mono = old_add_clock_mono + add;
         time += add;
     }
 
-    last_monotime = time;
+    last_clock_mono = time;
 #else
-    struct timespec monotime;
+    struct timespec clock_mono;
 #if defined(__linux__) && defined(CLOCK_MONOTONIC_RAW)
-    clock_gettime(CLOCK_MONOTONIC_RAW, &monotime);
+    clock_gettime(CLOCK_MONOTONIC_RAW, &clock_mono);
 #elif defined(__APPLE__)
     clock_serv_t muhclock;
     mach_timespec_t machtime;
@@ -110,12 +106,12 @@ uint64_t current_time_monotonic(void)
     clock_get_time(muhclock, &machtime);
     mach_port_deallocate(mach_task_self(), muhclock);
 
-    monotime.tv_sec = machtime.tv_sec;
-    monotime.tv_nsec = machtime.tv_nsec;
+    clock_mono.tv_sec = machtime.tv_sec;
+    clock_mono.tv_nsec = machtime.tv_nsec;
 #else
-    clock_gettime(CLOCK_MONOTONIC, &monotime);
+    clock_gettime(CLOCK_MONOTONIC, &clock_mono);
 #endif
-    time = 1000ULL * monotime.tv_sec + (monotime.tv_nsec / 1000000ULL);
+    time = 1000ULL * clock_mono.tv_sec + (clock_mono.tv_nsec / 1000000ULL);
 #endif
     return time;
 }
diff --git a/toxcore/mono_time.h b/toxcore/mono_time.h
index 1d2dd539..489bf138 100644
--- a/toxcore/mono_time.h
+++ b/toxcore/mono_time.h
@@ -50,7 +50,7 @@ uint64_t mono_time_get(const Mono_Time *monotime);
 bool mono_time_is_timeout(const Mono_Time *monotime, uint64_t timestamp, uint64_t timeout);
 
 /* return current monotonic time in milliseconds (ms). */
-uint64_t current_time_monotonic(void);
+uint64_t current_time_monotonic(const Mono_Time *monotime);
 
 #ifdef __cplusplus
 }
diff --git a/toxcore/net_crypto.c b/toxcore/net_crypto.c
index a577b6c7..11795827 100644
--- a/toxcore/net_crypto.c
+++ b/toxcore/net_crypto.c
@@ -703,7 +703,7 @@ static int send_packet_to(Net_Crypto *c, int crypt_connection_id, const uint8_t
     pthread_mutex_lock(&conn->mutex);
 
     if (ret == 0) {
-        conn->last_tcp_sent = current_time_monotonic();
+        conn->last_tcp_sent = current_time_monotonic(c->mono_time);
     }
 
     pthread_mutex_unlock(&conn->mutex);
@@ -957,8 +957,8 @@ static int generate_request_packet(const Logger *log, uint8_t *data, uint16_t le
  * return -1 on failure.
  * return number of requested packets on success.
  */
-static int handle_request_packet(const Logger *log, Packets_Array *send_array, const uint8_t *data, uint16_t length,
-                                 uint64_t *latest_send_time, uint64_t rtt_time)
+static int handle_request_packet(const Mono_Time *mono_time, const Logger *log, Packets_Array *send_array,
+                                 const uint8_t *data, uint16_t length, uint64_t *latest_send_time, uint64_t rtt_time)
 {
     if (length == 0) {
         return -1;
@@ -978,7 +978,7 @@ static int handle_request_packet(const Logger *log, Packets_Array *send_array, c
     uint32_t n = 1;
     uint32_t requested = 0;
 
-    const uint64_t temp_time = current_time_monotonic();
+    const uint64_t temp_time = current_time_monotonic(mono_time);
     uint64_t l_sent_time = ~0;
 
     for (uint32_t i = send_array->buffer_start; i != send_array->buffer_end; ++i) {
@@ -1120,7 +1120,7 @@ static int reset_max_speed_reached(Net_Crypto *c, int crypt_connection_id)
                 return -1;
             }
 
-            dt->sent_time = current_time_monotonic();
+            dt->sent_time = current_time_monotonic(c->mono_time);
         }
 
         conn->maximum_speed_reached = 0;
@@ -1173,7 +1173,7 @@ static int64_t send_lossless_packet(Net_Crypto *c, int crypt_connection_id, cons
         Packet_Data *dt1 = nullptr;
 
         if (get_data_pointer(c->log, &conn->send_array, &dt1, packet_num) == 1) {
-            dt1->sent_time = current_time_monotonic();
+            dt1->sent_time = current_time_monotonic(c->mono_time);
         }
     } else {
         conn->maximum_speed_reached = 1;
@@ -1279,7 +1279,7 @@ static int send_requested_packets(Net_Crypto *c, int crypt_connection_id, uint32
         return -1;
     }
 
-    const uint64_t temp_time = current_time_monotonic();
+    const uint64_t temp_time = current_time_monotonic(c->mono_time);
     uint32_t i, num_sent = 0, array_size = num_packets_array(&conn->send_array);
 
     for (i = 0; i < array_size; ++i) {
@@ -1395,7 +1395,7 @@ static int send_temp_packet(Net_Crypto *c, int crypt_connection_id)
         return -1;
     }
 
-    conn->temp_packet_sent_time = current_time_monotonic();
+    conn->temp_packet_sent_time = current_time_monotonic(c->mono_time);
     ++conn->temp_packet_num_sent;
     return 0;
 }
@@ -1545,7 +1545,8 @@ static int handle_data_packet_core(Net_Crypto *c, int crypt_connection_id, const
             rtt_time = DEFAULT_TCP_PING_CONNECTION;
         }
 
-        int requested = handle_request_packet(c->log, &conn->send_array, real_data, real_length, &rtt_calc_time, rtt_time);
+        int requested = handle_request_packet(c->mono_time, c->log, &conn->send_array, real_data, real_length, &rtt_calc_time,
+                                              rtt_time);
 
         if (requested == -1) {
             return -1;
@@ -1598,7 +1599,7 @@ static int handle_data_packet_core(Net_Crypto *c, int crypt_connection_id, const
     }
 
     if (rtt_calc_time != 0) {
-        uint64_t rtt_time = current_time_monotonic() - rtt_calc_time;
+        uint64_t rtt_time = current_time_monotonic(c->mono_time) - rtt_calc_time;
 
         if (rtt_time < conn->rtt_time) {
             conn->rtt_time = rtt_time;
@@ -2441,7 +2442,7 @@ static int udp_handle_packet(void *object, IP_Port source, const uint8_t *packet
 
 static void send_crypto_packets(Net_Crypto *c)
 {
-    const uint64_t temp_time = current_time_monotonic();
+    const uint64_t temp_time = current_time_monotonic(c->mono_time);
     double total_send_rate = 0;
     uint32_t peak_request_packet_interval = ~0;