12 files changed, 73 insertions, 68 deletions

diff --git a/testing/av_test.c b/testing/av_test.c
index a36d0a00..d484250b 100644
--- a/testing/av_test.c
+++ b/testing/av_test.c
@@ -45,6 +45,7 @@ extern "C" {
 #include "../toxav/ring_buffer.c"
 
 #include "../toxav/toxav.h"
+#include "../toxcore/Messenger.h"
 #include "../toxcore/mono_time.h" /* current_time_monotonic() */
 #include "../toxcore/tox.h"
 #include "../toxcore/util.h"
@@ -564,6 +565,9 @@ CHECK_ARG:
 
     initialize_tox(&bootstrap, &AliceAV, &AliceCC, &BobAV, &BobCC);
 
+    // TODO(iphydf): Don't depend on toxcore internals
+    const Mono_Time *mono_time = (*(Messenger **)bootstrap)->mono_time;
+
     if (TEST_TRANSFER_A) {
         SNDFILE *af_handle;
         SF_INFO af_info;
@@ -657,7 +661,7 @@ CHECK_ARG:
         printf("Sample rate %d\n", af_info.samplerate);
 
         while (start_time + expected_time > time(nullptr)) {
-            uint64_t enc_start_time = current_time_monotonic();
+            uint64_t enc_start_time = current_time_monotonic(mono_time);
             int64_t count = sf_read_short(af_handle, PCM, frame_size);
 
             if (count > 0) {
@@ -670,7 +674,7 @@ CHECK_ARG:
             }
 
             iterate_tox(bootstrap, AliceAV, BobAV, nullptr);
-            c_sleep((audio_frame_duration - (current_time_monotonic() - enc_start_time) - 1));
+            c_sleep((audio_frame_duration - (current_time_monotonic(mono_time) - enc_start_time) - 1));
         }
 
         printf("Played file in: %lu; stopping stream...\n", time(nullptr) - start_time);
diff --git a/toxav/audio.c b/toxav/audio.c
index 729a4922..f1284f54 100644
--- a/toxav/audio.c
+++ b/toxav/audio.c
@@ -44,7 +44,8 @@ static bool reconfigure_audio_decoder(ACSession *ac, int32_t sampling_rate, int8
 
 
 
-ACSession *ac_new(const Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb, void *cb_data)
+ACSession *ac_new(const Mono_Time *mono_time, const Logger *log, ToxAV *av, uint32_t friend_number,
+                  toxav_audio_receive_frame_cb *cb, void *cb_data)
 {
     ACSession *ac = (ACSession *)calloc(sizeof(ACSession), 1);
 
@@ -75,6 +76,7 @@ ACSession *ac_new(const Logger *log, ToxAV *av, uint32_t friend_number, toxav_au
         goto BASE_CLEANUP;
     }
 
+    ac->mono_time = mono_time;
     ac->log = log;
 
     /* Initialize encoders with default values */
@@ -214,7 +216,7 @@ void ac_iterate(ACSession *ac)
     pthread_mutex_unlock(ac->queue_mutex);
 }
 
-int ac_queue_message(void *acp, struct RTPMessage *msg)
+int ac_queue_message(const Mono_Time *mono_time, void *acp, struct RTPMessage *msg)
 {
     if (!acp || !msg) {
         return -1;
@@ -496,7 +498,7 @@ bool reconfigure_audio_encoder(const Logger *log, OpusEncoder **e, int32_t new_b
 bool reconfigure_audio_decoder(ACSession *ac, int32_t sampling_rate, int8_t channels)
 {
     if (sampling_rate != ac->ld_sample_rate || channels != ac->ld_channel_count) {
-        if (current_time_monotonic() - ac->ldrts < 500) {
+        if (current_time_monotonic(ac->mono_time) - ac->ldrts < 500) {
             return false;
         }
 
@@ -510,7 +512,7 @@ bool reconfigure_audio_decoder(ACSession *ac, int32_t sampling_rate, int8_t chan
 
         ac->ld_sample_rate = sampling_rate;
         ac->ld_channel_count = channels;
-        ac->ldrts = current_time_monotonic();
+        ac->ldrts = current_time_monotonic(ac->mono_time);
 
         opus_decoder_destroy(ac->decoder);
         ac->decoder = new_dec;
diff --git a/toxav/audio.h b/toxav/audio.h
index f71aaed3..6a19e6b6 100644
--- a/toxav/audio.h
+++ b/toxav/audio.h
@@ -50,6 +50,7 @@
 #define AUDIO_MAX_BUFFER_SIZE_BYTES (AUDIO_MAX_BUFFER_SIZE_PCM16 * 2)
 
 typedef struct ACSession_s {
+    const Mono_Time *mono_time;
     const Logger *log;
 
     /* encoding */
@@ -77,11 +78,11 @@ typedef struct ACSession_s {
     void *acb_user_data;
 } ACSession;
 
-ACSession *ac_new(const Logger *log, ToxAV *av, uint32_t friend_number, toxav_audio_receive_frame_cb *cb,
-                  void *cb_data);
+ACSession *ac_new(const Mono_Time *mono_time, const Logger *log, ToxAV *av, uint32_t friend_number,
+                  toxav_audio_receive_frame_cb *cb, void *cb_data);
 void ac_kill(ACSession *ac);
 void ac_iterate(ACSession *ac);
-int ac_queue_message(void *acp, struct RTPMessage *msg);
+int ac_queue_message(const Mono_Time *mono_time, void *acp, struct RTPMessage *msg);
 int ac_reconfigure_encoder(ACSession *ac, int32_t bit_rate, int32_t sampling_rate, uint8_t channels);
 
 #endif /* AUDIO_H */
diff --git a/toxav/bwcontroller.c b/toxav/bwcontroller.c
index 460cf118..695bb99b 100644
--- a/toxav/bwcontroller.c
+++ b/toxav/bwcontroller.c
@@ -83,7 +83,7 @@ BWController *bwc_new(Messenger *m, uint32_t friendnumber, m_cb *mcb, void *mcb_
     retu->mcb_user_data = mcb_user_data;
     retu->m = m;
     retu->friend_number = friendnumber;
-    uint64_t now = current_time_monotonic();
+    uint64_t now = current_time_monotonic(m->mono_time);
     retu->cycle.last_sent_timestamp = now;
     retu->cycle.last_refresh_timestamp = now;
     retu->rcvpkt.rb = rb_new(BWC_AVG_PKT_COUNT);
@@ -138,7 +138,7 @@ void bwc_add_recv(BWController *bwc, uint32_t recv_bytes)
 void send_update(BWController *bwc)
 {
     if (bwc->packet_loss_counted_cycles > BWC_AVG_LOSS_OVER_CYCLES_COUNT &&
-            current_time_monotonic() - bwc->cycle.last_sent_timestamp > BWC_SEND_INTERVAL_MS) {
+            current_time_monotonic(bwc->m->mono_time) - bwc->cycle.last_sent_timestamp > BWC_SEND_INTERVAL_MS) {
         bwc->packet_loss_counted_cycles = 0;
 
         if (bwc->cycle.lost) {
@@ -159,7 +159,7 @@ void send_update(BWController *bwc)
             }
         }
 
-        bwc->cycle.last_sent_timestamp = current_time_monotonic();
+        bwc->cycle.last_sent_timestamp = current_time_monotonic(bwc->m->mono_time);
         bwc->cycle.lost = 0;
         bwc->cycle.recv = 0;
     }
@@ -170,12 +170,12 @@ static int on_update(BWController *bwc, const struct BWCMessage *msg)
     LOGGER_DEBUG(bwc->m->log, "%p Got update from peer", (void *)bwc);
 
     /* Peers sent update too soon */
-    if (bwc->cycle.last_recv_timestamp + BWC_SEND_INTERVAL_MS > current_time_monotonic()) {
+    if (bwc->cycle.last_recv_timestamp + BWC_SEND_INTERVAL_MS > current_time_monotonic(bwc->m->mono_time)) {
         LOGGER_INFO(bwc->m->log, "%p Rejecting extra update", (void *)bwc);
         return -1;
     }
 
-    bwc->cycle.last_recv_timestamp = current_time_monotonic();
+    bwc->cycle.last_recv_timestamp = current_time_monotonic(bwc->m->mono_time);
 
     uint32_t recv = net_ntohl(msg->recv);
     uint32_t lost = net_ntohl(msg->lost);
diff --git a/toxav/rtp.c b/toxav/rtp.c
index 61297937..77cae626 100644
--- a/toxav/rtp.c
+++ b/toxav/rtp.c
@@ -389,7 +389,7 @@ static int handle_video_packet(RTPSession *session, const struct RTPHeader *head
         LOGGER_DEBUG(log, "-- handle_video_packet -- CALLBACK-001a b0=%d b1=%d", (int)m_new->data[0], (int)m_new->data[1]);
         update_bwc_values(log, session, m_new);
         // Pass ownership of m_new to the callback.
-        session->mcb(session->cs, m_new);
+        session->mcb(session->m->mono_time, session->cs, m_new);
         // Now we no longer own m_new.
         m_new = nullptr;
 
@@ -426,7 +426,7 @@ static int handle_video_packet(RTPSession *session, const struct RTPHeader *head
     if (m_new) {
         LOGGER_DEBUG(log, "-- handle_video_packet -- CALLBACK-003a b0=%d b1=%d", (int)m_new->data[0], (int)m_new->data[1]);
         update_bwc_values(log, session, m_new);
-        session->mcb(session->cs, m_new);
+        session->mcb(session->m->mono_time, session->cs, m_new);
 
         m_new = nullptr;
     }
@@ -499,15 +499,15 @@ static int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t
 
         /* Invoke processing of active multiparted message */
         if (session->mp) {
-            session->mcb(session->cs, session->mp);
+            session->mcb(session->m->mono_time, session->cs, session->mp);
             session->mp = nullptr;
         }
 
         /* The message came in the allowed time;
          */
 
-        return session->mcb(session->cs, new_message(&header, length - RTP_HEADER_SIZE, data + RTP_HEADER_SIZE,
-                            length - RTP_HEADER_SIZE));
+        return session->mcb(session->m->mono_time, session->cs, new_message(&header, length - RTP_HEADER_SIZE,
+                            data + RTP_HEADER_SIZE, length - RTP_HEADER_SIZE));
     }
 
     /* The message is sent in multiple parts */
@@ -542,7 +542,7 @@ static int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t
                 /* Received a full message; now push it for the further
                  * processing.
                  */
-                session->mcb(session->cs, session->mp);
+                session->mcb(session->m->mono_time, session->cs, session->mp);
                 session->mp = nullptr;
             }
         } else {
@@ -555,7 +555,7 @@ static int handle_rtp_packet(Messenger *m, uint32_t friendnumber, const uint8_t
             }
 
             /* Push the previous message for processing */
-            session->mcb(session->cs, session->mp);
+            session->mcb(session->m->mono_time, session->cs, session->mp);
 
             session->mp = nullptr;
             goto NEW_MULTIPARTED;
@@ -760,7 +760,7 @@ int rtp_send_data(RTPSession *session, const uint8_t *data, uint32_t length,
 
     header.sequnum = session->sequnum;
 
-    header.timestamp = current_time_monotonic();
+    header.timestamp = current_time_monotonic(session->m->mono_time);
 
     header.ssrc = session->ssrc;
 
diff --git a/toxav/rtp.h b/toxav/rtp.h
index 225f4c03..42997594 100644
--- a/toxav/rtp.h
+++ b/toxav/rtp.h
@@ -159,7 +159,7 @@ struct RTPWorkBufferList {
 
 #define DISMISS_FIRST_LOST_VIDEO_PACKET_COUNT 10
 
-typedef int rtp_m_cb(void *cs, struct RTPMessage *msg);
+typedef int rtp_m_cb(const Mono_Time *mono_time, void *cs, struct RTPMessage *msg);
 
 /**
  * RTP control session.
diff --git a/toxav/toxav.c b/toxav/toxav.c
index 84e67858..19648936 100644
--- a/toxav/toxav.c
+++ b/toxav/toxav.c
@@ -248,7 +248,7 @@ void toxav_iterate(ToxAV *av)
         return;
     }
 
-    uint64_t start = current_time_monotonic();
+    uint64_t start = current_time_monotonic(av->m->mono_time);
     int32_t rc = 500;
 
     ToxAVCall *i = av->calls[av->calls_head];
@@ -286,7 +286,7 @@ void toxav_iterate(ToxAV *av)
     pthread_mutex_unlock(av->mutex);
 
     av->interval = rc < av->dmssa ? 0 : (rc - av->dmssa);
-    av->dmsst += current_time_monotonic() - start;
+    av->dmsst += current_time_monotonic(av->m->mono_time) - start;
 
     if (++av->dmssc == 3) {
         av->dmssa = av->dmsst / 3 + 5 /* NOTE Magic Offset for precission */;
@@ -1325,7 +1325,7 @@ bool call_prepare_transmission(ToxAVCall *call)
     call->bwc = bwc_new(av->m, call->friend_number, callback_bwc, call);
 
     { /* Prepare audio */
-        call->audio = ac_new(av->m->log, av, call->friend_number, av->acb, av->acb_user_data);
+        call->audio = ac_new(av->m->mono_time, av->m->log, av, call->friend_number, av->acb, av->acb_user_data);
 
         if (!call->audio) {
             LOGGER_ERROR(av->m->log, "Failed to create audio codec session");
@@ -1341,7 +1341,7 @@ bool call_prepare_transmission(ToxAVCall *call)
         }
     }
     { /* Prepare video */
-        call->video = vc_new(av->m->log, av, call->friend_number, av->vcb, av->vcb_user_data);
+        call->video = vc_new(av->m->mono_time, av->m->log, av, call->friend_number, av->vcb, av->vcb_user_data);
 
         if (!call->video) {
             LOGGER_ERROR(av->m->log, "Failed to create video codec session");
diff --git a/toxav/video.c b/toxav/video.c
index 94f10230..bc164cea 100644
--- a/toxav/video.c
+++ b/toxav/video.c
@@ -159,7 +159,8 @@ static void vc_init_encoder_cfg(const Logger *log, vpx_codec_enc_cfg_t *cfg, int
 #endif
 }
 
-VCSession *vc_new(const Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb, void *cb_data)
+VCSession *vc_new(const Mono_Time *mono_time, const Logger *log, ToxAV *av, uint32_t friend_number,
+                  toxav_video_receive_frame_cb *cb, void *cb_data)
 {
     VCSession *vc = (VCSession *)calloc(sizeof(VCSession), 1);
     vpx_codec_err_t rc;
@@ -264,7 +265,7 @@ VCSession *vc_new(const Logger *log, ToxAV *av, uint32_t friend_number, toxav_vi
           goto BASE_CLEANUP_1;
       }
      */
-    vc->linfts = current_time_monotonic();
+    vc->linfts = current_time_monotonic(mono_time);
     vc->lcfd = 60;
     vc->vcb = cb;
     vc->vcb_user_data = cb_data;
@@ -355,7 +356,7 @@ void vc_iterate(VCSession *vc)
     }
 }
 
-int vc_queue_message(void *vcp, struct RTPMessage *msg)
+int vc_queue_message(const Mono_Time *mono_time, void *vcp, struct RTPMessage *msg)
 {
     /* This function is called with complete messages
      * they have already been assembled.
@@ -389,9 +390,9 @@ int vc_queue_message(void *vcp, struct RTPMessage *msg)
     free(rb_write(vc->vbuf_raw, msg));
 
     /* Calculate time it took for peer to send us this frame */
-    uint32_t t_lcfd = current_time_monotonic() - vc->linfts;
+    uint32_t t_lcfd = current_time_monotonic(mono_time) - vc->linfts;
     vc->lcfd = t_lcfd > 100 ? vc->lcfd : t_lcfd;
-    vc->linfts = current_time_monotonic();
+    vc->linfts = current_time_monotonic(mono_time);
     pthread_mutex_unlock(vc->queue_mutex);
     return 0;
 }
diff --git a/toxav/video.h b/toxav/video.h
index 898c986a..14d866d1 100644
--- a/toxav/video.h
+++ b/toxav/video.h
@@ -60,11 +60,11 @@ typedef struct VCSession_s {
     pthread_mutex_t queue_mutex[1];
 } VCSession;
 
-VCSession *vc_new(const Logger *log, ToxAV *av, uint32_t friend_number, toxav_video_receive_frame_cb *cb,
-                  void *cb_data);
+VCSession *vc_new(const Mono_Time *mono_time, const Logger *log, ToxAV *av, uint32_t friend_number,
+                  toxav_video_receive_frame_cb *cb, void *cb_data);
 void vc_kill(VCSession *vc);
 void vc_iterate(VCSession *vc);
-int vc_queue_message(void *vcp, struct RTPMessage *msg);
+int vc_queue_message(const Mono_Time *mono_time, void *vcp, struct RTPMessage *msg);
 int vc_reconfigure_encoder(VCSession *vc, uint32_t bit_rate, uint16_t width, uint16_t height, int16_t kf_max_dist);
 
 #endif /* VIDEO_H */
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;