From: Arran Cudbard-Bell <a.cudbardb@freeradius.org>
Date: Thu, 23 Sep 2021 16:35:06 +0000 (-0500)
Subject: Switch fr_time_t to use a struct to detect misuses
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=5e9217f8f08553134f922180aef3daec27dbcbac;p=thirdparty%2Ffreeradius-server.git

Switch fr_time_t to use a struct to detect misuses
---

diff --git a/src/bin/radclient.c b/src/bin/radclient.c
index a9386825ae..512f115f86 100644
--- a/src/bin/radclient.c
+++ b/src/bin/radclient.c
@@ -870,7 +870,7 @@ static int send_one_packet(rc_request_t *request)
 		request->resend++;
 
 	} else {		/* request->packet->id >= 0 */
-		fr_time_delta_t now = fr_time();
+		fr_time_t now = fr_time();
 
 		/*
 		 *	FIXME: Accounting packets are never retried!
@@ -882,15 +882,15 @@ static int send_one_packet(rc_request_t *request)
 		/*
 		 *	Not time for a retry, do so.
 		 */
-		if ((now - request->timestamp) < timeout) {
+		if (fr_time_sub(now, request->timestamp) < timeout) {
 			/*
 			 *	When we walk over the tree sending
 			 *	packets, we update the minimum time
 			 *	required to sleep.
 			 */
 			if ((sleep_time == -1) ||
-			    (sleep_time > (now - request->timestamp))) {
-				sleep_time = now - request->timestamp;
+			    (sleep_time > fr_time_sub(now, request->timestamp))) {
+				sleep_time = fr_time_sub(now, request->timestamp);
 			}
 			return 0;
 		}
@@ -947,7 +947,7 @@ static int send_one_packet(rc_request_t *request)
 /*
  *	Receive one packet, maybe.
  */
-static int recv_one_packet(fr_time_t wait_time)
+static int recv_one_packet(fr_time_delta_t wait_time)
 {
 	fd_set			set;
 	fr_time_delta_t		our_wait_time;
@@ -961,7 +961,7 @@ static int recv_one_packet(fr_time_t wait_time)
 	max_fd = fr_packet_list_fd_set(packet_list, &set);
 	if (max_fd < 0) fr_exit_now(1); /* no sockets to listen on! */
 
-	our_wait_time = (wait_time <= 0) ? 0 : wait_time;
+	our_wait_time = wait_time <= 0 ? fr_time_delta_from_sec(0) : wait_time;
 
 	/*
 	 *	No packet was received.
diff --git a/src/bin/radclient.h b/src/bin/radclient.h
index 45f3f967e7..e6c3a092f7 100644
--- a/src/bin/radclient.h
+++ b/src/bin/radclient.h
@@ -76,7 +76,7 @@ struct rc_request {
 	rc_file_pair_t		*files;		//!< Request and response file names.
 
 	fr_pair_t		*password;	//!< Password.Cleartext
-	fr_time_delta_t		timestamp;
+	fr_time_t		timestamp;
 
 	fr_radius_packet_t	*packet;	//!< The outgoing request.
 	fr_radius_packet_t	*reply;		//!< The incoming response.
diff --git a/src/bin/radiusd.c b/src/bin/radiusd.c
index bab2292989..669f2fbc8f 100644
--- a/src/bin/radiusd.c
+++ b/src/bin/radiusd.c
@@ -175,7 +175,7 @@ static void fr_exit_after(fr_event_list_t *el, fr_time_t now, void *uctx)
 
 	fr_time_delta_t	exit_after = *(fr_time_delta_t *)uctx;
 
-	if (now == 0) {
+	if (fr_time_eq(now, fr_time_wrap(0))) {
 		if (fr_event_timer_in(el, el, &ev, exit_after, fr_exit_after, uctx) < 0) {
 			PERROR("Failed inserting exit event");
 		}
@@ -921,7 +921,7 @@ int main(int argc, char *argv[])
 
 	fr_time_sync_event(main_loop_event_list(), fr_time(), NULL);
 #ifndef NDEBUG
-	if (exit_after > 0) fr_exit_after(main_loop_event_list(), 0, &exit_after);
+	if (exit_after > 0) fr_exit_after(main_loop_event_list(), fr_time_wrap(0), &exit_after);
 #endif
 	/*
 	 *  Process requests until HUP or exit.
diff --git a/src/bin/radlock.c b/src/bin/radlock.c
index d5470936e5..b58eeb4e5f 100644
--- a/src/bin/radlock.c
+++ b/src/bin/radlock.c
@@ -287,12 +287,12 @@ int main(int argc, char *argv[])
 		INFO("\tUser          : %s (%u)", uid_str, info.sem_perm.uid);
 		INFO("\tGroup         : %s (%u)", gid_str, info.sem_perm.gid);
 		INFO("\tTime          : %s",
-		     fr_asprintf(autofree, "%pV", fr_box_date(fr_time_from_sec(info.sem_otime))));
+		     fr_asprintf(autofree, "%pV", fr_box_time(fr_time_from_sec(info.sem_otime))));
 		INFO("Created:");
 		INFO("\tUser          : %s (%u)", cuid_str, info.sem_perm.cuid);
 		INFO("\tGroup         : %s (%u)", cgid_str, info.sem_perm.cgid);
 		INFO("\tTime          : %s",
-		     fr_asprintf(autofree, "%pV", fr_box_date(fr_time_from_sec(info.sem_ctime))));
+		     fr_asprintf(autofree, "%pV", fr_box_time(fr_time_from_sec(info.sem_ctime))));
 	}
 		EXIT_WITH_SUCCESS;
 
diff --git a/src/bin/radmin.c b/src/bin/radmin.c
index 305059d809..5661320431 100644
--- a/src/bin/radmin.c
+++ b/src/bin/radmin.c
@@ -418,7 +418,7 @@ static void *fr_radmin(UNUSED void *input_ctx)
 /** radmin functions, tables, and callbacks
  *
  */
-static fr_time_delta_t start_time;
+static fr_time_t start_time;
 
 static int cmd_exit(UNUSED FILE *fp, UNUSED FILE *fp_err, UNUSED void *ctx, UNUSED fr_cmd_info_t const *info)
 {
@@ -458,7 +458,7 @@ static int cmd_uptime(FILE *fp, UNUSED FILE *fp_err, UNUSED void *ctx, UNUSED fr
 {
 	fr_time_delta_t uptime;
 
-	uptime = fr_time() - start_time;
+	uptime = fr_time_sub(fr_time(), start_time);
 
 	fr_fprintf(fp, "Uptime: %pVs seconds\n", fr_box_time_delta(uptime));
 
diff --git a/src/bin/radsniff.c b/src/bin/radsniff.c
index 6448731fc5..05d7bce394 100644
--- a/src/bin/radsniff.c
+++ b/src/bin/radsniff.c
@@ -1775,7 +1775,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt
 	 *	It's a linked response
 	 */
 	if (original && original->linked) {
-		latency = fr_time_delta_to_timeval(packet->timestamp - original->packet->timestamp);
+		latency = fr_time_delta_to_timeval(fr_time_sub(packet->timestamp, original->packet->timestamp));
 
 		/*
 		 *	Update stats for both the request and response types.
@@ -1858,7 +1858,7 @@ static void rs_packet_process(uint64_t count, rs_event_t *event, struct pcap_pkt
 static void rs_got_packet(fr_event_list_t *el, int fd, UNUSED int flags, void *ctx)
 {
 	static uint64_t		count = 0;	/* Packets seen */
-	static fr_time_t	last_sync = 0;
+	static fr_time_t	last_sync = fr_time_wrap(0);
 	fr_time_t		now_real;
 	rs_event_t		*event = talloc_get_type(ctx, rs_event_t);
 	pcap_t			*handle = event->in->handle;
@@ -1875,7 +1875,7 @@ static void rs_got_packet(fr_event_list_t *el, int fd, UNUSED int flags, void *c
 	 *	event ourselves.
 	 */
 	now_real = fr_time();
-	if ((now_real - last_sync) > fr_time_delta_from_sec(1)) {
+	if (fr_time_sub(now_real, last_sync) > fr_time_delta_from_sec(1)) {
 		fr_time_sync();
 		last_sync = now_real;
 	}
@@ -1948,7 +1948,7 @@ static void rs_got_packet(fr_event_list_t *el, int fd, UNUSED int flags, void *c
 	}
 }
 
-static int  _rs_event_status(fr_time_delta_t wake_t, UNUSED void *uctx)
+static int  _rs_event_status(UNUSED fr_time_t now, fr_time_delta_t wake_t, UNUSED void *uctx)
 {
 	struct timeval wake;
 
@@ -2126,7 +2126,8 @@ static void rs_collectd_reopen(fr_event_list_t *el, fr_time_t now, UNUSED void *
 	ERROR("Will attempt to re-establish connection in %i ms", RS_SOCKET_REOPEN_DELAY);
 
 	if (fr_event_timer_at(NULL, el, &event,
-			      now + fr_time_delta_from_msec(RS_SOCKET_REOPEN_DELAY), rs_collectd_reopen, el) < 0) {
+			      fr_time_add(now, fr_time_delta_from_msec(RS_SOCKET_REOPEN_DELAY)),
+			      rs_collectd_reopen, el) < 0) {
 		ERROR("Failed inserting re-open event");
 		RS_ASSERT(0);
 	}
diff --git a/src/bin/radsnmp.c b/src/bin/radsnmp.c
index da3d7e2ab8..02be4a7d2d 100644
--- a/src/bin/radsnmp.c
+++ b/src/bin/radsnmp.c
@@ -90,7 +90,7 @@ typedef struct {
 	uint16_t		server_port;		//!< Port to send requests to.
 
 	unsigned int		retries;		//!< Number of retries.
-	fr_time_t		timeout;
+	fr_time_delta_t		timeout;
 	char			*secret;		//!< Shared secret.
 } radsnmp_conf_t;
 
diff --git a/src/lib/eap/session.c b/src/lib/eap/session.c
index e2294aa8d4..bfd7235e94 100644
--- a/src/lib/eap/session.c
+++ b/src/lib/eap/session.c
@@ -50,7 +50,7 @@ static int _eap_session_free(eap_session_t *eap_session)
 	 *	retransmit which nukes our ID, and therefore our state.
 	 */
 	if (((request && RDEBUG_ENABLED) || (!request && DEBUG_ENABLED)) &&
-	    (eap_session->tls && !eap_session->finished && ((fr_time() - eap_session->updated) > (((fr_time_t) 3) * NSEC)))) {
+	    (eap_session->tls && !eap_session->finished && (fr_time_sub(fr_time(), eap_session->updated) > fr_time_delta_from_sec(3)))) {
 		ROPTIONAL(RWDEBUG, WARN, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 		ROPTIONAL(RWDEBUG, WARN, "!! EAP session %016" PRIxPTR " did not finish!                   !!",
 			  (uintptr_t)eap_session);
diff --git a/src/lib/io/channel.c b/src/lib/io/channel.c
index a21added6d..ec23e4efd3 100644
--- a/src/lib/io/channel.c
+++ b/src/lib/io/channel.c
@@ -142,8 +142,8 @@ typedef struct fr_channel_s fr_channel_t;
  * and an atomic queue in each direction to allow for bidirectional communication.
  */
 struct fr_channel_s {
-	fr_time_t		cpu_time;	//!< Total time used by the responder for this channel.
-	fr_time_t		processing_time; //!< Time spent by the responder processing requests.
+	fr_time_delta_t		cpu_time;	//!< Total time used by the responder for this channel.
+	fr_time_delta_t		processing_time; //!< Time spent by the responder processing requests.
 
 	bool			same_thread;	//!< are both ends in the same thread?
 
@@ -152,12 +152,12 @@ struct fr_channel_s {
 
 fr_table_num_sorted_t const channel_signals[] = {
 	{ L("error"),			FR_CHANNEL_ERROR			},
-	{ L("data-to-responder"),		FR_CHANNEL_SIGNAL_DATA_TO_RESPONDER	},
-	{ L("data-to-requestor"),		FR_CHANNEL_DATA_READY_REQUESTOR		},
+	{ L("data-to-responder"),	FR_CHANNEL_SIGNAL_DATA_TO_RESPONDER	},
+	{ L("data-to-requestor"),	FR_CHANNEL_DATA_READY_REQUESTOR		},
 	{ L("open"),			FR_CHANNEL_OPEN				},
 	{ L("close"),			FR_CHANNEL_CLOSE			},
 	{ L("data-done-responder"),	FR_CHANNEL_SIGNAL_DATA_DONE_RESPONDER	},
-	{ L("responder-sleeping"),		FR_CHANNEL_SIGNAL_RESPONDER_SLEEPING	},
+	{ L("responder-sleeping"),	FR_CHANNEL_SIGNAL_RESPONDER_SLEEPING	},
 };
 size_t channel_signals_len = NUM_ELEMENTS(channel_signals);
 
@@ -306,7 +306,8 @@ static int fr_channel_data_ready(fr_channel_t *ch, fr_time_t when, fr_channel_en
 int fr_channel_send_request(fr_channel_t *ch, fr_channel_data_t *cd)
 {
 	uint64_t sequence;
-	fr_time_t when, message_interval;
+	fr_time_t when;
+	fr_time_delta_t message_interval;
 	fr_channel_end_t *requestor;
 
 	if (!fr_cond_assert_msg(atomic_load(&ch->end[TO_RESPONDER].active), "Channel not active")) return -1;
@@ -338,7 +339,7 @@ int fr_channel_send_request(fr_channel_t *ch, fr_channel_data_t *cd)
 	}
 
 	requestor->sequence = sequence;
-	message_interval = when - requestor->stats.last_write;
+	message_interval = fr_time_sub(when, requestor->stats.last_write);
 
 	if (!requestor->stats.message_interval) {
 		requestor->stats.message_interval = message_interval;
@@ -346,9 +347,9 @@ int fr_channel_send_request(fr_channel_t *ch, fr_channel_data_t *cd)
 		requestor->stats.message_interval = RTT(requestor->stats.message_interval, message_interval);
 	}
 
-	fr_assert_msg(requestor->stats.last_write <= when,
+	fr_assert_msg(fr_time_lteq(requestor->stats.last_write, when),
 		      "Channel data timestamp (%" PRId64") older than last channel data sent (%" PRId64 ")",
-		      when, requestor->stats.last_write);
+		      fr_time_unwrap(when), fr_time_unwrap(requestor->stats.last_write));
 	requestor->stats.last_write = when;
 
 	requestor->stats.outstanding++;
@@ -452,7 +453,7 @@ bool fr_channel_recv_reply(fr_channel_t *ch)
 	requestor->ack = cd->live.sequence;
 	requestor->their_view_of_my_sequence = cd->live.ack;
 
-	fr_assert(requestor->stats.last_read_other <= cd->m.when);
+	fr_assert(fr_time_lteq(requestor->stats.last_read_other, cd->m.when));
 	requestor->stats.last_read_other = cd->m.when;
 
 	ch->end[TO_RESPONDER].recv(ch->end[TO_RESPONDER].recv_uctx, ch, cd);
@@ -489,7 +490,7 @@ bool fr_channel_recv_request(fr_channel_t *ch)
 	responder->ack = cd->live.sequence;
 	responder->their_view_of_my_sequence = cd->live.ack;
 
-	fr_assert(responder->stats.last_read_other <= cd->m.when);
+	fr_assert(fr_time_lteq(responder->stats.last_read_other, cd->m.when));
 	responder->stats.last_read_other = cd->m.when;
 
 	ch->end[TO_REQUESTOR].recv(ch->end[TO_REQUESTOR].recv_uctx, ch, cd);
@@ -510,7 +511,8 @@ bool fr_channel_recv_request(fr_channel_t *ch)
 int fr_channel_send_reply(fr_channel_t *ch, fr_channel_data_t *cd)
 {
 	uint64_t		sequence;
-	fr_time_t		when, message_interval;
+	fr_time_t		when;
+	fr_time_delta_t		message_interval;
 	fr_channel_end_t	*responder;
 
 	if (!fr_cond_assert_msg(atomic_load(&ch->end[TO_REQUESTOR].active), "Channel not active")) return -1;
@@ -545,12 +547,12 @@ int fr_channel_send_reply(fr_channel_t *ch, fr_channel_data_t *cd)
 	MPRINT("\tRESPONDER replies %"PRIu64", num_outstanding %"PRIu64"\n", responder->stats.packets, responder->stats.outstanding);
 
 	responder->sequence = sequence;
-	message_interval = when - responder->stats.last_write;
+	message_interval = fr_time_sub(when, responder->stats.last_write);
 	responder->stats.message_interval = RTT(responder->stats.message_interval, message_interval);
 
-	fr_assert_msg(responder->stats.last_write <= when,
+	fr_assert_msg(fr_time_lteq(responder->stats.last_write, when),
 		      "Channel data timestamp (%" PRId64") older than last channel data sent (%" PRId64 ")",
-		      when, responder->stats.last_write);
+		      fr_time_unwrap(when), fr_time_unwrap(responder->stats.last_write));
 	responder->stats.last_write = when;
 
 	/*
@@ -967,16 +969,16 @@ void fr_channel_stats_log(fr_channel_t const *ch, fr_log_t const *log, char cons
 	fr_log(log, L_INFO, file, line, "\toutstanding = %" PRIu64 "\n", ch->end[TO_RESPONDER].stats.outstanding);
 	fr_log(log, L_INFO, file, line, "\tpackets processed = %" PRIu64 "\n", ch->end[TO_RESPONDER].stats.packets);
 	fr_log(log, L_INFO, file, line, "\tmessage interval (RTT) = %" PRIu64 "\n", ch->end[TO_RESPONDER].stats.message_interval);
-	fr_log(log, L_INFO, file, line, "\tlast write = %" PRIu64 "\n", ch->end[TO_RESPONDER].stats.last_read_other);
-	fr_log(log, L_INFO, file, line, "\tlast read other end = %" PRIu64 "\n", ch->end[TO_RESPONDER].stats.last_read_other);
-	fr_log(log, L_INFO, file, line, "\tlast signal other = %" PRIu64 "\n", ch->end[TO_RESPONDER].stats.last_sent_signal);
+	fr_log(log, L_INFO, file, line, "\tlast write = %" PRIu64 "\n", fr_time_unwrap(ch->end[TO_RESPONDER].stats.last_read_other));
+	fr_log(log, L_INFO, file, line, "\tlast read other end = %" PRIu64 "\n", fr_time_unwrap(ch->end[TO_RESPONDER].stats.last_read_other));
+	fr_log(log, L_INFO, file, line, "\tlast signal other = %" PRIu64 "\n", fr_time_unwrap(ch->end[TO_RESPONDER].stats.last_sent_signal));
 
 	fr_log(log, L_INFO, file, line, "responder\n");
 	fr_log(log, L_INFO, file, line, "\tsignals sent = %" PRIu64"\n", ch->end[TO_REQUESTOR].stats.signals);
 	fr_log(log, L_INFO, file, line, "\tkevents checked = %" PRIu64 "\n", ch->end[TO_REQUESTOR].stats.kevents);
 	fr_log(log, L_INFO, file, line, "\tpackets processed = %" PRIu64 "\n", ch->end[TO_REQUESTOR].stats.packets);
 	fr_log(log, L_INFO, file, line, "\tmessage interval (RTT) = %" PRIu64 "\n", ch->end[TO_REQUESTOR].stats.message_interval);
-	fr_log(log, L_INFO, file, line, "\tlast write = %" PRIu64 "\n", ch->end[TO_REQUESTOR].stats.last_read_other);
-	fr_log(log, L_INFO, file, line, "\tlast read other end = %" PRIu64 "\n", ch->end[TO_REQUESTOR].stats.last_read_other);
-	fr_log(log, L_INFO, file, line, "\tlast signal other = %" PRIu64 "\n", ch->end[TO_REQUESTOR].stats.last_sent_signal);
+	fr_log(log, L_INFO, file, line, "\tlast write = %" PRIu64 "\n", fr_time_unwrap(ch->end[TO_REQUESTOR].stats.last_read_other));
+	fr_log(log, L_INFO, file, line, "\tlast read other end = %" PRIu64 "\n", fr_time_unwrap(ch->end[TO_REQUESTOR].stats.last_read_other));
+	fr_log(log, L_INFO, file, line, "\tlast signal other = %" PRIu64 "\n", fr_time_unwrap(ch->end[TO_REQUESTOR].stats.last_sent_signal));
 }
diff --git a/src/lib/io/channel.h b/src/lib/io/channel.h
index 095e84b3dd..87721b276b 100644
--- a/src/lib/io/channel.h
+++ b/src/lib/io/channel.h
@@ -132,9 +132,9 @@ typedef struct {
 		} request;
 
 		struct {
-			fr_time_delta_t		cpu_time;	//!<  total CPU time, including predicted work, (only worker -> network)
-			fr_time_delta_t		processing_time;  //!< actual processing time for this packet (only worker -> network)
-			fr_time_t		request_time;	//!< timestamp of the request packet
+			fr_time_delta_t		cpu_time;		//!< Total CPU time, including predicted work, (only worker -> network).
+			fr_time_delta_t		processing_time; 	//!< Actual processing time for this packet (only worker -> network).
+			fr_time_t		request_time;		//!< Timestamp of the request packet.
 	        } reply;
 	};
 
diff --git a/src/lib/io/load.c b/src/lib/io/load.c
index 5db1b9aa50..0eeaba29a0 100644
--- a/src/lib/io/load.c
+++ b/src/lib/io/load.c
@@ -108,14 +108,14 @@ static void fr_load_generator_send(fr_load_t *l, fr_time_t now, int count)
 	 *	it more likely that the next timer fires on time.
 	 */
 	for (i = 0; i < count; i++) {
-		l->callback(now + i, l->uctx);
+		l->callback(fr_time_add(now, fr_time_delta_from_nsec(i)), l->uctx);
 	}
 }
 
 static void load_timer(fr_event_list_t *el, fr_time_t now, void *uctx)
 {
 	fr_load_t *l = uctx;
-	fr_time_t delta;
+	fr_time_delta_t delta;
 	int count;
 
 	/*
@@ -128,14 +128,14 @@ static void load_timer(fr_event_list_t *el, fr_time_t now, void *uctx)
 	/*
 	 *	If we're done this step, go to the next one.
 	 */
-	if (l->next >= l->step_end) {
+	if (fr_time_gteq(l->next, l->step_end)) {
 		l->step_start = l->next;
-		l->step_end = l->next + ((uint64_t) l->config->duration) * NSEC;
+		l->step_end = fr_time_add(l->next, l->config->duration);
 		l->step_received = l->stats.received;
 		l->pps += l->config->step;
 		l->stats.pps = l->pps;
 		l->stats.skipped = 0;
-		l->delta = (NSEC * ((uint64_t) l->config->parallel)) / l->pps;
+		l->delta = fr_time_delta_from_sec(l->config->parallel) / l->pps;
 
 		/*
 		 *	Stop at max PPS, if it's set.  Otherwise
@@ -189,14 +189,14 @@ static void load_timer(fr_event_list_t *el, fr_time_t now, void *uctx)
 	/*
 	 *	Skip timers if we're too busy.
 	 */
-	l->next += l->delta;
-	if (l->next < now) {
-		while ((l->next + l->delta) < now) {
+	l->next = fr_time_add(l->next, l->delta);
+	if (fr_time_lt(l->next, now)) {
+		while (fr_time_lt(fr_time_add(l->next, l->delta), now)) {
 //			l->stats.skipped += l->count;
-			l->next += l->delta;
+			l->next = fr_time_add(l->next, l->delta);
 		}
 	}
-	delta = l->next - now;
+	delta = fr_time_sub(l->next, now);
 
 	/*
 	 *	Set the timer for the next packet.
@@ -217,14 +217,14 @@ int fr_load_generator_start(fr_load_t *l)
 {
 	l->stats.start = fr_time();
 	l->step_start = l->stats.start;
-	l->step_end = l->step_start + ((uint64_t) l->config->duration) * NSEC;
+	l->step_end = fr_time_add(l->step_start, l->config->duration);
 
 	l->pps = l->config->start_pps;
 	l->stats.pps = l->pps;
 	l->count = l->config->parallel;
 
 	l->delta = (NSEC * ((uint64_t) l->config->parallel)) / l->pps;
-	l->next = l->step_start + l->delta;
+	l->next = fr_time_add(l->step_start, l->delta);
 
 	load_timer(l->el, l->step_start, l);
 	return 0;
@@ -257,7 +257,7 @@ fr_load_reply_t fr_load_generator_have_reply(fr_load_t *l, fr_time_t request_tim
 	 *	for any kind of timing.
 	 */
 	now = fr_time();
-	t = now - request_time;
+	t = fr_time_sub(now, request_time);
 
 	l->stats.rttvar = RTTVAR(l->stats.rtt, l->stats.rttvar, t);
 	l->stats.rtt = RTT(l->stats.rtt, t);
@@ -334,10 +334,10 @@ size_t fr_load_generator_stats_sprint(fr_load_t *l, fr_time_t now, char *buffer,
 	}
 
 
-	now_f = now - l->stats.start;
+	now_f = fr_time_sub(now, l->stats.start);
 	now_f /= NSEC;
 
-	last_send_f = l->stats.last_send - l->stats.start;
+	last_send_f = fr_time_sub(l->stats.last_send, l->stats.start);
 	last_send_f /= NSEC;
 
 	/*
@@ -346,8 +346,8 @@ size_t fr_load_generator_stats_sprint(fr_load_t *l, fr_time_t now, char *buffer,
 	 *	is 1B, the calculations have to be done via 64-bit
 	 *	numbers, and then converted to a final 32-bit counter.
 	 */
-	if (now > l->step_start) {
-		l->stats.pps_accepted = (((uint64_t) (l->stats.received - l->step_received)) * NSEC) / (now - l->step_start);
+	if (fr_time_gt(now, l->step_start)) {
+		l->stats.pps_accepted = fr_time_delta_from_sec(l->stats.received - l->step_received) / fr_time_sub(now, l->step_start);
 	}
 
 	return snprintf(buffer, buflen,
diff --git a/src/lib/io/load.h b/src/lib/io/load.h
index aa873f94d4..98791f5f9a 100644
--- a/src/lib/io/load.h
+++ b/src/lib/io/load.h
@@ -72,7 +72,7 @@ RCSIDH(load_h, "$Id$")
 typedef struct {
 	uint32_t       	start_pps;	//!< start PPS
 	uint32_t       	max_pps;	//!< max PPS, 0 for "no limit".
-	uint32_t       	duration;	//!< duration of each step
+	fr_time_delta_t	duration;	//!< duration of each step
 	uint32_t	step;		//!< how much to increase each load test by
 	uint32_t	parallel;	//!< how many packets in parallel to send
 	uint32_t	milliseconds;	//!< how many milliseconds of backlog to top out at
diff --git a/src/lib/io/master.c b/src/lib/io/master.c
index 28930faaef..f131f003fd 100644
--- a/src/lib/io/master.c
+++ b/src/lib/io/master.c
@@ -197,7 +197,7 @@ static int8_t pending_packet_cmp(void const *one, void const *two)
 	 *	packets go in.  Since we'll never have two identical
 	 *	"recv_time" values, the code should never get here.
 	 */
-	return CMP_PREFER_SMALLER(a->recv_time, b->recv_time);
+	return CMP_PREFER_SMALLER(fr_time_unwrap(a->recv_time), fr_time_unwrap(b->recv_time));
 }
 
 /*
@@ -1102,17 +1102,17 @@ static int _client_live_free(fr_io_client_t *client)
 static ssize_t mod_read(fr_listen_t *li, void **packet_ctx, fr_time_t *recv_time_p,
 			uint8_t *buffer, size_t buffer_len, size_t *leftover, uint32_t *priority, bool *is_dup)
 {
-	fr_io_instance_t const *inst;
-	fr_io_thread_t *thread;
-	ssize_t packet_len = -1;
-	fr_time_t recv_time = 0;
-	fr_io_client_t *client;
-	fr_io_address_t address;
-	fr_io_connection_t my_connection, *connection;
-	fr_io_pending_packet_t *pending;
-	fr_io_track_t *track, *new_track;
-	fr_listen_t *child;
-	int value, accept_fd = -1;
+	fr_io_instance_t const	*inst;
+	fr_io_thread_t		*thread;
+	ssize_t			packet_len = -1;
+	fr_time_t		recv_time = fr_time_wrap(0);
+	fr_io_client_t		*client;
+	fr_io_address_t		address;
+	fr_io_connection_t	my_connection, *connection;
+	fr_io_pending_packet_t	*pending;
+	fr_io_track_t		*track, *new_track;
+	fr_listen_t		*child;
+	int			value, accept_fd = -1;
 
 	fr_assert(is_dup != NULL);
 	*is_dup = false;
@@ -1175,7 +1175,7 @@ redo:
 		 *	it's fast, but also that it's hard to look up
 		 *	random packets in the pending heap.
 		 */
-		if (pending->recv_time != track->timestamp) {
+		if (fr_time_neq(pending->recv_time, track->timestamp)) {
 			DEBUG3("Discarding old packet");
 			talloc_free(pending);
 			goto redo;
@@ -1896,7 +1896,7 @@ static void client_expiry_timer(fr_event_list_t *el, fr_time_t now, void *uctx)
 	 *	Called from the read or write functions with
 	 *	now==0, to signal that we have to *set* the timer.
 	 */
-	if (!now) {
+	if (fr_time_eq(now, fr_time_wrap(0))) {
 		switch (client->state) {
 		case PR_CLIENT_CONNECTED:
 			fr_assert(connection != NULL);
@@ -2083,11 +2083,11 @@ static void packet_expiry_timer(fr_event_list_t *el, fr_time_t now, void *uctx)
 	 *
 	 *	On duplicates this also extends the expiry timer.
 	 */
-	if (!now && !track->discard && inst->app_io->track_duplicates) {
+	if (fr_time_eq(now, fr_time_wrap(0)) && !track->discard && inst->app_io->track_duplicates) {
 		fr_assert(inst->cleanup_delay > 0);
 		fr_assert(track->do_not_respond || track->reply_len);
 
-		track->expires = fr_time() + inst->cleanup_delay;
+		track->expires = fr_time_add(fr_time(), inst->cleanup_delay);
 
 		/*
 		 *	if the timer succeeds, then "track"
@@ -2109,7 +2109,7 @@ static void packet_expiry_timer(fr_event_list_t *el, fr_time_t now, void *uctx)
 	 *	So that all cleanup paths can come here, not just the
 	 *	timeout ones.
 	 */
-	if (now) {
+	if (fr_time_neq(now, fr_time_wrap(0))) {
 		DEBUG2("TIMER - proto_%s - cleanup delay", inst->app_io->name);
 	} else {
 		DEBUG2("proto_%s - cleaning up", inst->app_io->name);
@@ -2170,7 +2170,7 @@ static ssize_t mod_write(fr_listen_t *li, void *packet_ctx, fr_time_t request_ti
 		 *	The request later received a conflicting
 		 *	packet, so we discard this one.
 		 */
-		if ((track->timestamp != request_time) || track->discard) {
+		if (fr_time_neq(track->timestamp, request_time) || track->discard) {
 			fr_assert(track->packets > 0);
 			track->packets--;
 
@@ -2199,7 +2199,7 @@ static ssize_t mod_write(fr_listen_t *li, void *packet_ctx, fr_time_t request_ti
 						 buffer, buffer_len, written);
 		if (packet_len <= 0) {
 			track->discard = true;
-			packet_expiry_timer(el, 0, track);
+			packet_expiry_timer(el, fr_time_wrap(0), track);
 			return packet_len;
 		}
 
@@ -2235,7 +2235,7 @@ static ssize_t mod_write(fr_listen_t *li, void *packet_ctx, fr_time_t request_ti
 		 *	On dedup this also extends the timer.
 		 */
 	setup_timer:
-		packet_expiry_timer(el, 0, track);
+		packet_expiry_timer(el, fr_time_wrap(0), track);
 		return buffer_len;
 	}
 
@@ -2283,7 +2283,7 @@ static ssize_t mod_write(fr_listen_t *li, void *packet_ctx, fr_time_t request_ti
 		 */
 		if (connection && (inst->ipproto == IPPROTO_UDP)) {
 			connection = fr_io_connection_alloc(inst, thread, client, -1, connection->address, connection);
-			client_expiry_timer(el, 0, connection->client);
+			client_expiry_timer(el, fr_time_wrap(0), connection->client);
 
 			errno = ECONNREFUSED;
 			return -1;
@@ -2294,7 +2294,7 @@ static ssize_t mod_write(fr_listen_t *li, void *packet_ctx, fr_time_t request_ti
 		 *	expiry timer, which will close and free the
 		 *	connection.
 		 */
-		client_expiry_timer(el, 0, client);
+		client_expiry_timer(el, fr_time_wrap(0), client);
 		return buffer_len;
 	}
 
@@ -2490,7 +2490,7 @@ finish:
 	 *	timed out, so there's nothing more to do.  In that case, set up the expiry timers.
 	 */
 	if (client->packets == 0) {
-		client_expiry_timer(el, 0, client);
+		client_expiry_timer(el, fr_time_wrap(0), client);
 	}
 
 reread:
diff --git a/src/lib/io/network.c b/src/lib/io/network.c
index d338b4d33b..fb37a88609 100644
--- a/src/lib/io/network.c
+++ b/src/lib/io/network.c
@@ -61,8 +61,8 @@ typedef struct {
  */
 typedef struct {
 	fr_heap_index_t		heap_id;		//!< workers are in a heap
-	fr_time_t		cpu_time;		//!< how much CPU time this worker has spent
-	fr_time_t		predicted;		//!< predicted processing time for one packet
+	fr_time_delta_t		cpu_time;		//!< how much CPU time this worker has spent
+	fr_time_delta_t		predicted;		//!< predicted processing time for one packet
 
 	bool			blocked;		//!< is this worker blocked?
 
@@ -148,7 +148,7 @@ struct fr_network_s {
 };
 
 static void fr_network_post_event(fr_event_list_t *el, fr_time_t now, void *uctx);
-static int fr_network_pre_event(fr_time_t wake, void *uctx);
+static int fr_network_pre_event(fr_time_t now, fr_time_delta_t wake, void *uctx);
 static void fr_network_socket_dead(fr_network_t *nr, fr_network_socket_t *s);
 static void fr_network_read(UNUSED fr_event_list_t *el, int sockfd, UNUSED int flags, void *ctx);
 
@@ -157,10 +157,10 @@ static int8_t reply_cmp(void const *one, void const *two)
 	fr_channel_data_t const *a = one, *b = two;
 	int ret;
 
-	ret = (a->priority > b->priority) - (a->priority < b->priority);
+	ret = CMP(a->priority, b->priority);
 	if (ret != 0) return ret;
 
-	return (a->m.when > b->m.when) - (a->m.when < b->m.when);
+	return fr_time_cmp(a->m.when, b->m.when);
 }
 
 static int8_t waiting_cmp(void const *one, void const *two)
@@ -168,10 +168,10 @@ static int8_t waiting_cmp(void const *one, void const *two)
 	fr_channel_data_t const *a = one, *b = two;
 	int ret;
 
-	ret = (a->priority > b->priority) - (a->priority < b->priority);
+	ret = CMP(a->priority, b->priority);
 	if (ret != 0) return ret;
 
-	return (a->reply.request_time > b->reply.request_time) - (a->reply.request_time < b->reply.request_time);
+	return fr_time_cmp(a->reply.request_time, b->reply.request_time);
 }
 
 static int8_t socket_listen_cmp(void const *one, void const *two)
@@ -448,7 +448,7 @@ static void fr_network_recv_reply(void *ctx, fr_channel_t *ch, fr_channel_data_t
 	worker = fr_channel_requestor_uctx_get(ch);
 	worker->stats.out++;
 	worker->cpu_time = cd->reply.cpu_time;
-	if (!worker->predicted) {
+	if (worker->predicted == 0) {
 		worker->predicted = cd->reply.processing_time;
 	} else {
 		worker->predicted = RTT(worker->predicted, cd->reply.processing_time);
@@ -581,7 +581,7 @@ retry:
 		}
 	} else {
 		int i;
-		fr_time_t cpu_time = ~((fr_time_t) 0);
+		fr_time_delta_t cpu_time = ~((fr_time_delta_t) 0);
 		fr_network_worker_t *found = NULL;
 
 		/*
@@ -823,7 +823,7 @@ next_message:
 	 *	Ensure this hasn't been somehow corrupted during
 	 *	ring buffer allocation.
 	 */
-	fr_assert(cd->m.when == now);
+	fr_assert(fr_time_eq(cd->m.when, now));
 
 	if (fr_network_send_request(nr, cd) < 0) {
 		talloc_free(cd->packet_ctx); /* not sure what else to do here */
@@ -1320,10 +1320,11 @@ static void fr_network_inject_callback(void *ctx, void const *data, size_t data_
  *  work, and tell the event code to return to the main loop if
  *  there's work to do.
  *
- * @param[in] wake the time when the event loop will wake up.
- * @param[in] uctx the network
+ * @param[in] now	the current time.
+ * @param[in] wake	the time when the event loop will wake up.
+ * @param[in] uctx	the network
  */
-static int fr_network_pre_event(UNUSED fr_time_t wake, void *uctx)
+static int fr_network_pre_event(UNUSED fr_time_t now, UNUSED fr_time_delta_t wake, void *uctx)
 {
 	fr_network_t *nr = talloc_get_type_abort(uctx, fr_network_t);
 
@@ -1497,7 +1498,7 @@ static void _signal_pipe_read(UNUSED fr_event_list_t *el, int fd, UNUSED int fla
 		return;
 	}
 
-	fr_assert(buff = 1);
+	fr_assert(buff == 1);
 
 	/*
 	 *	fr_network_stop() will signal the workers
diff --git a/src/lib/io/schedule.c b/src/lib/io/schedule.c
index 94bb0b3e79..127b7f1ea9 100644
--- a/src/lib/io/schedule.c
+++ b/src/lib/io/schedule.c
@@ -277,7 +277,7 @@ static void stats_timer(fr_event_list_t *el, fr_time_t now, void *uctx)
 
 	fr_network_stats_log(sn->nr, sn->sc->log);
 
-	(void) fr_event_timer_at(sn, el, &sn->ev, now + sn->sc->config->stats_interval, stats_timer, sn);
+	(void) fr_event_timer_at(sn, el, &sn->ev, fr_time_add(now, sn->sc->config->stats_interval), stats_timer, sn);
 }
 
 /** Initialize and run the network thread.
diff --git a/src/lib/io/time_tracking.h b/src/lib/io/time_tracking.h
index d67f07c749..18fe784965 100644
--- a/src/lib/io/time_tracking.h
+++ b/src/lib/io/time_tracking.h
@@ -84,11 +84,11 @@ struct fr_time_tracking_s {
  */
 #define ASSERT_ON_TIME_TRAVEL(_tt, _now) \
 do { \
-	fr_assert((_tt)->last_changed <= (_now)); \
-	fr_assert((_tt)->started <= (_now)); \
-	fr_assert((_tt)->ended <= (_now)); \
-	fr_assert((_tt)->last_yielded <= (_now)); \
-	fr_assert((_tt)->last_resumed <= (_now)); \
+	fr_assert(fr_time_lteq((_tt)->last_changed, (_now))); \
+	fr_assert(fr_time_lteq((_tt)->started, (_now))); \
+	fr_assert(fr_time_lteq((_tt)->ended, (_now))); \
+	fr_assert(fr_time_lteq((_tt)->last_yielded, (_now))); \
+	fr_assert(fr_time_lteq((_tt)->last_resumed, (_now))); \
 } while(0);
 
 /** Set the last time a tracked entity started in its list of parents
@@ -173,10 +173,10 @@ static inline CC_HINT(nonnull) void fr_time_tracking_push(fr_time_tracking_t *pa
 {
 	fr_time_delta_t		run_time;
 
-	fr_assert(parent->parent = tt->parent);
+	fr_assert(parent->parent == tt->parent);
 
 	fr_assert_msg(tt->state == FR_TIME_TRACKING_RUNNING, "Unexpected time tracking state state %i", tt->state);
-	run_time = now - tt->last_changed;
+	run_time = fr_time_sub(now, tt->last_changed);
 	tt->last_changed = parent->started = now;
 
 	UPDATE_PARENT_RUN_TIME(tt, run_time, last_changed, now);
@@ -196,7 +196,7 @@ static inline CC_HINT(nonnull) void fr_time_tracking_pop(fr_time_tracking_t *tt,
 	fr_time_delta_t		run_time;
 
 	fr_assert_msg(tt->state == FR_TIME_TRACKING_RUNNING, "Unexpected time tracking state state %i", tt->state);
-	run_time = now - tt->last_changed;
+	run_time = fr_time_sub(now, tt->last_changed);
 	tt->last_changed = tt->parent->ended = now;
 
 	tt->running_total += run_time;
@@ -220,7 +220,7 @@ static inline CC_HINT(nonnull) void fr_time_tracking_yield(fr_time_tracking_t *t
 	tt->state = FR_TIME_TRACKING_YIELDED;
 	tt->last_yielded = tt->last_changed = now;
 
-	run_time = now - tt->last_resumed;
+	run_time = fr_time_sub(now, tt->last_resumed);
 	tt->running_total += run_time;
 	UPDATE_PARENT_RUN_TIME(tt, run_time, last_yielded, now);
 }
@@ -240,7 +240,7 @@ static inline CC_HINT(nonnull) void fr_time_tracking_resume(fr_time_tracking_t *
 	tt->state = FR_TIME_TRACKING_RUNNING;
 	tt->last_resumed = tt->last_changed = now;
 
-	wait_time = now - tt->last_yielded;
+	wait_time = fr_time_sub(now, tt->last_yielded);
 	tt->waiting_total += wait_time;
 	UPDATE_PARENT_WAIT_TIME(tt, wait_time, last_resumed, now);
 }
@@ -265,7 +265,7 @@ static inline void fr_time_tracking_end(fr_time_delta_t *predicted,
 	tt->state = FR_TIME_TRACKING_STOPPED;
 	tt->ended = tt->last_changed = now;
 
-	run_time = now - tt->last_resumed;
+	run_time = fr_time_sub(now, tt->last_resumed);
 	tt->running_total += run_time;
 	UPDATE_PARENT_RUN_TIME(tt, run_time, ended, now);
 
@@ -281,14 +281,15 @@ static inline void fr_time_tracking_end(fr_time_delta_t *predicted,
  */
 static inline CC_HINT(nonnull) void fr_time_tracking_debug(fr_time_tracking_t *tt, FILE *fp)
 {
+#define DPRINT_TIME(_x) fprintf(fp, "\t" #_x " = %"PRIu64"\n", fr_time_unwrap(tt->_x));
 #define DPRINT(_x) fprintf(fp, "\t" #_x " = %"PRIu64"\n", tt->_x);
 
-	DPRINT(started);
-	DPRINT(ended);
-	DPRINT(last_changed);
+	DPRINT_TIME(started);
+	DPRINT_TIME(ended);
+	DPRINT_TIME(last_changed);
 
-	DPRINT(last_yielded);
-	DPRINT(last_resumed);
+	DPRINT_TIME(last_yielded);
+	DPRINT_TIME(last_resumed);
 
 	DPRINT(running_total);
 	DPRINT(waiting_total);
diff --git a/src/lib/io/worker.c b/src/lib/io/worker.c
index 4039a0790c..275c76b4e8 100644
--- a/src/lib/io/worker.c
+++ b/src/lib/io/worker.c
@@ -409,9 +409,8 @@ static void worker_max_request_time(UNUSED fr_event_list_t *el, UNUSED fr_time_t
 
 		REQUEST_VERIFY(request);
 
-		cleanup = request->async->recv_time;
-		cleanup += worker->config.max_request_time;
-		if (cleanup > now) break;
+		cleanup = fr_time_add(request->async->recv_time, worker->config.max_request_time);
+		if (fr_time_gt(cleanup, now)) break;
 
 		/*
 		 *	Waiting too long, delete it.
@@ -442,8 +441,7 @@ static void worker_max_request_timer(fr_worker_t *worker)
 	request = fr_heap_peek_tail(worker->time_order);
 	if (!request) return;
 
-	cleanup = request->async->recv_time;
-	cleanup += worker->config.max_request_time;
+	cleanup = fr_time_add(request->async->recv_time, worker->config.max_request_time);
 
 	DEBUG2("Resetting cleanup timer to +%pV", fr_box_time_delta(worker->config.max_request_time));
 	if (fr_event_timer_at(worker, worker->el, &worker->ev_cleanup,
@@ -581,7 +579,7 @@ static void worker_send_reply(fr_worker_t *worker, request_t *request, size_t si
 	/*
 	 *	Update the various timers.
 	 */
-	fr_time_elapsed_update(&worker->cpu_time, now, now + reply->reply.processing_time);
+	fr_time_elapsed_update(&worker->cpu_time, now, fr_time_add(now, reply->reply.processing_time));
 	fr_time_elapsed_update(&worker->wall_clock, reply->reply.request_time, now);
 
 	RDEBUG("Finished request");
@@ -779,7 +777,7 @@ nak:
 		 *	@todo - fix the channel code to do queue
 		 *	depth, and not sequence / ack.
 		 */
-		if (old->async->recv_time == request->async->recv_time) {
+		if (fr_time_eq(old->async->recv_time, request->async->recv_time)) {
 			RWARN("Discarding duplicate of request (%"PRIu64")", old->number);
 
 			fr_channel_null_reply(request->async->channel);
@@ -831,7 +829,7 @@ static int8_t worker_runnable_cmp(void const *one, void const *two)
 	ret = CMP(a->async->sequence, b->async->sequence);
 	if (ret != 0) return ret;
 
-	return CMP(a->async->recv_time, b->async->recv_time);
+	return fr_time_cmp(a->async->recv_time, b->async->recv_time);
 }
 
 /**
@@ -841,7 +839,7 @@ static int8_t worker_time_order_cmp(void const *one, void const *two)
 {
 	request_t const *a = one, *b = two;
 
-	return CMP(a->async->recv_time, b->async->recv_time);
+	return fr_time_cmp(a->async->recv_time, b->async->recv_time);
 }
 
 /**
@@ -1168,7 +1166,7 @@ static inline CC_HINT(always_inline) void worker_run_request(fr_worker_t *worker
 	 *	event loop fewer times per second, instead of after
 	 *	every request.
 	 */
-	while (((now - start) < (NSEC / 100000)) &&
+	while ((fr_time_sub(now, start) < (NSEC / 100000)) &&
 	       ((request = fr_heap_pop(worker->runnable)) != NULL)) {
 
 		REQUEST_VERIFY(request);
@@ -1370,7 +1368,7 @@ void fr_worker(fr_worker_t *worker)
  *
  *	This should be run ONLY in single-threaded mode!
  */
-int fr_worker_pre_event(UNUSED fr_time_t wake, void *uctx)
+int fr_worker_pre_event(UNUSED fr_time_t now, UNUSED fr_time_delta_t wake, void *uctx)
 {
 	fr_worker_t *worker = talloc_get_type_abort(uctx, fr_worker_t);
 	request_t *request;
@@ -1507,7 +1505,7 @@ int fr_worker_stats(fr_worker_t const *worker, int num, uint64_t *stats)
 static int cmd_stats_worker(FILE *fp, UNUSED FILE *fp_err, void *ctx, fr_cmd_info_t const *info)
 {
 	fr_worker_t const *worker = ctx;
-	fr_time_t when;
+	fr_time_delta_t when;
 
 	if ((info->argc == 0) || (strcmp(info->argv[0], "count") == 0)) {
 		fprintf(fp, "count.in\t\t\t%" PRIu64 "\n", worker->stats.in);
diff --git a/src/lib/io/worker.h b/src/lib/io/worker.h
index ef3fc74015..c40b06880b 100644
--- a/src/lib/io/worker.h
+++ b/src/lib/io/worker.h
@@ -77,7 +77,7 @@ void		fr_worker(fr_worker_t *worker) CC_HINT(nonnull);
 
 void		fr_worker_debug(fr_worker_t *worker, FILE *fp) CC_HINT(nonnull);
 
-int		fr_worker_pre_event(fr_time_t wake, void *uctx);
+int		fr_worker_pre_event(fr_time_t now, fr_time_delta_t wake, void *uctx);
 
 void		fr_worker_post_event(fr_event_list_t *el, fr_time_t now, void *uctx);
 
diff --git a/src/lib/redis/cluster.c b/src/lib/redis/cluster.c
index d3a4396506..4f200cd35f 100644
--- a/src/lib/redis/cluster.c
+++ b/src/lib/redis/cluster.c
@@ -1013,7 +1013,7 @@ fr_redis_cluster_rcode_t fr_redis_cluster_remap(request_t *request, fr_redis_clu
 	 *	The remap times are _our_ times, not the _request_ time.
 	 */
 	now = fr_time();
-	if (now == cluster->last_updated) {
+	if (fr_time_eq(now, cluster->last_updated)) {
 	too_soon:
 		ROPTIONAL(RWARN, WARN, "Cluster was updated less than a second ago, ignoring remap request");
 		return FR_REDIS_CLUSTER_RCODE_IGNORED;
@@ -1074,7 +1074,7 @@ fr_redis_cluster_rcode_t fr_redis_cluster_remap(request_t *request, fr_redis_clu
 		fr_redis_reply_free(&map);	/* Free the map */
 		goto in_progress;
 	}
-	if (now == cluster->last_updated) {
+	if (fr_time_eq(now, cluster->last_updated)) {
 		pthread_mutex_unlock(&cluster->mutex);
 		fr_redis_reply_free(&map);	/* Free the map */
 		goto too_soon;
@@ -1197,22 +1197,22 @@ static int cluster_node_pool_health(fr_time_t now, fr_pool_state_t const *state)
 	/*
 	 *	Failed spawn recently, probably bad
 	 */
-	if (fr_time_delta_to_msec(now - state->last_failed) < FAILED_PERIOD) return FAILED_WEIGHT;
+	if (fr_time_delta_to_msec(fr_time_sub(now, state->last_failed)) < FAILED_PERIOD) return FAILED_WEIGHT;
 
 	/*
 	 *	Closed recently, probably bad
 	 */
-	if (fr_time_delta_to_msec(now - state->last_closed) < CLOSED_PERIOD) return CLOSED_WEIGHT;
+	if (fr_time_delta_to_msec(fr_time_sub(now, state->last_closed)) < CLOSED_PERIOD) return CLOSED_WEIGHT;
 
 	/*
 	 *	Released too long ago, don't know
 	 */
-	if (fr_time_delta_to_msec(now - state->last_released) > RELEASED_PERIOD) return RELEASED_MIN_WEIGHT;
+	if (fr_time_delta_to_msec(fr_time_sub(now, state->last_released)) > RELEASED_PERIOD) return RELEASED_MIN_WEIGHT;
 
 	/*
 	 *	Released not long ago, might be ok.
 	 */
-	return RELEASED_MIN_WEIGHT + (RELEASED_PERIOD - fr_time_delta_to_msec(now - state->last_released));
+	return RELEASED_MIN_WEIGHT + (RELEASED_PERIOD - fr_time_delta_to_msec(fr_time_sub(now, state->last_released)));
 }
 
 /** Issue a ping request against a cluster node
@@ -1453,7 +1453,7 @@ static int _cluster_conn_free(fr_redis_conn_t *conn)
  */
 void *fr_redis_cluster_conn_create(TALLOC_CTX *ctx, void *instance, fr_time_delta_t timeout)
 {
-	fr_redis_cluster_node_t		*node = instance;
+	fr_redis_cluster_node_t	*node = instance;
 	fr_redis_conn_t		*conn = NULL;
 	redisContext		*handle;
 	redisReply		*reply = NULL;
diff --git a/src/lib/redis/cluster.h b/src/lib/redis/cluster.h
index f12bfb6237..f0a0aaf99f 100644
--- a/src/lib/redis/cluster.h
+++ b/src/lib/redis/cluster.h
@@ -81,7 +81,7 @@ fr_redis_cluster_rcode_t fr_redis_cluster_remap(request_t *request, fr_redis_clu
 /*
  *	Callback for the connection pool to create a new connection
  */
-void *fr_redis_cluster_conn_create(TALLOC_CTX *ctx, void *instance, fr_time_t timeout);
+void *fr_redis_cluster_conn_create(TALLOC_CTX *ctx, void *instance, fr_time_delta_t timeout);
 
 /*
  *	Functions to resolve a key to a cluster node
diff --git a/src/lib/server/exec_legacy.c b/src/lib/server/exec_legacy.c
index 16e5b0af5e..baa82c7a59 100644
--- a/src/lib/server/exec_legacy.c
+++ b/src/lib/server/exec_legacy.c
@@ -406,7 +406,7 @@ int radius_readfrom_program_legacy(int fd, pid_t pid, fr_time_delta_t timeout, c
 		FD_ZERO(&fds);
 		FD_SET(fd, &fds);
 
-		elapsed = fr_time() - start;
+		elapsed = fr_time_sub(fr_time(), start);
 		if (elapsed >= timeout) goto too_long;
 
 		rcode = select(fd + 1, &fds, NULL, NULL, &fr_time_delta_to_timeval(timeout - elapsed));
diff --git a/src/lib/server/exfile.c b/src/lib/server/exfile.c
index 0088f13787..1c12e96292 100644
--- a/src/lib/server/exfile.c
+++ b/src/lib/server/exfile.c
@@ -47,7 +47,7 @@ typedef struct {
 
 struct exfile_s {
 	uint32_t		max_entries;		//!< How many file descriptors we keep track of.
-	uint32_t		max_idle;		//!< Maximum idle time for a descriptor.
+	fr_time_delta_t		max_idle;		//!< Maximum idle time for a descriptor.
 	fr_time_t      		last_cleaned;
 	pthread_mutex_t		mutex;
 	exfile_entry_t		*entries;
@@ -148,7 +148,7 @@ static int _exfile_free(exfile_t *ef)
  *	- new context.
  *	- NULL on error.
  */
-exfile_t *exfile_init(TALLOC_CTX *ctx, uint32_t max_entries, uint32_t max_idle, bool locking)
+exfile_t *exfile_init(TALLOC_CTX *ctx, uint32_t max_entries, fr_time_delta_t max_idle, bool locking)
 {
 	exfile_t *ef;
 
@@ -308,7 +308,7 @@ int exfile_open(exfile_t *ef, char const *filename, mode_t permissions)
 
 	pthread_mutex_lock(&ef->mutex);
 
-	if (now > (ef->last_cleaned + 1)) do_cleanup = true;
+	if (fr_time_gt(now, fr_time_add(ef->last_cleaned, fr_time_delta_from_sec(1)))) do_cleanup = true;
 
 	/*
 	 *	Find the matching entry, or an unused one.
@@ -323,7 +323,7 @@ int exfile_open(exfile_t *ef, char const *filename, mode_t permissions)
 		}
 
 		if ((oldest < 0) ||
-		    (ef->entries[i].last_used < ef->entries[oldest].last_used)) {
+		    (fr_time_lt(ef->entries[i].last_used, ef->entries[oldest].last_used))) {
 			oldest = i;
 		}
 
@@ -352,7 +352,7 @@ int exfile_open(exfile_t *ef, char const *filename, mode_t permissions)
 			 *	do so now.
 			 */
 		} else if (do_cleanup) {
-			if ((ef->entries[i].last_used + ef->max_idle) >= now) continue;
+			if (fr_time_gteq(fr_time_add(ef->entries[i].last_used, ef->max_idle), now)) continue;
 
 			exfile_cleanup_entry(ef, &ef->entries[i]);
 		}
diff --git a/src/lib/server/exfile.h b/src/lib/server/exfile.h
index e1acb0cb1f..48d4d7f6e4 100644
--- a/src/lib/server/exfile.h
+++ b/src/lib/server/exfile.h
@@ -35,7 +35,7 @@ extern "C" {
  */
 typedef struct exfile_s exfile_t;
 
-exfile_t	*exfile_init(TALLOC_CTX *ctx, uint32_t entries, uint32_t idle, bool locking);
+exfile_t	*exfile_init(TALLOC_CTX *ctx, uint32_t entries, fr_time_delta_t idle, bool locking);
 
 void		exfile_enable_triggers(exfile_t *ef, CONF_SECTION *cs, char const *trigger_prefix,
 				       fr_pair_list_t *trigger_args);
diff --git a/src/lib/server/log.h b/src/lib/server/log.h
index 1eef10dc18..2748e6bf4a 100644
--- a/src/lib/server/log.h
+++ b/src/lib/server/log.h
@@ -546,9 +546,9 @@ typedef struct {
 do {\
 	if (fr_rate_limit_enabled()) {\
 		(_entry)->now = fr_time();\
-		if ((_entry)->now != (_entry)->last_complained) {\
+		if (fr_time_to_sec((_entry)->now) != fr_time_to_sec((_entry)->last_complained)) {\
 			(_entry)->last_complained = (_entry)->now;\
-			if (((_entry)->repeated > 0) && (((_entry)->now - (_entry)->last_complained) == 1)) { \
+			if (((_entry)->repeated > 0) && (fr_time_delta_to_sec(fr_time_sub((_entry)->now, (_entry)->last_complained)) == 1)) { \
 				_log(_fmt " - repeated %u time(s)", ##__VA_ARGS__, (_entry)->repeated); \
 			} else { \
 				_log(_fmt, ##__VA_ARGS__); \
@@ -583,9 +583,9 @@ do {\
 do {\
 	if (fr_rate_limit_enabled()) {\
 		(_entry)->now = fr_time();\
-		if ((_entry)->now != (_entry)->last_complained) {\
+		if (fr_time_to_sec((_entry)->now) != fr_time_to_sec((_entry)->last_complained)) {\
 			(_entry)->last_complained = (_entry)->now;\
-			if (((_entry)->repeated > 0) && (((_entry)->now - (_entry)->last_complained) == 1)) { \
+			if (((_entry)->repeated > 0) && (fr_time_delta_to_sec(fr_time_sub((_entry)->now, (_entry)->last_complained)) == 1)) { \
 				ROPTIONAL(_l_request, _l_global, _fmt " - repeated %u time(s)", ##__VA_ARGS__, (_entry)->repeated); \
 			} else { \
 				ROPTIONAL(_l_request, _l_global, _fmt, ##__VA_ARGS__); \
diff --git a/src/lib/server/main_config.c b/src/lib/server/main_config.c
index 8031c183a8..49dcc3ae99 100644
--- a/src/lib/server/main_config.c
+++ b/src/lib/server/main_config.c
@@ -1397,7 +1397,7 @@ void main_config_hup(main_config_t *config)
 {
 	fr_time_t		when;
 
-	static fr_time_t	last_hup = 0;
+	static fr_time_t	last_hup = fr_time_wrap(0);
 
 	/*
 	 *	Re-open the log file.  If we can't, then keep logging
@@ -1412,7 +1412,7 @@ void main_config_hup(main_config_t *config)
 	 *	Only check the config files every few seconds.
 	 */
 	when = fr_time();
-	if ((last_hup + fr_time_delta_from_sec(2)) >= when) {
+	if (fr_time_gteq(fr_time_add(last_hup, fr_time_delta_from_sec(2)), when)) {
 		INFO("HUP - Last HUP was too recent.  Ignoring");
 		return;
 	}
diff --git a/src/lib/server/main_loop.c b/src/lib/server/main_loop.c
index 480de6fd14..6b3597478c 100644
--- a/src/lib/server/main_loop.c
+++ b/src/lib/server/main_loop.c
@@ -119,10 +119,10 @@ static void main_loop_signal_process(int flag)
 	 */
 	if ((flag & RADIUS_SIGNAL_SELF_HUP) != 0) {
 		fr_time_t when;
-		static fr_time_t last_hup = 0;
+		static fr_time_t last_hup = fr_time_wrap(0);
 
 		when = fr_time();
-		if (when - last_hup <  fr_time_delta_from_sec(5)) {
+		if (fr_time_sub(when, last_hup) <  fr_time_delta_from_sec(5)) {
 			INFO("Ignoring HUP (less than 5s since last one)");
 			return;
 		}
@@ -232,7 +232,7 @@ int main_loop_start(void)
 	return ret;
 }
 
-static int _loop_status(fr_time_t wake, UNUSED void *ctx)
+static int _loop_status(UNUSED fr_time_t now, fr_time_delta_t wake, UNUSED void *ctx)
 {
 	if (wake > (NSEC / 10)) DEBUG3("Main loop waking up in %pV seconds", fr_box_time_delta(wake));
 
diff --git a/src/lib/server/module.c b/src/lib/server/module.c
index 68f149b63c..e993763490 100644
--- a/src/lib/server/module.c
+++ b/src/lib/server/module.c
@@ -298,7 +298,7 @@ static int8_t module_instance_data_cmp(void const *one, void const *two)
 exfile_t *module_exfile_init(TALLOC_CTX *ctx,
 			     CONF_SECTION *module,
 			     uint32_t max_entries,
-			     uint32_t max_idle,
+			     fr_time_delta_t max_idle,
 			     bool locking,
 			     char const *trigger_prefix,
 			     fr_pair_list_t *trigger_args)
diff --git a/src/lib/server/module.h b/src/lib/server/module.h
index 7aff0704dc..83e47131a1 100644
--- a/src/lib/server/module.h
+++ b/src/lib/server/module.h
@@ -284,7 +284,7 @@ fr_pool_t	*module_connection_pool_init(CONF_SECTION *module,
 exfile_t	*module_exfile_init(TALLOC_CTX *ctx,
 			     	    CONF_SECTION *module,
 				    uint32_t max_entries,
-				    uint32_t max_idle,
+				    fr_time_delta_t max_idle,
 				    bool locking,
 				    char const *trigger_prefix,
 				    fr_pair_list_t *trigger_args);
diff --git a/src/lib/server/pool.c b/src/lib/server/pool.c
index eb962860ec..5f0512a0ef 100644
--- a/src/lib/server/pool.c
+++ b/src/lib/server/pool.c
@@ -53,7 +53,7 @@ struct fr_pool_connection_s {
 	fr_pool_connection_t	*next;			//!< Next connection in list.
 	fr_heap_index_t	heap_id;			//!< For the next connection heap.
 
-	time_t		created;		//!< Time connection was created.
+	fr_time_t	created;		//!< Time connection was created.
 	fr_time_t	last_reserved;		//!< Last time the connection was reserved.
 
 	fr_time_t	last_released;  	//!< Time the connection was released.
@@ -338,7 +338,9 @@ static fr_pool_connection_t *connection_spawn(fr_pool_t *pool, request_t *reques
 	 *	opening connections, don't open multiple connections until
 	 *	we successfully open at least one.
 	 */
-	if ((pool->state.num == 0) && pool->state.pending && pool->state.last_failed) return NULL;
+	if ((pool->state.num == 0) &&
+	    pool->state.pending &&
+	    fr_time_gt(pool->state.last_failed, fr_time_wrap(0))) return NULL;
 
 	pthread_mutex_lock(&pool->mutex);
 	fr_assert(pool->state.num <= pool->max);
@@ -357,10 +359,11 @@ static fr_pool_connection_t *connection_spawn(fr_pool_t *pool, request_t *reques
 	 *	If the last attempt failed, wait a bit before
 	 *	retrying.
 	 */
-	if (pool->state.last_failed && ((pool->state.last_failed + pool->retry_delay) > now)) {
+	if (fr_time_gt(pool->state.last_failed, fr_time_wrap(0)) &&
+	    fr_time_gt(fr_time_add(pool->state.last_failed, pool->retry_delay), now)) {
 		bool complain = false;
 
-		if ((now - pool->state.last_throttled) >= NSEC) {
+		if (fr_time_sub(now, pool->state.last_throttled) >= fr_time_delta_from_sec(1)) {
 			complain = true;
 
 			pool->state.last_throttled = now;
@@ -370,7 +373,7 @@ static fr_pool_connection_t *connection_spawn(fr_pool_t *pool, request_t *reques
 
 		if (!fr_rate_limit_enabled() || complain) {
 			ERROR("Last connection attempt failed, waiting %pV seconds before retrying",
-			      fr_box_time_delta(pool->state.last_failed + pool->retry_delay - now));
+			      fr_box_time_delta(fr_time_sub(fr_time_add(pool->state.last_failed, pool->retry_delay), now)));
 		}
 
 		return NULL;
@@ -505,7 +508,7 @@ static fr_pool_connection_t *connection_spawn(fr_pool_t *pool, request_t *reques
 	pool->state.last_spawned = fr_time();
 	pool->delay_interval = pool->cleanup_interval;
 	pool->state.next_delay = pool->cleanup_interval;
-	pool->state.last_failed = 0;
+	pool->state.last_failed = fr_time_wrap(0);
 
 	/*
 	 *	Must be done inside the mutex, reconnect callback
@@ -579,7 +582,7 @@ static void connection_close_internal(fr_pool_t *pool, fr_pool_connection_t *thi
  *	- 0 if connection was closed.
  *	- 1 if connection handle was left open.
  */
-static int connection_manage(fr_pool_t *pool, request_t *request, fr_pool_connection_t *this, time_t now)
+static int connection_manage(fr_pool_t *pool, request_t *request, fr_pool_connection_t *this, fr_time_t now)
 {
 	fr_assert(pool != NULL);
 	fr_assert(this != NULL);
@@ -608,16 +611,16 @@ static int connection_manage(fr_pool_t *pool, request_t *request, fr_pool_connec
 	}
 
 	if ((pool->lifetime > 0) &&
-	    ((this->created + pool->lifetime) < now)) {
+	    (fr_time_lt(fr_time_add(this->created, pool->lifetime), now))) {
 		ROPTIONAL(RDEBUG2, DEBUG2, "Closing expired connection (%" PRIu64 "): Hit lifetime limit",
 			  this->number);
 		goto do_delete;
 	}
 
 	if ((pool->idle_timeout > 0) &&
-	    ((this->last_released + pool->idle_timeout) < now)) {
+	    (fr_time_lt(fr_time_add(this->last_released, pool->idle_timeout), now))) {
 		ROPTIONAL(RINFO, INFO, "Closing connection (%" PRIu64 "): Hit idle_timeout, was idle for %pVs",
-		     	  this->number, fr_box_time_delta(now - this->last_released));
+		     	  this->number, fr_box_time_delta(fr_time_sub(now, this->last_released)));
 		goto do_delete;
 	}
 
@@ -645,7 +648,7 @@ static int connection_check(fr_pool_t *pool, request_t *request)
 	fr_time_t		now = fr_time();
 	fr_pool_connection_t	*this, *next;
 
-	if ((now - pool->state.last_checked) < NSEC) {
+	if (fr_time_sub(now, pool->state.last_checked) < fr_time_delta_from_sec(1)) {
 		pthread_mutex_unlock(&pool->mutex);
 		return 1;
 	}
@@ -724,7 +727,7 @@ static int connection_check(fr_pool_t *pool, request_t *request)
 		 *	Don't close connections too often, in order to
 		 *	prevent flapping.
 		 */
-		if (now < (pool->state.last_spawned + pool->delay_interval)) goto manage_connections;
+		if (fr_time_lt(now, fr_time_add(pool->state.last_spawned, pool->delay_interval))) goto manage_connections;
 
 		/*
 		 *	Find a connection to close.
@@ -733,7 +736,7 @@ static int connection_check(fr_pool_t *pool, request_t *request)
 		for (this = pool->tail; this != NULL; this = this->prev) {
 			if (this->in_use) continue;
 
-			if (!found || (this->last_reserved < found->last_reserved)) found = this;
+			if (!found || (fr_time_lt(this->last_reserved, found->last_reserved))) found = this;
 		}
 
 		if (!fr_cond_assert(found)) goto done;
@@ -849,7 +852,7 @@ static void *connection_get_internal(fr_pool_t *pool, request_t *request, bool s
 		/*
 		 *	Rate-limit complaints.
 		 */
-		if ((now - pool->state.last_at_max) > NSEC) {
+		if (fr_time_sub(now, pool->state.last_at_max) > fr_time_delta_from_sec(1)) {
 			complain = true;
 			pool->state.last_at_max = now;
 		}
@@ -1401,7 +1404,7 @@ void fr_pool_connection_release(fr_pool_t *pool, request_t *request, void *conn)
 	 *	This is done inside the mutex to ensure
 	 *	updates are atomic.
 	 */
-	held = this->last_released - this->last_reserved;
+	held = fr_time_sub(this->last_released, this->last_reserved);
 
 	/*
 	 *	Check we've not exceeded out trigger limits
@@ -1410,14 +1413,14 @@ void fr_pool_connection_release(fr_pool_t *pool, request_t *request, void *conn)
 	 */
 	if (pool->held_trigger_min &&
 	    (held < pool->held_trigger_min) &&
-	    ((this->last_released - pool->state.last_held_min) >= NSEC)) {
+	    (fr_time_sub(this->last_released, pool->state.last_held_min) >= fr_time_delta_from_sec(1))) {
 	    	trigger_min = true;
 	    	pool->state.last_held_min = this->last_released;
 	}
 
 	if (pool->held_trigger_min &&
 	    (held > pool->held_trigger_max) &&
-	    ((this->last_released - pool->state.last_held_max) >= NSEC)) {
+	    (fr_time_sub(this->last_released, pool->state.last_held_max) >= fr_time_delta_from_sec(1))) {
 	    	trigger_max = true;
 	    	pool->state.last_held_max = this->last_released;
 	}
diff --git a/src/lib/server/snmp.c b/src/lib/server/snmp.c
index 5ddd00e886..4f6cce2959 100644
--- a/src/lib/server/snmp.c
+++ b/src/lib/server/snmp.c
@@ -119,12 +119,12 @@ static int snmp_value_uptime_get(UNUSED TALLOC_CTX *ctx, fr_value_box_t *out, ND
 	fr_assert(map->da->type == FR_TYPE_UINT32);
 
 	now = fr_time();
-	delta = now - start_time;
+	delta = fr_time_sub(now, start_time);
 
 	/*
 	 *	ticks are in 1/100's of seconds.
 	 */
-	out->vb_uint32 += delta / 10000000;
+	out->vb_uint32 += fr_time_delta_to_csec(delta);
 
 	return 0;
 }
@@ -138,12 +138,12 @@ static int snmp_config_reset_time_get(UNUSED TALLOC_CTX *ctx, fr_value_box_t *ou
 	fr_assert(map->da->type == FR_TYPE_UINT32);
 
 	now = fr_time();
-	delta = now - reset_time;
+	delta = fr_time_sub(now, reset_time);
 
 	/*
 	 *	ticks are in 1/100's of seconds.
 	 */
-	out->vb_uint32 += delta / 10000000;
+	out->vb_uint32 += fr_time_delta_to_csec(delta);
 
 	return 0;
 }
diff --git a/src/lib/server/state.c b/src/lib/server/state.c
index 08830d0185..27dd5b7b1c 100644
--- a/src/lib/server/state.c
+++ b/src/lib/server/state.c
@@ -367,7 +367,7 @@ static fr_state_entry_t *state_entry_create(fr_state_tree_t *state, request_t *r
 		/*
 		 *	Too old, we can delete it.
 		 */
-		if (entry->cleanup < now) {
+		if (fr_time_lt(entry->cleanup, now)) {
 			state_entry_unlink(state, entry);
 			fr_dlist_insert_tail(&to_free, entry);
 			timed_out++;
@@ -449,7 +449,7 @@ static fr_state_entry_t *state_entry_create(fr_state_tree_t *state, request_t *r
 	 *	isn't perfect, but it's reasonable, and it's one less
 	 *	thing for an administrator to configure.
 	 */
-	entry->cleanup = now + state->timeout;
+	entry->cleanup = fr_time_add(now, state->timeout);
 
 	/*
 	 *	Some modules create their own magic
@@ -525,8 +525,9 @@ static fr_state_entry_t *state_entry_create(fr_state_tree_t *state, request_t *r
 		fr_pair_append(reply_list, vp);
 	}
 
-	DEBUG4("State ID %" PRIu64 " created, value 0x%pH, expires %" PRIu64 "s",
-	       entry->id, fr_box_octets(entry->state, sizeof(entry->state)), (uint64_t)entry->cleanup - now);
+	DEBUG4("State ID %" PRIu64 " created, value 0x%pH, expires %pV",
+	       entry->id, fr_box_octets(entry->state, sizeof(entry->state)),
+	       fr_box_time_delta(fr_time_sub(entry->cleanup, now)));
 
 	PTHREAD_MUTEX_LOCK(&state->mutex);
 
diff --git a/src/lib/server/stats.c b/src/lib/server/stats.c
index 8a55b0f6ce..fa386a44a2 100644
--- a/src/lib/server/stats.c
+++ b/src/lib/server/stats.c
@@ -158,13 +158,13 @@ void radius_stats_init(int flag)
 
 void radius_stats_ema(fr_stats_ema_t *ema, fr_time_t start, fr_time_t end)
 {
-	uint64_t	tdiff;
+	fr_time_delta_t	tdiff;
 #ifdef WITH_STATS_DEBUG
 	static int	n = 0;
 #endif
 	if (ema->window == 0) return;
 
-	fr_assert(start <= end);
+	fr_assert(fr_time_lteq(start, end));
 
 	/*
 	 *	Initialize it.
@@ -176,8 +176,7 @@ void radius_stats_ema(fr_stats_ema_t *ema, fr_time_t start, fr_time_t end)
 		ema->f10 = (2 * F_EMA_SCALE) / ((10 * ema->window) + 1);
 	}
 
-	tdiff = fr_time_delta_to_usec(start);
-	tdiff -= fr_time_delta_to_usec(end);
+	tdiff = fr_time_delta_to_usec(fr_time_sub(start, end));
 	tdiff *= EMA_SCALE;
 
 	if (ema->ema1 == 0) {
@@ -214,11 +213,11 @@ void radius_stats_ema(fr_stats_ema_t *ema, fr_time_t start, fr_time_t end)
  */
 void fr_stats_bins(fr_stats_t *stats, fr_time_t start, fr_time_t end)
 {
-	fr_time_t	diff;
+	fr_time_delta_t	diff;
 	uint32_t	delay;
 
-	if (end < start) return;	/* bad data */
-	diff = end - start;
+	if (fr_time_lt(end, start)) return;	/* bad data */
+	diff = fr_time_sub(end, start);
 
 	if (diff >= fr_time_delta_from_sec(10)) {
 		stats->elapsed[7]++;
diff --git a/src/lib/server/trigger.c b/src/lib/server/trigger.c
index a785407012..0171585fae 100644
--- a/src/lib/server/trigger.c
+++ b/src/lib/server/trigger.c
@@ -368,7 +368,7 @@ int trigger_exec(unlang_interpret_t *intp,
 		if (!found) {
 			MEM(found = talloc(NULL, trigger_last_fired_t));
 			found->ci = ci;
-			found->last_fired = 0;
+			found->last_fired = fr_time_wrap(0);
 
 			fr_rb_insert(trigger_last_fired_tree, found);
 		}
@@ -378,7 +378,7 @@ int trigger_exec(unlang_interpret_t *intp,
 		/*
 		 *	Send the rate_limited traps at most once per second.
 		 */
-		if (found->last_fired == now) return -1;
+		if (fr_time_to_sec(found->last_fired) == fr_time_to_sec(now)) return -1;
 		found->last_fired = now;
 	}
 
diff --git a/src/lib/server/trunk.c b/src/lib/server/trunk.c
index 8483a6ecd9..b8ef8327e0 100644
--- a/src/lib/server/trunk.c
+++ b/src/lib/server/trunk.c
@@ -53,7 +53,7 @@ typedef struct fr_trunk_s fr_trunk_t;
 static atomic_uint_fast64_t request_counter = ATOMIC_VAR_INIT(1);
 
 #ifdef TESTING_TRUNK
-static fr_time_t test_time_base = 1;
+static fr_time_t test_time_base = fr_time_wrap(1);
 
 static fr_time_t test_time(void)
 {
@@ -1536,7 +1536,8 @@ static fr_trunk_enqueue_t trunk_request_check_enqueue(fr_trunk_connection_t **tc
 	 *	one or more connections comes online.
 	 */
 	if (!trunk->conf.backlog_on_failed_conn &&
-	    trunk->pub.last_failed && (trunk->pub.last_connected < trunk->pub.last_failed)) {
+	    fr_time_gt(trunk->pub.last_failed, fr_time_wrap(0)) &&
+	    fr_time_lt(trunk->pub.last_connected, trunk->pub.last_failed)) {
 	    	RATE_LIMIT_LOCAL_ROPTIONAL(&trunk->limit_last_failure_log,
 					   RWARN, WARN, "Refusing to enqueue requests - "
 					   "No active connections and last event was a connection failure");
@@ -2374,7 +2375,7 @@ fr_trunk_request_t *fr_trunk_request_alloc(fr_trunk_t *trunk, request_t *request
 		fr_assert(treq->pub.trunk == trunk);
 		fr_assert(treq->pub.tconn == NULL);
 		fr_assert(treq->cancel_reason == FR_TRUNK_CANCEL_REASON_NONE);
-		fr_assert(treq->last_freed > 0);
+		fr_assert(fr_time_gt(treq->last_freed, fr_time_wrap(0)));
 		trunk->pub.req_alloc_reused++;
 	} else {
 		MEM(treq = talloc_pooled_object(trunk, fr_trunk_request_t,
@@ -3990,7 +3991,7 @@ static void trunk_manage(fr_trunk_t *trunk, fr_time_t now)
 	 *	have been idle for too long.
 	 */
 	while ((treq = fr_dlist_tail(&trunk->free_requests)) &&
-	       ((treq->last_freed + trunk->conf.req_cleanup_delay) <= now)) talloc_free(treq);
+	       fr_time_lteq(fr_time_add(treq->last_freed, trunk->conf.req_cleanup_delay), now)) talloc_free(treq);
 
 	/*
 	 *	Free any connections which have drained
@@ -4042,7 +4043,7 @@ static void trunk_manage(fr_trunk_t *trunk, fr_time_t now)
 	 *	We're above the target requests per connection
 	 *	spawn more connections!
 	 */
-	if ((trunk->pub.last_above_target >= trunk->pub.last_below_target)) {
+	if (fr_time_gteq(trunk->pub.last_above_target, trunk->pub.last_below_target)) {
 		/*
 		 *	If connecting is provided, check we
 		 *	wouldn't have too many connections in
@@ -4066,10 +4067,10 @@ static void trunk_manage(fr_trunk_t *trunk, fr_time_t now)
 		 *	Only apply hysteresis if we have at least
 		 *	one available connection.
 		 */
-		if (conn_count && ((trunk->pub.last_above_target + trunk->conf.open_delay) > now)) {
+		if (conn_count && fr_time_gt(fr_time_add(trunk->pub.last_above_target, trunk->conf.open_delay), now)) {
 			DEBUG3("Not opening connection - Need to be above target for %pVs.  It's been %pVs",
 			       fr_box_time_delta(trunk->conf.open_delay),
-			       fr_box_time_delta(now - trunk->pub.last_above_target));
+			       fr_box_time_delta(fr_time_sub(now, trunk->pub.last_above_target)));
 			return;	/* too soon */
 		}
 
@@ -4133,11 +4134,11 @@ static void trunk_manage(fr_trunk_t *trunk, fr_time_t now)
 		 *	Implement delay if there's no connections that
 		 *	could be immediately re-activated.
 		 */
-		if ((trunk->pub.last_open + trunk->conf.open_delay) > now) {
+		if (fr_time_gt(fr_time_add(trunk->pub.last_open, trunk->conf.open_delay), now)) {
 			DEBUG3("Not opening connection - Need to wait %pVs before opening another connection.  "
 			       "It's been %pVs",
 			       fr_box_time_delta(trunk->conf.open_delay),
-			       fr_box_time_delta(now - trunk->pub.last_open));
+			       fr_box_time_delta(fr_time_sub(now, trunk->pub.last_open)));
 			return;
 		}
 
@@ -4151,11 +4152,11 @@ static void trunk_manage(fr_trunk_t *trunk, fr_time_t now)
 	 *	We're below the target requests per connection.
 	 *	Free some connections...
 	 */
-	else if (trunk->pub.last_below_target > trunk->pub.last_above_target) {
-		if ((trunk->pub.last_below_target + trunk->conf.close_delay) > now) {
+	else if (fr_time_gt(trunk->pub.last_below_target, trunk->pub.last_above_target)) {
+		if (fr_time_gt(fr_time_add(trunk->pub.last_below_target, trunk->conf.close_delay), now)) {
 			DEBUG3("Not closing connection - Need to be below target for %pVs. It's been %pVs",
 			       fr_box_time_delta(trunk->conf.close_delay),
-			       fr_box_time_delta(now - trunk->pub.last_below_target));
+			       fr_box_time_delta(fr_time_sub(now, trunk->pub.last_below_target)));
 			return;	/* too soon */
 		}
 
@@ -4206,11 +4207,11 @@ static void trunk_manage(fr_trunk_t *trunk, fr_time_t now)
 		       ROUND_UP_DIV(req_count, conn_count), trunk->conf.target_req_per_conn);
 
 	close:
-		if ((trunk->pub.last_closed + trunk->conf.close_delay) > now) {
+		if (fr_time_gt(fr_time_add(trunk->pub.last_closed, trunk->conf.close_delay), now)) {
 			DEBUG3("Not closing connection - Need to wait %pVs before closing another connection.  "
 			       "It's been %pVs",
 			       fr_box_time_delta(trunk->conf.close_delay),
-			       fr_box_time_delta(now - trunk->pub.last_closed));
+			       fr_box_time_delta(fr_time_sub(now, trunk->pub.last_closed)));
 			return;
 		}
 
@@ -4349,7 +4350,7 @@ static uint64_t trunk_requests_per_connection(uint16_t *conn_count_out, uint32_t
 	uint16_t conn_count = 0;
 	uint64_t req_per_conn = 0;
 
-	fr_assert(now > 0);
+	fr_assert(fr_time_gt(now, fr_time_wrap(0)));
 
 	/*
 	 *	No need to update these as the trunk is being freed
@@ -4411,7 +4412,7 @@ static uint64_t trunk_requests_per_connection(uint16_t *conn_count_out, uint32_t
 		 *
 		 *	The equality check is correct here as both values start at 0.
 		 */
-		if (trunk->pub.last_above_target <= trunk->pub.last_below_target) trunk->pub.last_above_target = now;
+		if (fr_time_lteq(trunk->pub.last_above_target, trunk->pub.last_below_target)) trunk->pub.last_above_target = now;
 	} else if (req_per_conn < trunk->conf.target_req_per_conn) {
 	below_target:
 		/*
@@ -4419,7 +4420,7 @@ static uint64_t trunk_requests_per_connection(uint16_t *conn_count_out, uint32_t
 		 *
 		 *	The equality check is correct here as both values start at 0.
 		 */
-		if (trunk->pub.last_below_target <= trunk->pub.last_above_target) trunk->pub.last_below_target = now;
+		if (fr_time_lteq(trunk->pub.last_below_target, trunk->pub.last_above_target)) trunk->pub.last_below_target = now;
 	}
 
 done:
diff --git a/src/lib/server/virtual_servers.c b/src/lib/server/virtual_servers.c
index af242c3077..5fc4752aa0 100644
--- a/src/lib/server/virtual_servers.c
+++ b/src/lib/server/virtual_servers.c
@@ -496,7 +496,7 @@ unlang_action_t virtual_server_push(request_t *request, CONF_SECTION *server_cs,
 	mi->module = (module_t *)server->process_module;
 	mi->number = 0;	/* Hacky hack hack */
 
-	if (unlikely(track && track->dynamic && server->dynamic_client_module)) {
+	if (unlikely(track && fr_time_gt(track->dynamic, fr_time_wrap(0)) && server->dynamic_client_module)) {
 		process = (fr_process_module_t const *) server->dynamic_client_module->module->common;
 		mi->dl_inst = server->dynamic_client_module;
 
diff --git a/src/lib/tls/cache.c b/src/lib/tls/cache.c
index 23e1d26cb1..ab1f820e3c 100644
--- a/src/lib/tls/cache.c
+++ b/src/lib/tls/cache.c
@@ -408,7 +408,7 @@ unlang_action_t tls_cache_store_push(request_t *request, fr_tls_conf_t *conf, fr
 	fr_assert(tls_cache->store.sess);
 	fr_assert(tls_cache->store.state == FR_TLS_CACHE_STORE_REQUESTED);
 
-	if (expires <= now) {
+	if (fr_time_lteq(expires, now)) {
 		RWDEBUG("Session has already expired, not storing");
 		return UNLANG_ACTION_CALCULATE_RESULT;
 	}
@@ -440,7 +440,7 @@ unlang_action_t tls_cache_store_push(request_t *request, fr_tls_conf_t *conf, fr
 	 *	How long the session has to live
 	 */
 	MEM(pair_update_request(&vp, attr_tls_session_ttl) >= 0);
-	vp->vp_time_delta = fr_time_delta_from_nsec(expires - now);
+	vp->vp_time_delta = fr_time_sub(expires, now);
 
 	/*
 	 *	Serialize the session
diff --git a/src/lib/tls/cert.c b/src/lib/tls/cert.c
index 77f8be741f..fd01bd9bd7 100644
--- a/src/lib/tls/cert.c
+++ b/src/lib/tls/cert.c
@@ -70,7 +70,7 @@ int fr_tls_cert_is_valid(fr_unix_time_t *not_before_p, fr_unix_time_t *not_after
 	/*
 	 *	Check the cert hasn't expired
 	 */
-	if (fr_time_from_sec(not_after) < now) {
+	if (fr_time_lt(fr_time_from_sec(not_after), now)) {
 		fr_strerror_printf("Certificate has expired.  "
 				   "Validity period (notAfter) ends %pV, current time is %pV",
 				   fr_box_date(fr_unix_time_from_time(not_before)), fr_box_date(fr_time_to_unix_time(now)));
@@ -81,7 +81,7 @@ int fr_tls_cert_is_valid(fr_unix_time_t *not_before_p, fr_unix_time_t *not_after
 	 *	Check the cert's validity period
 	 *	has started.
 	 */
-	if (fr_time_from_sec(not_before) > now) {
+	if (fr_time_gt(fr_time_from_sec(not_before), now)) {
 		fr_strerror_printf("Certificate is not yet valid.  "
 				   "Validity period (notBefore) starts %pV, current time is %pV",
 				   fr_box_date(fr_unix_time_from_time(not_before)), fr_box_date(fr_time_to_unix_time(now)));
diff --git a/src/lib/unlang/compile.c b/src/lib/unlang/compile.c
index 22dbd25120..0f20a5407a 100644
--- a/src/lib/unlang/compile.c
+++ b/src/lib/unlang/compile.c
@@ -4121,7 +4121,7 @@ void unlang_frame_perf_cleanup(unlang_t const *instruction)
 
 	t = &unlang_thread_array[instruction->number];
 
-	t->cpu_time += (fr_time() - t->enter);
+	t->cpu_time += fr_time_sub(fr_time(), t->enter);
 }
 
 
diff --git a/src/lib/unlang/interpret.c b/src/lib/unlang/interpret.c
index 70f814e893..aaba2dbc9b 100644
--- a/src/lib/unlang/interpret.c
+++ b/src/lib/unlang/interpret.c
@@ -283,7 +283,7 @@ unlang_frame_action_t result_calculate(request_t *request, unlang_stack_frame_t
 			 *	frame is cleaned up.
 			 */
 			if (instruction->actions.retry.mrd) {
-				retry->timeout = fr_time() + instruction->actions.retry.mrd;
+				retry->timeout = fr_time_add(fr_time(), instruction->actions.retry.mrd);
 
 				if (fr_event_timer_at(retry, unlang_interpret_event_list(request), &retry->ev, retry->timeout,
 						      instruction_timeout_handler, request) < 0) {
diff --git a/src/lib/unlang/module.c b/src/lib/unlang/module.c
index a6205f58ba..2998ba5d8f 100644
--- a/src/lib/unlang/module.c
+++ b/src/lib/unlang/module.c
@@ -882,7 +882,7 @@ static void unlang_module_event_retry_handler(UNUSED fr_event_list_t *el, fr_tim
 
 	case FR_RETRY_MRD:
 		REDEBUG("Reached max_rtx_duration (%pVs > %pVs) - sending timeout signal",
-			fr_box_time_delta(now - state->retry.start), fr_box_time_delta(state->retry.config->mrd));
+			fr_box_time_delta(fr_time_sub(now, state->retry.start)), fr_box_time_delta(state->retry.config->mrd));
 		break;
 
 	case FR_RETRY_MRC:
@@ -901,7 +901,7 @@ static unlang_action_t unlang_module(rlm_rcode_t *p_result, request_t *request,
 	unlang_frame_state_module_t	*state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
 	char const 			*caller;
 	unlang_action_t			ua;
-	fr_time_t			now = 0;
+	fr_time_t			now = fr_time_wrap(0);
 
 	*p_result = state->rcode = RLM_MODULE_NOOP;
 	state->set_rcode = true;
@@ -995,7 +995,7 @@ static unlang_action_t unlang_module(rlm_rcode_t *p_result, request_t *request,
 		 *	If we have retry timers, then start the retries.
 		 */
 		if (frame->instruction->actions.retry.irt) {
-			fr_assert(now != 0);
+			fr_assert(fr_time_gt(now, fr_time_wrap(0)));
 
 			(void) fr_retry_init(&state->retry, now, &frame->instruction->actions.retry); /* can't fail */
 
diff --git a/src/lib/util/event.c b/src/lib/util/event.c
index 42b2417ef0..0c77f38bfb 100644
--- a/src/lib/util/event.c
+++ b/src/lib/util/event.c
@@ -1563,13 +1563,8 @@ int _fr_event_timer_in(NDEBUG_LOCATION_ARGS
 		       TALLOC_CTX *ctx, fr_event_list_t *el, fr_event_timer_t const **ev_p,
 		       fr_time_delta_t delta, fr_event_timer_cb_t callback, void const *uctx)
 {
-	fr_time_t now;
-
-	now = el->time();
-	now += delta;
-
 	return _fr_event_timer_at(NDEBUG_LOCATION_VALS
-				  ctx, el, ev_p, now, callback, uctx);
+				  ctx, el, ev_p, fr_time_add(el->time(), delta), callback, uctx);
 }
 
 /** Delete a timer event from the event list
@@ -1833,7 +1828,7 @@ unsigned int fr_event_list_reap_signal(fr_event_list_t *el, fr_time_delta_t time
 		struct kevent	evset;
 		int		waiting = 0;
 		int 		kq = kqueue();
-		fr_time_t	now, start = el->time(), end = start + timeout;
+		fr_time_t	now, start = el->time(), end = fr_time_add(start, timeout);
 
 		if (unlikely(kq < 0)) goto force;
 
@@ -1875,11 +1870,12 @@ unsigned int fr_event_list_reap_signal(fr_event_list_t *el, fr_time_delta_t time
 		/*
 		 *	Keep draining process exits as they come in...
 		 */
-		while ((waiting > 0) && (end > (now = el->time()))) {
+		while ((waiting > 0) && fr_time_gt(end, (now = el->time()))) {
 			struct kevent	kev;
 			int		ret;
 
-			ret = kevent(kq, NULL, 0, &kev, 1, &fr_time_delta_to_timespec(end - now));
+			ret = kevent(kq, NULL, 0, &kev, 1,
+				     &fr_time_delta_to_timespec(fr_time_sub(end, now)));
 			switch (ret) {
 			default:
 				EVENT_DEBUG("%p - %s - Reaper tmp loop error %s, forcing process reaping",
@@ -2123,20 +2119,20 @@ int fr_event_timer_run(fr_event_list_t *el, fr_time_t *when)
 	if (unlikely(!el)) return 0;
 
 	if (fr_lst_num_elements(el->times) == 0) {
-		*when = 0;
+		*when = fr_time_wrap(0);
 		return 0;
 	}
 
 	ev = fr_lst_peek(el->times);
 	if (!ev) {
-		*when = 0;
+		*when = fr_time_wrap(0);
 		return 0;
 	}
 
 	/*
 	 *	See if it's time to do this one.
 	 */
-	if (ev->when > *when) {
+	if (fr_time_gt(ev->when, *when)) {
 		*when = ev->when;
 		return 0;
 	}
@@ -2167,7 +2163,7 @@ int fr_event_timer_run(fr_event_list_t *el, fr_time_t *when)
  */
 int fr_event_corral(fr_event_list_t *el, fr_time_t now, bool wait)
 {
-	fr_time_t		when, *wake;
+	fr_time_delta_t		when, *wake;
 	struct timespec		ts_when, *ts_wake;
 	fr_event_pre_t		*pre;
 	int			num_fd_events;
@@ -2198,11 +2194,11 @@ int fr_event_corral(fr_event_list_t *el, fr_time_t now, bool wait)
 	 */
 	ev = fr_lst_peek(el->times);
 	if (ev) {
-		if (ev->when <= el->now) {
+		if (fr_time_lteq(ev->when, el->now)) {
 			timer_event_ready = true;
 
 		} else if (wait) {
-			when = ev->when - el->now;
+			when = fr_time_sub(ev->when, el->now);
 
 		} /* else we're not waiting, leave "when == 0" */
 
@@ -2226,7 +2222,7 @@ int fr_event_corral(fr_event_list_t *el, fr_time_t now, bool wait)
 		for (pre = fr_dlist_head(&el->pre_callbacks);
 		     pre != NULL;
 		     pre = fr_dlist_next(&el->pre_callbacks, pre)) {
-			if (pre->callback(wake ? *wake : 0, pre->uctx) > 0) {
+			if (pre->callback(now, wake ? *wake : 0, pre->uctx) > 0) {
 				wake = &when;
 				when = 0;
 			}
@@ -2272,7 +2268,7 @@ int fr_event_corral(fr_event_list_t *el, fr_time_t now, bool wait)
 	 *	If there are no FD events, we must have woken up from a timer
 	 */
 	if (!num_fd_events) {
-		el->now += when;
+		el->now = fr_time_add(el->now, when);
 		if (wait) timer_event_ready = true;
 	}
 	/*
@@ -2767,7 +2763,7 @@ void fr_event_report(fr_event_list_t *el, fr_time_t now, void *uctx)
 	for (ev = fr_lst_iter_init(el->times, &iter);
 	     ev != NULL;
 	     ev = fr_lst_iter_next(el->times, &iter)) {
-		fr_time_delta_t diff = ev->when - now;
+		fr_time_delta_t diff = fr_time_sub(ev->when, now);
 
 		for (i = 0; i < NUM_ELEMENTS(decades); i++) {
 			if ((diff <= decades[i]) || (i == NUM_ELEMENTS(decades) - 1)) {
@@ -2836,14 +2832,15 @@ void fr_event_timer_dump(fr_event_list_t *el)
 
 	now = el->time();
 
-	EVENT_DEBUG("Time is now %"PRId64"", now);
+	EVENT_DEBUG("Time is now %"PRId64"", fr_time_unwrap(now));
 
 	for (ev = fr_lst_iter_init(el->times, &iter);
 	     ev;
 	     ev = fr_lst_iter_next(el->times, &iter)) {
 		(void)talloc_get_type_abort(ev, fr_event_timer_t);
 		EVENT_DEBUG("%s[%u]: %p time=%" PRId64 " (%c), callback=%p",
-			    ev->file, ev->line, ev, ev->when, now > ev->when ? '<' : '>', ev->callback);
+			    ev->file, ev->line, ev, fr_time_unwrap(ev->when),
+			    fr_time_gt(now, ev->when) ? '<' : '>', ev->callback);
 	}
 }
 #endif
diff --git a/src/lib/util/event.h b/src/lib/util/event.h
index 640dac42ff..496bc21446 100644
--- a/src/lib/util/event.h
+++ b/src/lib/util/event.h
@@ -117,9 +117,10 @@ typedef	void (*fr_event_timer_cb_t)(fr_event_list_t *el, fr_time_t now, void *uc
  * Called before calling kqueue to put the thread in a sleeping state.
  *
  * @param[in] now	The current time.
+ * @param[in] wake	When we'll next need to wake up to service an event.
  * @param[in] uctx	User ctx passed to #fr_event_list_alloc.
  */
-typedef	int (*fr_event_status_cb_t)(fr_time_t now, void *uctx);
+typedef	int (*fr_event_status_cb_t)(fr_time_t now, fr_time_delta_t wake, void *uctx);
 
 /** Called when an IO event occurs on a file descriptor
  *
diff --git a/src/lib/util/heap_tests.c b/src/lib/util/heap_tests.c
index 5450d12eeb..0a6b839ad8 100644
--- a/src/lib/util/heap_tests.c
+++ b/src/lib/util/heap_tests.c
@@ -271,9 +271,9 @@ static void heap_cycle(void)
 	end = fr_time();
 
 	TEST_MSG_ALWAYS("\ncycle size: %d\n", HEAP_CYCLE_SIZE);
-	TEST_MSG_ALWAYS("insert: %2.2f s\n", ((double)(start_remove - start_insert)) / NSEC);
-	TEST_MSG_ALWAYS("extract: %2.2f s\n", ((double)(start_swap - start_remove)) / NSEC);
-	TEST_MSG_ALWAYS("swap: %2.2f s\n", ((double)(end - start_swap)) / NSEC);
+	TEST_MSG_ALWAYS("insert: %2.2f s\n", fr_time_sub(start_remove, start_insert) / (double)NSEC);
+	TEST_MSG_ALWAYS("extract: %2.2f s\n", fr_time_sub(start_swap, start_remove)/ (double)NSEC);
+	TEST_MSG_ALWAYS("swap: %2.2f s\n", fr_time_sub(end, start_swap) / (double)NSEC);
 
 	talloc_free(hp);
 	free(array);
diff --git a/src/lib/util/lst_tests.c b/src/lib/util/lst_tests.c
index 0a78459046..fdd46963c5 100644
--- a/src/lib/util/lst_tests.c
+++ b/src/lib/util/lst_tests.c
@@ -375,9 +375,9 @@ static void lst_cycle(void)
 	end = fr_time();
 
 	TEST_MSG_ALWAYS("\ncycle size: %d\n", LST_CYCLE_SIZE);
-	TEST_MSG_ALWAYS("insert: %2.2f s\n", ((double)(start_remove - start_insert)) / NSEC);
-	TEST_MSG_ALWAYS("extract: %2.2f s\n", ((double)(start_swap - start_remove)) / NSEC);
-	TEST_MSG_ALWAYS("swap: %2.2f s\n", ((double)(end - start_swap)) / NSEC);
+	TEST_MSG_ALWAYS("insert: %2.2f s\n", fr_time_sub(start_remove, start_insert) / (double)NSEC);
+	TEST_MSG_ALWAYS("extract: %2.2f s\n", fr_time_sub(start_swap, start_remove) / (double)NSEC);
+	TEST_MSG_ALWAYS("swap: %2.2f s\n", fr_time_sub(end, start_swap) / (double)NSEC);
 
 	talloc_free(lst);
 	free(values);
@@ -446,7 +446,7 @@ static void queue_cmp(unsigned int count)
 	 *	Check times for LST alloc, insert, pop
 	 */
 	{
-		fr_time_t	start_alloc, end_alloc, start_insert, end_insert, start_pop, end_pop, end_pop_first = 0;
+		fr_time_t	start_alloc, end_alloc, start_insert, end_insert, start_pop, end_pop, end_pop_first = fr_time_wrap(0);
 
 		populate_values(values, count);
 
@@ -470,10 +470,10 @@ static void queue_cmp(unsigned int count)
 		end_pop = fr_time();
 
 		TEST_MSG_ALWAYS("\nlst size: %u\n", count);
-		TEST_MSG_ALWAYS("alloc: %"PRIu64" μs\n", (end_alloc - start_alloc) / 1000);
-		TEST_MSG_ALWAYS("insert: %"PRIu64" μs\n", (end_insert - start_insert) / 1000);
-		TEST_MSG_ALWAYS("pop-first: %"PRIu64" μs\n", (end_pop_first - start_pop) / 1000);
-		TEST_MSG_ALWAYS("pop: %"PRIu64" μs\n", (end_pop - start_pop) / 1000);
+		TEST_MSG_ALWAYS("alloc: %"PRIu64" μs\n", fr_time_sub(end_alloc, start_alloc) / 1000);
+		TEST_MSG_ALWAYS("insert: %"PRIu64" μs\n", fr_time_sub(end_insert, start_insert) / 1000);
+		TEST_MSG_ALWAYS("pop-first: %"PRIu64" μs\n", fr_time_sub(end_pop_first, start_pop) / 1000);
+		TEST_MSG_ALWAYS("pop: %"PRIu64" μs\n", fr_time_sub(end_pop, start_pop) / 1000);
 
 		talloc_free(lst);
 	}
@@ -482,7 +482,7 @@ static void queue_cmp(unsigned int count)
 	 *	Check times for heap alloc, insert, pop
 	 */
 	{
-		fr_time_t	start_alloc, end_alloc, start_insert, end_insert, start_pop, end_pop, end_pop_first = 0;
+		fr_time_t	start_alloc, end_alloc, start_insert, end_insert, start_pop, end_pop, end_pop_first = fr_time_wrap(0);
 
 		populate_values(values, count);
 
@@ -506,10 +506,10 @@ static void queue_cmp(unsigned int count)
 		end_pop = fr_time();
 
 		TEST_MSG_ALWAYS("\nheap size: %u\n", count);
-		TEST_MSG_ALWAYS("alloc: %"PRIu64" μs\n", (end_alloc - start_alloc) / 1000);
-		TEST_MSG_ALWAYS("insert: %"PRIu64" μs\n", (end_insert - start_insert) / 1000);
-		TEST_MSG_ALWAYS("pop-first: %"PRIu64" μs\n", (end_pop_first - start_pop) / 1000);
-		TEST_MSG_ALWAYS("pop: %"PRIu64" μs\n", (end_pop - start_pop) / 1000);
+		TEST_MSG_ALWAYS("alloc: %"PRIu64" μs\n", fr_time_sub(end_alloc, start_alloc) / 1000);
+		TEST_MSG_ALWAYS("insert: %"PRIu64" μs\n", fr_time_sub(end_insert, start_insert) / 1000);
+		TEST_MSG_ALWAYS("pop-first: %"PRIu64" μs\n", fr_time_sub(end_pop_first, start_pop) / 1000);
+		TEST_MSG_ALWAYS("pop: %"PRIu64" μs\n", fr_time_sub(end_pop, start_pop) / 1000);
 
 		talloc_free(heap);
 	}
@@ -520,7 +520,7 @@ static void queue_cmp(unsigned int count)
 	{
 		lst_thing	**array;
 		populate_values(values, count);
-		fr_time_t	start_alloc, end_alloc, start_insert, end_insert, start_pop, end_pop, end_pop_first = 0;
+		fr_time_t	start_alloc, end_alloc, start_insert, end_insert, start_pop, end_pop, end_pop_first = fr_time_wrap(0);
 
 		start_alloc = fr_time();
 		array = talloc_array(NULL, lst_thing *, count);
@@ -538,10 +538,10 @@ static void queue_cmp(unsigned int count)
 		end_pop = fr_time();
 
 		TEST_MSG_ALWAYS("\narray size: %u\n", count);
-		TEST_MSG_ALWAYS("alloc: %"PRIu64" μs\n", (end_alloc - start_alloc) / 1000);
-		TEST_MSG_ALWAYS("insert: %"PRIu64" μs\n", (end_insert - start_insert) / 1000);
-		TEST_MSG_ALWAYS("pop-first: %"PRIu64" μs\n", (end_pop_first - start_pop) / 1000);
-		TEST_MSG_ALWAYS("pop: %"PRIu64" μs\n", (end_pop - start_pop) / 1000);
+		TEST_MSG_ALWAYS("alloc: %"PRIu64" μs\n", fr_time_sub(end_alloc, start_alloc) / 1000);
+		TEST_MSG_ALWAYS("insert: %"PRIu64" μs\n", fr_time_sub(end_insert, start_insert) / 1000);
+		TEST_MSG_ALWAYS("pop-first: %"PRIu64" μs\n", fr_time_sub(end_pop_first, start_pop) / 1000);
+		TEST_MSG_ALWAYS("pop: %"PRIu64" μs\n", fr_time_sub(end_pop, start_pop) / 1000);
 
 		talloc_free(array);
 	}
diff --git a/src/lib/util/pair_list_perf_test.c b/src/lib/util/pair_list_perf_test.c
index 0a592c3581..e504d32120 100644
--- a/src/lib/util/pair_list_perf_test.c
+++ b/src/lib/util/pair_list_perf_test.c
@@ -304,7 +304,8 @@ static void do_test_fr_pair_append(unsigned int len, unsigned int perc, unsigned
 	fr_pair_list_t  test_vps;
 	unsigned int	i, j;
 	fr_pair_t	*new_vp;
-	fr_time_t	start, end, used = 0;
+	fr_time_t	start, end;
+	fr_time_delta_t	used = 0;
 	size_t		input_count = talloc_array_length(source_vps);
 
 	fr_pair_list_init(&test_vps);
@@ -325,7 +326,7 @@ static void do_test_fr_pair_append(unsigned int len, unsigned int perc, unsigned
 			start = fr_time();
 			fr_pair_append(&test_vps, new_vp);
 			end = fr_time();
-			used += (end - start);
+			used += fr_time_sub(end, start);
 		}
 		TEST_CHECK(fr_pair_list_len(&test_vps) == len);
 		fr_pair_list_free(&test_vps);
@@ -342,7 +343,8 @@ static void do_test_fr_pair_find_by_da(unsigned int len, unsigned int perc, unsi
 	fr_pair_list_t		test_vps;
 	unsigned int		i, j;
 	fr_pair_t		*new_vp;
-	fr_time_t		start, end, used = 0;
+	fr_time_t		start, end;
+	fr_time_delta_t		used = 0;
 	fr_dict_attr_t const	*da;
 	size_t			input_count = talloc_array_length(source_vps);
 
@@ -368,7 +370,7 @@ static void do_test_fr_pair_find_by_da(unsigned int len, unsigned int perc, unsi
 			start = fr_time();
 			(void) fr_pair_find_by_da(&test_vps, da, 0);
 			end = fr_time();
-			used += (end - start);
+			used += fr_time_sub(end, start);
 		}
 	}
 	fr_pair_list_free(&test_vps);
@@ -384,7 +386,8 @@ static void do_test_find_nth(unsigned int len, unsigned int perc, unsigned int r
 	fr_pair_list_t	  	test_vps;
 	unsigned int		i, j, nth_item;
 	fr_pair_t		*new_vp;
-	fr_time_t		start, end, used = 0;
+	fr_time_t		start, end;
+	fr_time_delta_t		used = 0;
 	fr_dict_attr_t const	*da;
 	size_t			input_count = talloc_array_length(source_vps);
 
@@ -413,7 +416,7 @@ static void do_test_find_nth(unsigned int len, unsigned int perc, unsigned int r
 			start = fr_time();
 			(void) fr_pair_find_by_da(&test_vps, da, nth_item);
 			end = fr_time();
-			used += (end - start);
+			used += fr_time_sub(end, start);
 		}
 	}
 	fr_pair_list_free(&test_vps);
@@ -429,7 +432,8 @@ static void do_test_fr_pair_list_free(unsigned int len, unsigned int perc, unsig
 	fr_pair_list_t  test_vps;
 	unsigned int	i, j;
 	fr_pair_t	*new_vp;
-	fr_time_t	start, end, used = 0;
+	fr_time_t	start, end;
+	fr_time_delta_t	used = 0;
 	size_t		input_count = talloc_array_length(source_vps);
 
 	fr_pair_list_init(&test_vps);
@@ -444,7 +448,7 @@ static void do_test_fr_pair_list_free(unsigned int len, unsigned int perc, unsig
 		start = fr_time();
 		fr_pair_list_free(&test_vps);
 		end = fr_time();
-		used += (end - start);
+		used += fr_time_sub(end, start);
 	}
 	fr_pair_list_free(&test_vps);
 	TEST_MSG_ALWAYS("repetitions=%d", reps);
diff --git a/src/lib/util/pair_tests.c b/src/lib/util/pair_tests.c
index e074cd75c9..5f46861201 100644
--- a/src/lib/util/pair_tests.c
+++ b/src/lib/util/pair_tests.c
@@ -644,7 +644,7 @@ static void test_fr_pair_value_aprintf(void)
 	char      fmt_test[64];
 	fr_time_t now = fr_time();
 
-	snprintf(fmt_test, sizeof(fmt_test), "Now is %ld", (long)now);
+	snprintf(fmt_test, sizeof(fmt_test), "Now is %"PRId64, fr_time_unwrap(now));
 
 	TEST_CASE("Find 'Test-String'");
 	TEST_CHECK((vp = fr_pair_find_by_da(&test_pairs, fr_dict_attr_test_string, 0)) != NULL);
@@ -653,7 +653,7 @@ static void test_fr_pair_value_aprintf(void)
 	VP_VERIFY(vp);
 
 	TEST_CASE("Copy content of 'fmt_test' to attribute value using fr_pair_value_aprintf()");
-	TEST_CHECK(fr_pair_value_aprintf(vp, "Now is %ld", (long)now) == 0);
+	TEST_CHECK(fr_pair_value_aprintf(vp, "Now is %"PRId64, fr_time_unwrap(now)) == 0);
 
 	TEST_CASE("Validating VP_VERIFY()");
 	VP_VERIFY(vp);
diff --git a/src/lib/util/retry.c b/src/lib/util/retry.c
index b055b89980..65f4f3b298 100644
--- a/src/lib/util/retry.c
+++ b/src/lib/util/retry.c
@@ -59,7 +59,7 @@ int fr_retry_init(fr_retry_t *r, fr_time_t now, fr_retry_config_t const *config)
 	rt = uint128_to_64(uint128_rshift(delay, 32));
 
 	r->rt = rt;
-	r->next = now + rt;
+	r->next = fr_time_add(now, rt);
 
 	return 0;
 }
@@ -98,10 +98,8 @@ redo:
 	if (r->config->mrd) {
 		fr_time_t end;
 
-		end = r->start;
-		end += r->config->mrd;
-
-		if (now > end) {
+		end = fr_time_add(r->start, r->config->mrd);
+		if (fr_time_gt(now, end)) {
 			return FR_RETRY_MRD;
 		}
 	}
@@ -149,7 +147,7 @@ redo:
 	 *	the packet at "next + rt", and not "now + rt".  That
 	 *	way the timer won't drift.
 	 */
-	r->next += rt;
+	r->next = fr_time_add(r->next, rt);
 
 	/*
 	 *	The "next" retransmission time is in the past, AND
@@ -160,7 +158,7 @@ redo:
 	 *	i.e. if we weren't serviced for one event, just skip
 	 *	it, and go to the next one.
 	 */
-	if ((r->next + (rt / 2)) < now) goto redo;
+	if (fr_time_lt(fr_time_add(r->next, (rt / 2)), now)) goto redo;
 
 	return FR_RETRY_CONTINUE;
 }
diff --git a/src/lib/util/strerror_tests.c b/src/lib/util/strerror_tests.c
index 349df8badd..d33e9aa74f 100644
--- a/src/lib/util/strerror_tests.c
+++ b/src/lib/util/strerror_tests.c
@@ -195,7 +195,7 @@ static void strerror_printf_benchmark(void)
 	}
 	stop = fr_time();
 
-	rate = (uint64_t)((float)NSEC / ((stop - start) / 100000));
+	rate = (uint64_t)((float)NSEC / (fr_time_sub(stop, start) / 100000));
 	printf("printf pop rate %" PRIu64 "\n", rate);
 
 	/* shared runners are terrible for performance tests */
@@ -219,7 +219,7 @@ static void strerror_const_benchmark(void)
 	}
 	stop = fr_time();
 
-	rate = (uint64_t)((float)NSEC / ((stop - start) / 100000));
+	rate = (uint64_t)((float)NSEC / (fr_time_sub(stop, start) / 100000));
 	printf("const pop rate %" PRIu64 "\n", rate);
 
 	/* shared runners are terrible for performance tests */
diff --git a/src/lib/util/time.c b/src/lib/util/time.c
index 752d0e024f..699f3ec8a1 100644
--- a/src/lib/util/time.c
+++ b/src/lib/util/time.c
@@ -505,12 +505,12 @@ DIAG_ON(format-nonliteral)
 
 void fr_time_elapsed_update(fr_time_elapsed_t *elapsed, fr_time_t start, fr_time_t end)
 {
-	fr_time_t delay;
+	fr_time_delta_t delay;
 
-	if (start >= end) {
+	if (fr_time_gteq(start, end)) {
 		delay = 0;
 	} else {
-		delay = end - start;
+		delay = fr_time_sub(end, start);
 	}
 
 	if (delay < 1000) { /* microseconds */
@@ -528,10 +528,10 @@ void fr_time_elapsed_update(fr_time_elapsed_t *elapsed, fr_time_t start, fr_time
 	} else if (delay < 10000000) {
 		elapsed->array[4]++;
 
-	} else if (delay < (fr_time_t) 100000000) {
+	} else if (delay < (fr_time_delta_t) 100000000) {
 		elapsed->array[5]++;
 
-	} else if (delay < (fr_time_t) 1000000000) { /* seconds */
+	} else if (delay < (fr_time_delta_t) 1000000000) { /* seconds */
 		elapsed->array[6]++;
 
 	} else {		/* tens of seconds or more */
diff --git a/src/lib/util/time.h b/src/lib/util/time.h
index 8c7e51c252..06324b1b4b 100644
--- a/src/lib/util/time.h
+++ b/src/lib/util/time.h
@@ -22,7 +22,7 @@
  * @brief Simple time functions
  *
  * @copyright 2016-2019 Alan DeKok (aland@freeradius.org)
- * @copyright 2019-2020 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
+ * @copyright 2019-2021 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
  */
 RCSIDH(time_h, "$Id$")
 
@@ -48,7 +48,9 @@ extern "C" {
  *  for internal timers, events, etc.  It can skew randomly as NTP
  *  plays with the local clock.
  */
-typedef int64_t fr_time_t;
+typedef struct fr_time_s {
+	int64_t	value;
+} fr_time_t;
 
 /** "Unix" time.  This is the time in nanoseconds since midnight January 1, 1970
  *
@@ -70,6 +72,46 @@ typedef uint64_t fr_unix_time_t;
  */
 typedef int64_t fr_time_delta_t;
 
+#define fr_time_wrap(_time) (fr_time_t){ .value = (_time) }
+#define fr_time_unwrap(_time) (_time).value
+
+/* Don't add fr_time_add_time_time, it's almost always a type error */
+static inline fr_time_t fr_time_add_time_delta(fr_time_t a, fr_time_delta_t b) { return fr_time_wrap(fr_time_unwrap(a) + b); }
+static inline fr_time_t fr_time_add_delta_time(fr_time_delta_t a, fr_time_t b) { return fr_time_wrap(a + fr_time_unwrap(b)); }
+static inline fr_time_delta_t fr_time_add_delta_delta(fr_time_delta_t a, fr_time_delta_t b) { return a + b; }
+
+#define fr_time_add(_a, _b) \
+	_Generic(_a, \
+		fr_time_t	: _Generic(_b, \
+					fr_time_delta_t	: fr_time_add_time_delta \
+				  ), \
+		fr_time_delta_t	: _Generic(_b, \
+					fr_time_t	: fr_time_add_delta_time, \
+					fr_time_delta_t	: fr_time_add_delta_delta \
+				  ) \
+	)(_a, _b)
+
+static inline fr_time_delta_t fr_time_sub_time_time(fr_time_t a, fr_time_t b) { return fr_time_unwrap(a) - fr_time_unwrap(b); }
+static inline fr_time_t fr_time_sub_time_delta(fr_time_t a, fr_time_delta_t b) { return fr_time_wrap(fr_time_unwrap(a) - b); }
+
+/** Subtract one time from another
+ *
+ */
+#define fr_time_sub(_a, _b) \
+	_Generic(_a, \
+		fr_time_t	: _Generic(_b, \
+					fr_time_t	: fr_time_sub_time_time, \
+					fr_time_delta_t	: fr_time_sub_time_delta \
+				  ) \
+	)(_a, _b)
+
+static inline bool fr_time_gt(fr_time_t a, fr_time_t b) { return fr_time_unwrap(a) > fr_time_unwrap(b); }
+static inline bool fr_time_gteq(fr_time_t a, fr_time_t b) { return fr_time_unwrap(a) >= fr_time_unwrap(b); }
+static inline bool fr_time_lt(fr_time_t a, fr_time_t b) { return fr_time_unwrap(a) < fr_time_unwrap(b); }
+static inline bool fr_time_lteq(fr_time_t a, fr_time_t b) { return fr_time_unwrap(a) <= fr_time_unwrap(b); }
+static inline bool fr_time_eq(fr_time_t a, fr_time_t b) { return fr_time_unwrap(a) == fr_time_unwrap(b); }
+static inline bool fr_time_neq(fr_time_t a, fr_time_t b) { return fr_time_unwrap(a) != fr_time_unwrap(b); }
+
 /** The base resolution for print parse operations
  */
 typedef enum {
@@ -86,6 +128,7 @@ typedef struct {
 #define NSEC	(1000000000)
 #define USEC	(1000000)
 #define MSEC	(1000)
+#define CSEC	(100)
 
 extern _Atomic int64_t			our_realtime;
 
@@ -102,6 +145,7 @@ extern uint64_t				our_mach_epoch;
 #define fr_unix_time_from_nsec(_x)	(fr_unix_time_t)(_x)
 #define fr_unix_time_from_usec(_x)	(fr_unix_time_t)fr_time_delta_from_usec((fr_time_delta_t)(_x))
 #define fr_unix_time_from_msec(_x)	(fr_unix_time_t)fr_time_delta_from_msec((fr_time_delta_t)(_x))
+#define fr_unix_time_from_csec(_x)	(fr_unix_time_t)fr_time_delta_from_csec((fr_time_delta_t)(_x))
 #define fr_unix_time_from_sec(_x)	(fr_unix_time_t)fr_time_delta_from_sec((fr_time_delta_t)(_x))
 
 /** Covert a time_t into out internal fr_unix_time_t
@@ -124,6 +168,7 @@ static inline CC_HINT(nonnull) fr_unix_time_t fr_unix_time_from_time(time_t time
 #define fr_unix_time_to_nsec(_x)	(uint64_t)(_x)
 #define fr_unix_time_to_usec(_x) 	(uint64_t)fr_time_delta_to_usec(_x)
 #define fr_unix_time_to_msec(_x) 	(uint64_t)fr_time_delta_to_msec(_x)
+#define fr_unix_time_to_csec(_x) 	(uint64_t)fr_time_delta_to_csec(_x)
 #define fr_unix_time_to_sec(_x)  	(uint64_t)fr_time_delta_to_sec(_x)
 
 static inline CC_HINT(nonnull) fr_unix_time_t fr_unix_time_from_timeval(struct timeval const *tv)
@@ -146,6 +191,11 @@ static inline fr_time_delta_t fr_time_delta_from_msec(int64_t msec)
 	return (msec * (NSEC / MSEC));
 }
 
+static inline fr_time_delta_t fr_time_delta_from_csec(int64_t csec)
+{
+	return (csec * (NSEC / CSEC));
+}
+
 static inline fr_time_delta_t fr_time_delta_from_sec(int64_t sec)
 {
 	return (sec * NSEC);
@@ -171,6 +221,11 @@ static inline int64_t fr_time_delta_to_msec(fr_time_delta_t delta)
 	return (delta / (NSEC / MSEC));
 }
 
+static inline int64_t fr_time_delta_to_csec(fr_time_delta_t delta)
+{
+	return (delta / (NSEC / CSEC));
+}
+
 static inline int64_t fr_time_delta_to_sec(fr_time_delta_t delta)
 {
 	return (delta / NSEC);
@@ -194,13 +249,13 @@ static inline int64_t fr_time_delta_to_sec(fr_time_delta_t delta)
  *
  * @param[in] _when	The server epoch time to convert.
  */
-#define fr_time_to_timeval(_when) fr_time_delta_to_timeval(fr_time_wallclock_at_last_sync() + _when)
+#define fr_time_to_timeval(_when) fr_time_delta_to_timeval(fr_time_wallclock_at_last_sync() + fr_time_unwrap(_when))
 
 /** Convert server epoch time to unix epoch time
  *
  * @param[in] _when	The server epoch time to convert.
  */
-#define fr_time_to_timespec(_when) fr_time_delta_to_timespec(fr_time_wallclock_at_last_sync() + _when)
+#define fr_time_to_timespec(_when) fr_time_delta_to_timespec(fr_time_wallclock_at_last_sync() + fr_time_unwrap(_when))
 
 
 /** Nanoseconds since the Unix Epoch the last time we synced internal time with wallclock time
@@ -216,7 +271,7 @@ static inline int64_t fr_time_wallclock_at_last_sync(void)
  */
 static inline fr_unix_time_t fr_time_to_unix_time(fr_time_t when)
 {
-	return when + atomic_load_explicit(&our_realtime, memory_order_consume);
+	return fr_time_unwrap(when) + atomic_load_explicit(&our_realtime, memory_order_consume);
 }
 
 /** Convert an fr_time_t (internal time) to number of usec since the unix epoch (wallclock time)
@@ -224,7 +279,7 @@ static inline fr_unix_time_t fr_time_to_unix_time(fr_time_t when)
  */
 static inline int64_t fr_time_to_usec(fr_time_t when)
 {
-	return ((when + atomic_load_explicit(&our_realtime, memory_order_consume)) / (NSEC / USEC));
+	return ((fr_time_unwrap(when) + atomic_load_explicit(&our_realtime, memory_order_consume)) / (NSEC / USEC));
 }
 
 /** Convert an fr_time_t (internal time) to number of msec since the unix epoch (wallclock time)
@@ -232,7 +287,15 @@ static inline int64_t fr_time_to_usec(fr_time_t when)
  */
 static inline int64_t fr_time_to_msec(fr_time_t when)
 {
-	return ((when + atomic_load_explicit(&our_realtime, memory_order_consume)) / (NSEC / MSEC));
+	return ((fr_time_unwrap(when) + atomic_load_explicit(&our_realtime, memory_order_consume)) / (NSEC / MSEC));
+}
+
+/** Convert an fr_time_t (internal time) to number of csec since the unix epoch (wallclock time)
+ *
+ */
+static inline int64_t fr_time_to_csec(fr_time_t when)
+{
+	return ((fr_time_unwrap(when) + atomic_load_explicit(&our_realtime, memory_order_consume)) / (NSEC / CSEC));
 }
 
 /** Convert an fr_time_t (internal time) to number of sec since the unix epoch (wallclock time)
@@ -240,7 +303,20 @@ static inline int64_t fr_time_to_msec(fr_time_t when)
  */
 static inline int64_t fr_time_to_sec(fr_time_t when)
 {
-	return ((when + atomic_load_explicit(&our_realtime, memory_order_consume)) / NSEC);
+	return ((fr_time_unwrap(when) + atomic_load_explicit(&our_realtime, memory_order_consume)) / NSEC);
+}
+
+/** Convert a timespec (wallclock time) to a fr_time_t (internal time)
+ *
+ * @param[in] when_ts	The timestamp to convert.
+ * @return
+ *	- >0 number of nanoseconds since the server started.
+ *	- 0 when the server started.
+ *	- 0 if when_tv occurred before the server started.
+ */
+static inline CC_HINT(nonnull) fr_time_t fr_time_from_timespec(struct timespec const *when_ts)
+{
+	return fr_time_wrap(fr_time_delta_from_timespec(when_ts) - atomic_load_explicit(&our_realtime, memory_order_consume));
 }
 
 /** Convert a timeval (wallclock time) to a fr_time_t (internal time)
@@ -253,10 +329,10 @@ static inline int64_t fr_time_to_sec(fr_time_t when)
  */
 static inline CC_HINT(nonnull) fr_time_t fr_time_from_timeval(struct timeval const *when_tv)
 {
-	return fr_time_delta_from_timeval(when_tv) - atomic_load_explicit(&our_realtime, memory_order_consume);
+	return fr_time_wrap(fr_time_delta_from_timeval(when_tv) - atomic_load_explicit(&our_realtime, memory_order_consume));
 }
 
-/** Convert a time_t (wallclock time) to a fr_time_t (internal time)
+/** Convert a nsec (wallclock time) to a fr_time_t (internal time)
  *
  * @param[in] when	The timestamp to convert.
  * @return
@@ -264,12 +340,12 @@ static inline CC_HINT(nonnull) fr_time_t fr_time_from_timeval(struct timeval con
  *	- 0 when the server started.
  *	- <0 number of nanoseconds before the server started.
  */
-static inline fr_time_t fr_time_from_sec(time_t when)
+static inline fr_time_t fr_time_from_nsec(int64_t when)
 {
-	return (((fr_time_t) when) * NSEC) - atomic_load_explicit(&our_realtime, memory_order_consume);
+	return fr_time_wrap((when * NSEC) - atomic_load_explicit(&our_realtime, memory_order_consume));
 }
 
-/** Convert msec (wallclock time) to a fr_time_t (internal time)
+/** Convert usec (wallclock time) to a fr_time_t (internal time)
  *
  * @param[in] when	The timestamp to convert.
  * @return
@@ -277,12 +353,12 @@ static inline fr_time_t fr_time_from_sec(time_t when)
  *	- 0 when the server started.
  *	- <0 number of nanoseconds before the server started.
  */
-static inline fr_time_t fr_time_from_msec(int64_t when)
+static inline fr_time_t fr_time_from_usec(int64_t when)
 {
-	return (((fr_time_t) when) * MSEC) - atomic_load_explicit(&our_realtime, memory_order_consume);
+	return fr_time_wrap((when * USEC) - atomic_load_explicit(&our_realtime, memory_order_consume));
 }
 
-/** Convert usec (wallclock time) to a fr_time_t (internal time)
+/** Convert msec (wallclock time) to a fr_time_t (internal time)
  *
  * @param[in] when	The timestamp to convert.
  * @return
@@ -290,12 +366,12 @@ static inline fr_time_t fr_time_from_msec(int64_t when)
  *	- 0 when the server started.
  *	- <0 number of nanoseconds before the server started.
  */
-static inline fr_time_t fr_time_from_usec(int64_t when)
+static inline fr_time_t fr_time_from_msec(int64_t when)
 {
-	return (((fr_time_t) when) * USEC) - atomic_load_explicit(&our_realtime, memory_order_consume);
+	return fr_time_wrap((when * MSEC) - atomic_load_explicit(&our_realtime, memory_order_consume));
 }
 
-/** Convert a nsec (wallclock time) to a fr_time_t (internal time)
+/** Convert csec (wallclock time) to a fr_time_t (internal time)
  *
  * @param[in] when	The timestamp to convert.
  * @return
@@ -303,22 +379,22 @@ static inline fr_time_t fr_time_from_usec(int64_t when)
  *	- 0 when the server started.
  *	- <0 number of nanoseconds before the server started.
  */
-static inline fr_time_t fr_time_from_nsec(int64_t when)
+static inline fr_time_t fr_time_from_csec(int64_t when)
 {
-	return (((fr_time_t) when) * NSEC) - atomic_load_explicit(&our_realtime, memory_order_consume);
+	return fr_time_wrap((when * CSEC) - atomic_load_explicit(&our_realtime, memory_order_consume));
 }
 
-/** Convert a timespec (wallclock time) to a fr_time_t (internal time)
+/** Convert a time_t (wallclock time) to a fr_time_t (internal time)
  *
- * @param[in] when_ts	The timestamp to convert.
+ * @param[in] when	The timestamp to convert.
  * @return
  *	- >0 number of nanoseconds since the server started.
  *	- 0 when the server started.
- *	- 0 if when_tv occurred before the server started.
+ *	- <0 number of nanoseconds before the server started.
  */
-static inline CC_HINT(nonnull) fr_time_t fr_time_from_timespec(struct timespec const *when_ts)
+static inline fr_time_t fr_time_from_sec(time_t when)
 {
-	return fr_time_delta_from_timespec(when_ts) - atomic_load_explicit(&our_realtime, memory_order_consume);
+	return fr_time_wrap((when * NSEC) - atomic_load_explicit(&our_realtime, memory_order_consume));
 }
 
 /** Compare two fr_time_t values
@@ -332,7 +408,7 @@ static inline CC_HINT(nonnull) fr_time_t fr_time_from_timespec(struct timespec c
  */
 static inline int8_t fr_time_cmp(fr_time_t a, fr_time_t b)
 {
-	return CMP(a, b);
+	return CMP(fr_time_unwrap(a), fr_time_unwrap(b));
 }
 
 /** Return a relative time since the server our_epoch
@@ -349,7 +425,7 @@ static inline fr_time_t fr_time(void)
 #ifdef HAVE_CLOCK_GETTIME
 	struct timespec ts;
 	(void) clock_gettime(CLOCK_MONOTONIC, &ts);
-	return fr_time_delta_from_timespec(&ts) - our_epoch;
+	return fr_time_wrap(fr_time_delta_from_timespec(&ts) - our_epoch);
 #else  /* __MACH__ is defined */
 	uint64_t when;
 
diff --git a/src/lib/util/udp.c b/src/lib/util/udp.c
index ef4e4065f6..48a10c4b7e 100644
--- a/src/lib/util/udp.c
+++ b/src/lib/util/udp.c
@@ -157,7 +157,7 @@ ssize_t udp_recv(int sockfd, int flags,
 
 	if ((flags & UDP_FLAGS_PEEK) != 0) sock_flags |= MSG_PEEK;
 
-	if (when) *when = 0;
+	if (when) *when = fr_time_wrap(0);
 
 	/*
 	 *	Always initialise the output socket structure
@@ -209,7 +209,7 @@ done:
 	 *	We didn't get it from the kernel
 	 *	so use our own time source.
 	 */
-	if (when && !*when) *when = fr_time();
+	if (when && fr_time_eq(*when, fr_time_wrap(0))) *when = fr_time();
 
 	return slen;
 }
diff --git a/src/lib/util/udp_queue.c b/src/lib/util/udp_queue.c
index b531332c7f..93a2861c7f 100644
--- a/src/lib/util/udp_queue.c
+++ b/src/lib/util/udp_queue.c
@@ -131,7 +131,7 @@ fr_udp_queue_t *fr_udp_queue_alloc(TALLOC_CTX *ctx, fr_udp_queue_config_t const
 	 */
 	if (config->send_buff_is_set) {
 		int opt;
-	
+
 		opt = config->send_buff;
 
 		if (opt < 65536) opt = 65536;
@@ -195,7 +195,7 @@ static void udp_queue_writable(UNUSED fr_event_list_t *el, UNUSED int fd,
 		 *	If the entry is expired, tell the caller that
 		 *	it wasn't written to the socket.
 		 */
-		if (now >= entry->expires) {
+		if (fr_time_gteq(now, entry->expires)) {
 			void *rctx = entry->rctx;
 
 			talloc_free(entry);
@@ -316,7 +316,7 @@ retry:
 		.sockaddr = sockaddr,
 		.socklen = socklen,
 		.uq = uq,
-		.expires = fr_time() + uq->config->max_queued_time,
+		.expires = fr_time_add(fr_time(), uq->config->max_queued_time),
 		.rctx = rctx,
 		.packet_len = packet_len,
 	};
diff --git a/src/lib/util/udpfromto.c b/src/lib/util/udpfromto.c
index b7ce9759c7..bd4cf80508 100644
--- a/src/lib/util/udpfromto.c
+++ b/src/lib/util/udpfromto.c
@@ -300,7 +300,7 @@ int recvfromto(int fd, void *buf, size_t len, int flags,
 	if (from_len) *from_len = msgh.msg_namelen;
 
 	if (ifindex) *ifindex = 0;
-	if (when) *when = 0;
+	if (when) *when = fr_time_wrap(0);
 
 	/* Process auxiliary received data in msgh */
 	for (cmsg = CMSG_FIRSTHDR(&msgh);
@@ -355,7 +355,7 @@ int recvfromto(int fd, void *buf, size_t len, int flags,
 #endif
 	}
 
-	if (when && !*when) *when = fr_time();
+	if (when && fr_time_eq(*when, fr_time_wrap(0))) *when = fr_time();
 
 	return ret;
 }
diff --git a/src/lib/util/value.h b/src/lib/util/value.h
index ae4dbd098d..8eac796567 100644
--- a/src/lib/util/value.h
+++ b/src/lib/util/value.h
@@ -266,6 +266,8 @@ typedef enum {
 
 #define fr_box_date(_val)			_fr_box(FR_TYPE_DATE, .vb_date, _val)
 
+#define fr_box_time(_val)			_fr_box(FR_TYPE_DATE, .vb_date, fr_time_to_unix_time(_val))
+
 #define fr_box_size(_val)			_fr_box(FR_TYPE_SIZE, .vb_size, _val)
 
 #define _fr_box_with_da(_type, _field, _val, _da) (&(fr_value_box_t){ .type = _type, _field = (_val), .enumv = (_da) })
diff --git a/src/listen/cron/proto_cron_crontab.c b/src/listen/cron/proto_cron_crontab.c
index a5ca90e333..f179994f3c 100644
--- a/src/listen/cron/proto_cron_crontab.c
+++ b/src/listen/cron/proto_cron_crontab.c
@@ -638,7 +638,8 @@ use_time:
 		      cf_section_name2(thread->inst->parent->server_cs), buffer, end - start);
 	}
 
-	if (fr_event_timer_at(thread, el, &thread->ev, now + fr_time_delta_from_sec(end - start), do_cron, thread) < 0) {
+	if (fr_event_timer_at(thread, el, &thread->ev, fr_time_add(now, fr_time_delta_from_sec(end - start)),
+			      do_cron, thread) < 0) {
 		fr_assert(0);
 	}
 
diff --git a/src/listen/detail/proto_detail.c b/src/listen/detail/proto_detail.c
index 060436216e..a656abc371 100644
--- a/src/listen/detail/proto_detail.c
+++ b/src/listen/detail/proto_detail.c
@@ -277,7 +277,7 @@ static int mod_decode(void const *instance, request_t *request, uint8_t *const d
 
 			vp = fr_pair_afrom_da(request->request_ctx, attr_packet_original_timestamp);
 			if (vp) {
-				vp->vp_date = ((fr_time_t) timestamp) * NSEC;
+				vp->vp_date = fr_unix_time_from_sec(timestamp);
 				vp->type = VT_DATA;
 				fr_dcursor_append(&cursor, vp);
 			}
diff --git a/src/listen/detail/proto_detail_file.c b/src/listen/detail/proto_detail_file.c
index 1505eba0f7..b7073b6815 100644
--- a/src/listen/detail/proto_detail_file.c
+++ b/src/listen/detail/proto_detail_file.c
@@ -247,7 +247,7 @@ static int work_exists(proto_detail_file_thread_t *thread, int fd)
 	 *	"detail.work" exists, try to lock it.
 	 */
 	if (rad_lockfd_nonblock(fd, 0) < 0) {
-		fr_time_t delay;
+		fr_time_delta_t delay;
 
 		DEBUG3("proto_detail (%s): Failed locking %s: %s",
 		       thread->name, inst->filename_work, fr_syserror(errno));
diff --git a/src/listen/detail/proto_detail_work.c b/src/listen/detail/proto_detail_work.c
index f341eb6e52..a4ecec4dc8 100644
--- a/src/listen/detail/proto_detail_work.c
+++ b/src/listen/detail/proto_detail_work.c
@@ -584,7 +584,7 @@ static ssize_t mod_write(fr_listen_t *li, void *packet_ctx, UNUSED fr_time_t req
 	fr_assert(thread->fd >= 0);
 
 	if (!buffer[0]) {
-		if (track->retry.start == 0) {
+		if (fr_time_eq(track->retry.start, fr_time_wrap(0))) {
 			fr_retry_init(&track->retry, fr_time(), &inst->retry_config);
 		} else {
 			fr_retry_state_t state;
diff --git a/src/listen/load/proto_load_step.c b/src/listen/load/proto_load_step.c
index a87833f96a..48b547b8df 100644
--- a/src/listen/load/proto_load_step.c
+++ b/src/listen/load/proto_load_step.c
@@ -88,7 +88,7 @@ static const CONF_PARSER load_listen_config[] = {
 
 	{ FR_CONF_OFFSET("start_pps", FR_TYPE_UINT32, proto_load_step_t, load.start_pps) },
 	{ FR_CONF_OFFSET("max_pps", FR_TYPE_UINT32, proto_load_step_t, load.max_pps) },
-	{ FR_CONF_OFFSET("duration", FR_TYPE_UINT32, proto_load_step_t, load.duration) },
+	{ FR_CONF_OFFSET("duration", FR_TYPE_TIME_DELTA, proto_load_step_t, load.duration) },
 	{ FR_CONF_OFFSET("step", FR_TYPE_UINT32, proto_load_step_t, load.step) },
 	{ FR_CONF_OFFSET("max_backlog", FR_TYPE_UINT32, proto_load_step_t, load.milliseconds) },
 	{ FR_CONF_OFFSET("parallel", FR_TYPE_UINT32, proto_load_step_t, load.parallel) },
@@ -372,8 +372,8 @@ static int mod_bootstrap(void *instance, CONF_SECTION *cs)
 	if (inst->load.max_pps > 0) FR_INTEGER_BOUND_CHECK("max_pps", inst->load.max_pps, >, inst->load.start_pps);
 	FR_INTEGER_BOUND_CHECK("max_pps", inst->load.max_pps, <, 100000);
 
-	FR_INTEGER_BOUND_CHECK("duration", inst->load.duration, >=, 1);
-	FR_INTEGER_BOUND_CHECK("duration", inst->load.duration, <, 10000);
+	FR_TIME_DELTA_BOUND_CHECK("duration", inst->load.duration, >=, fr_time_delta_from_sec(1));
+	FR_TIME_DELTA_BOUND_CHECK("duration", inst->load.duration, <, fr_time_delta_from_sec(10000));
 
 
 	FR_INTEGER_BOUND_CHECK("parallel", inst->load.parallel, >=, 1);
diff --git a/src/modules/proto_bfd/proto_bfd.c b/src/modules/proto_bfd/proto_bfd.c
index b84cee790b..af76e33ab5 100644
--- a/src/modules/proto_bfd/proto_bfd.c
+++ b/src/modules/proto_bfd/proto_bfd.c
@@ -947,11 +947,11 @@ static int bfd_start_packets(bfd_state_t *session)
 
 static void bfd_set_timeout(bfd_state_t *session, fr_time_t when)
 {
-	fr_time_t now = when;
+	fr_time_t now;
 
 	fr_event_timer_delete(&session->ev_timeout);
 
-	now += fr_time_delta_from_usec(session->detection_time);
+	now = fr_time_add(when, fr_time_delta_from_usec(session->detection_time));
 
 	if (session->detect_multi >= 2) {
 		uint32_t delay;
@@ -960,7 +960,7 @@ static void bfd_set_timeout(bfd_state_t *session, fr_time_t when)
 		delay = session->detection_time / session->detect_multi;
 		delay += delay / 2;
 
-		session->next_recv += fr_time_delta_from_usec(delay);
+		session->next_recv = fr_time_add(session->next_recv, fr_time_delta_from_usec(delay));
 	}
 
 	if (fr_event_timer_at(session, session->el, &session->ev_timeout,
@@ -1323,7 +1323,7 @@ static int bfd_process(bfd_state_t *session, bfd_packet_t *bfd)
 	 *	We've received a packet, but missed the previous one.
 	 *	Warn about it.
 	 */
-	if ((session->detect_multi >= 2) && (session->last_recv > session->next_recv)) {
+	if ((session->detect_multi >= 2) && (fr_time_gt(session->last_recv, session->next_recv))) {
 		fr_radius_packet_t packet;
 		request_t request;
 
diff --git a/src/modules/rlm_cache/rlm_cache.c b/src/modules/rlm_cache/rlm_cache.c
index 65a05c4f06..474e5c78e2 100644
--- a/src/modules/rlm_cache/rlm_cache.c
+++ b/src/modules/rlm_cache/rlm_cache.c
@@ -39,7 +39,7 @@ extern module_t rlm_cache;
 static const CONF_PARSER module_config[] = {
 	{ FR_CONF_OFFSET("driver", FR_TYPE_STRING, rlm_cache_config_t, driver_name), .dflt = "rlm_cache_rbtree" },
 	{ FR_CONF_OFFSET("key", FR_TYPE_TMPL | FR_TYPE_REQUIRED, rlm_cache_config_t, key) },
-	{ FR_CONF_OFFSET("ttl", FR_TYPE_UINT32, rlm_cache_config_t, ttl), .dflt = "500" },
+	{ FR_CONF_OFFSET("ttl", FR_TYPE_TIME_DELTA, rlm_cache_config_t, ttl), .dflt = "500s" },
 	{ FR_CONF_OFFSET("max_entries", FR_TYPE_UINT32, rlm_cache_config_t, max_entries), .dflt = "0" },
 
 	/* Should be a type which matches time_t, @fixme before 2038 */
@@ -238,10 +238,9 @@ static unlang_action_t cache_find(rlm_rcode_t *p_result, rlm_cache_entry_t **out
 	 */
 	if ((c->expires < fr_time_to_unix_time(request->packet->timestamp)) ||
 	    (c->created < fr_unix_time_from_sec(inst->config.epoch))) {
-		RDEBUG2("Found entry for \"%pV\", but it expired %pV seconds ago.  Removing it",
+		RDEBUG2("Found entry for \"%pV\", but it expired %pV ago.  Removing it",
 			fr_box_strvalue_len((char const *)key, key_len),
-			fr_box_date(fr_time_to_unix_time(request->packet->timestamp -
-							 fr_time_delta_from_sec(c->expires))));
+			fr_box_time_delta(fr_time_to_unix_time(request->packet->timestamp) - c->expires));
 
 		inst->driver->expire(&inst->config, inst->driver_inst->dl_inst->data, request, handle, c->key, c->key_len);
 		cache_free(inst, &c);
@@ -294,7 +293,7 @@ static unlang_action_t cache_expire(rlm_rcode_t *p_result,
  */
 static unlang_action_t cache_insert(rlm_rcode_t *p_result,
 				    rlm_cache_t const *inst, request_t *request, rlm_cache_handle_t **handle,
-				    uint8_t const *key, size_t key_len, int ttl)
+				    uint8_t const *key, size_t key_len, fr_time_delta_t ttl)
 {
 	map_t			const *map = NULL;
 	map_t			*c_map;
@@ -323,7 +322,7 @@ static unlang_action_t cache_insert(rlm_rcode_t *p_result,
 	 *	All in NSEC resolution
 	 */
 	c->created = c->expires = fr_time_to_unix_time(request->packet->timestamp);
-	c->expires += fr_time_delta_from_sec(ttl);
+	c->expires += ttl;
 
 	RDEBUG2("Creating new cache entry");
 
@@ -444,7 +443,7 @@ static unlang_action_t cache_insert(rlm_rcode_t *p_result,
 			RETURN_MODULE_FAIL;
 
 		case CACHE_OK:
-			RDEBUG2("Committed entry, TTL %d seconds", ttl);
+			RDEBUG2("Committed entry, TTL %pV seconds", fr_box_time_delta(ttl));
 			cache_free(inst, &c);
 			RETURN_MODULE_RCODE(merge ? RLM_MODULE_UPDATED : RLM_MODULE_OK);
 
@@ -551,7 +550,7 @@ static unlang_action_t CC_HINT(nonnull) mod_cache_it(rlm_rcode_t *p_result, modu
 	ssize_t			key_len;
 	rlm_rcode_t		rcode = RLM_MODULE_NOOP;
 
-	int			ttl = inst->config.ttl;
+	fr_time_delta_t		ttl = inst->config.ttl;
 
 	key_len = tmpl_expand((char const **)&key, (char *)buffer, sizeof(buffer),
 			      request, inst->config.key, NULL, NULL);
@@ -602,11 +601,11 @@ static unlang_action_t CC_HINT(nonnull) mod_cache_it(rlm_rcode_t *p_result, modu
 			expire = true;
 		} else if (vp->vp_int32 < 0) {
 			expire = true;
-			ttl = -(vp->vp_int32);
+			ttl = fr_time_delta_from_sec(-(vp->vp_int32));
 		/* Updating the TTL */
 		} else {
 			set_ttl = true;
-			ttl = vp->vp_int32;
+			ttl = fr_time_delta_from_sec(vp->vp_int32);
 		}
 	}
 
@@ -614,7 +613,7 @@ static unlang_action_t CC_HINT(nonnull) mod_cache_it(rlm_rcode_t *p_result, modu
 	RDEBUG3("merge  : %s", merge ? "yes" : "no");
 	RDEBUG3("insert : %s", insert ? "yes" : "no");
 	RDEBUG3("expire : %s", expire ? "yes" : "no");
-	RDEBUG3("ttl    : %i", ttl);
+	RDEBUG3("ttl    : %pV", fr_box_time_delta(ttl));
 	REXDENT();
 	if (cache_acquire(&handle, inst, request) < 0) {
 		RETURN_MODULE_FAIL;
diff --git a/src/modules/rlm_cache/rlm_cache.h b/src/modules/rlm_cache/rlm_cache.h
index 0e84875dc8..ad8db18024 100644
--- a/src/modules/rlm_cache/rlm_cache.h
+++ b/src/modules/rlm_cache/rlm_cache.h
@@ -51,8 +51,8 @@ typedef enum {
 typedef struct {
 	char const		*name;			//!< Name of xlat function to register.
 	char const		*driver_name;		//!< Driver name.
-	tmpl_t		*key;			//!< What to expand to get the value of the key.
-	uint32_t		ttl;			//!< How long an entry is valid for.
+	tmpl_t			*key;			//!< What to expand to get the value of the key.
+	fr_time_delta_t		ttl;			//!< How long an entry is valid for.
 	uint32_t		max_entries;		//!< Maximum entries allowed.
 	int32_t			epoch;			//!< Time after which entries are considered valid.
 	bool			stats;			//!< Generate statistics.
@@ -69,7 +69,7 @@ typedef struct {
 	rlm_cache_config_t	config;			//!< Must come first because of icky hacks.
 
 	module_instance_t	*driver_inst;		//!< Driver's instance data.
-	rlm_cache_driver_t const	*driver;		//!< Driver's exported interface.
+	rlm_cache_driver_t const *driver;		//!< Driver's exported interface.
 
 	fr_map_list_t		maps;			//!< Attribute map applied to users.
 							//!< and profiles.
diff --git a/src/modules/rlm_delay/rlm_delay.c b/src/modules/rlm_delay/rlm_delay.c
index 757c6b6504..751988fe25 100644
--- a/src/modules/rlm_delay/rlm_delay.c
+++ b/src/modules/rlm_delay/rlm_delay.c
@@ -62,7 +62,7 @@ static void _delay_done(UNUSED module_ctx_t const *mctx, request_t *request, voi
 	 *	timeout should never be *before* the scheduled time,
 	 *	if it is, something is very broken.
 	 */
-	if (!fr_cond_assert(fired >= *yielded)) REDEBUG("Unexpected resume time");
+	if (!fr_cond_assert(fr_time_gteq(fired, *yielded))) REDEBUG("Unexpected resume time");
 
 	unlang_interpret_mark_runnable(request);
 }
@@ -78,13 +78,13 @@ static void _xlat_delay_done(request_t *request,
 	 *	timeout should never be *before* the scheduled time,
 	 *	if it is, something is very broken.
 	 */
-	if (!fr_cond_assert(fired > *yielded)) REDEBUG("Unexpected resume time");
+	if (!fr_cond_assert(fr_time_gt(fired, *yielded))) REDEBUG("Unexpected resume time");
 
 	unlang_interpret_mark_runnable(request);
 }
 
 static int delay_add(request_t *request, fr_time_t *resume_at, fr_time_t now,
-		     fr_time_t delay, bool force_reschedule, bool relative)
+		     fr_time_delta_t delay, bool force_reschedule, bool relative)
 {
 	/*
 	 *	Delay is zero (and reschedule is not forced)
@@ -95,18 +95,18 @@ static int delay_add(request_t *request, fr_time_t *resume_at, fr_time_t now,
 	 *	Process the delay relative to the start of packet processing
 	 */
 	if (relative) {
-		*resume_at = request->packet->timestamp + delay;
+		*resume_at = fr_time_add(request->packet->timestamp, delay);
 	} else {
-		*resume_at = now + delay;
+		*resume_at = fr_time_add(now, delay);
 	}
 
 	/*
 	 *	If resume_at is in the past (and reschedule is not forced), just return noop
 	 */
-	if (!force_reschedule && (*resume_at <= now)) return 1;
+	if (!force_reschedule && fr_time_lteq(*resume_at, now)) return 1;
 
-	if (*resume_at > now) {
-		RDEBUG2("Delaying request by ~%pVs", fr_box_time_delta(*resume_at - now));
+	if (fr_time_gt(*resume_at, now)) {
+		RDEBUG2("Delaying request by ~%pVs", fr_box_time_delta(fr_time_sub(*resume_at, now)));
 	} else {
 		RDEBUG2("Rescheduling request");
 	}
@@ -125,7 +125,7 @@ static unlang_action_t mod_delay_return(rlm_rcode_t *p_result, UNUSED module_ctx
 	/*
 	 *	Print how long the delay *really* was.
 	 */
-	RDEBUG3("Request delayed by %pV", fr_box_time_delta(fr_time() - *yielded));
+	RDEBUG3("Request delayed by %pV", fr_box_time_delta(fr_time_sub(fr_time(), *yielded)));
 	talloc_free(yielded);
 
 	RETURN_MODULE_OK;
@@ -168,11 +168,8 @@ static unlang_action_t CC_HINT(nonnull) mod_delay(rlm_rcode_t *p_result, module_
 		RETURN_MODULE_NOOP;
 	}
 
-	/*
-	 *	FIXME - Should print wallclock time
-	 */
 	RDEBUG3("Current time %pVs, resume time %pVs",
-		fr_box_time_delta(*yielded_at), fr_box_time_delta(resume_at));
+		fr_box_time(*yielded_at), fr_box_time(resume_at));
 
 	if (unlang_module_timeout_add(request, _delay_done, yielded_at, resume_at) < 0) {
 		RPEDEBUG("Adding event failed");
@@ -188,10 +185,10 @@ static xlat_action_t xlat_delay_resume(TALLOC_CTX *ctx, fr_dcursor_t *out,
 				       UNUSED fr_value_box_list_t *in, void *rctx)
 {
 	fr_time_t	*yielded_at = talloc_get_type_abort(rctx, fr_time_t);
-	fr_time_t	delayed;
+	fr_time_delta_t	delayed;
 	fr_value_box_t	*vb;
 
-	delayed = fr_time() - *yielded_at;
+	delayed = fr_time_sub(fr_time(), *yielded_at);
 	talloc_free(yielded_at);
 
 	MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_TIME_DELTA, NULL, false));
@@ -265,10 +262,7 @@ static xlat_action_t xlat_delay(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out
 	}
 
 yield:
-	/*
-	 *	FIXME - Should print wallclock time
-	 */
-	RDEBUG3("Current time %pVs, resume time %pVs", fr_box_time_delta(*yielded_at), fr_box_time_delta(resume_at));
+	RDEBUG3("Current time %pVs, resume time %pVs", fr_box_time(*yielded_at), fr_box_time(resume_at));
 
 	if (unlang_xlat_event_timeout_add(request, _xlat_delay_done, yielded_at, resume_at) < 0) {
 		RPEDEBUG("Adding event failed");
diff --git a/src/modules/rlm_detail/rlm_detail.c b/src/modules/rlm_detail/rlm_detail.c
index dc5b136708..baed4c485b 100644
--- a/src/modules/rlm_detail/rlm_detail.c
+++ b/src/modules/rlm_detail/rlm_detail.c
@@ -148,7 +148,7 @@ static int mod_instantiate(void *instance, CONF_SECTION *conf)
 		inst->escape_func = rad_filename_make_safe;
 	}
 
-	inst->ef = module_exfile_init(inst, conf, 256, 30, inst->locking, NULL, NULL);
+	inst->ef = module_exfile_init(inst, conf, 256, fr_time_delta_from_sec(30), inst->locking, NULL, NULL);
 	if (!inst->ef) {
 		cf_log_err(conf, "Failed creating log file context");
 		return -1;
diff --git a/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.c b/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.c
index f199951285..1f2569f9b9 100644
--- a/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.c
+++ b/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.c
@@ -857,7 +857,7 @@ static fr_radius_packet_code_t eap_fast_process_tlvs(request_t *request, eap_ses
 			if (vp->da == attr_eap_fast_pac_acknowledge) {
 				if (vp->vp_uint32 == EAP_FAST_TLV_RESULT_SUCCESS) {
 					code = FR_RADIUS_CODE_ACCESS_ACCEPT;
-					t->pac.expires = ~((fr_time_t) 0);
+					t->pac.expires = fr_time_wrap(~fr_time_unwrap(fr_time_wrap(0)));
 					t->pac.expired = false;
 					t->stage = EAP_FAST_COMPLETE;
 				}
@@ -941,8 +941,9 @@ fr_radius_packet_code_t eap_fast_process(request_t *request, eap_session_t *eap_
 			/*
 			 *	Send a new pac at ~0.6 times the lifetime.
 			 */
-			if (!t->pac.expires || t->pac.expired ||
-			    t->pac.expires <= (request->packet->timestamp + fr_time_delta_from_sec((t->pac_lifetime >> 1) + (t->pac_lifetime >> 3)))) {
+			if (fr_time_eq(t->pac.expires, fr_time_wrap(0)) || t->pac.expired ||
+			    fr_time_lteq(t->pac.expires,
+					 fr_time_add(request->packet->timestamp, t->pac_lifetime))) {
 				t->pac.send = true;
 			}
 		}
diff --git a/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.h b/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.h
index 1c83b1979c..d70df90b27 100644
--- a/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.h
+++ b/src/modules/rlm_eap/types/rlm_eap_fast/eap_fast.h
@@ -183,7 +183,7 @@ typedef struct {
 	int			default_method;
 	int			default_provisioning_method;
 
-	uint32_t		pac_lifetime;
+	fr_time_delta_t		pac_lifetime;
 	char const		*authority_identity;
 	uint8_t const 		*a_id;
 	uint8_t const 		*pac_opaque_key;
diff --git a/src/modules/rlm_eap/types/rlm_eap_fast/rlm_eap_fast.c b/src/modules/rlm_eap/types/rlm_eap_fast/rlm_eap_fast.c
index 98800d720e..70acc76bd8 100644
--- a/src/modules/rlm_eap/types/rlm_eap_fast/rlm_eap_fast.c
+++ b/src/modules/rlm_eap/types/rlm_eap_fast/rlm_eap_fast.c
@@ -54,7 +54,7 @@ typedef struct {
 
 	int			stage;					//!< Processing stage.
 
-	uint32_t		pac_lifetime;				//!< seconds to add to current time to describe PAC lifetime
+	fr_time_delta_t		pac_lifetime;				//!< seconds to add to current time to describe PAC lifetime
 	char const		*authority_identity;			//!< The identity we present in the EAP-TLS
 	uint8_t			a_id[PAC_A_ID_LENGTH];			//!< The identity we present in the EAP-TLS
 	char const		*pac_opaque_key;			//!< The key used to encrypt PAC-Opaque
@@ -71,7 +71,7 @@ static CONF_PARSER submodule_config[] = {
 
 	{ FR_CONF_OFFSET("require_client_cert", FR_TYPE_BOOL, rlm_eap_fast_t, req_client_cert), .dflt = "no" },
 
-	{ FR_CONF_OFFSET("pac_lifetime", FR_TYPE_UINT32, rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
+	{ FR_CONF_OFFSET("pac_lifetime", FR_TYPE_TIME_DELTA, rlm_eap_fast_t, pac_lifetime), .dflt = "604800" },
 	{ FR_CONF_OFFSET("authority_identity", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_fast_t, authority_identity) },
 	{ FR_CONF_OFFSET("pac_opaque_key", FR_TYPE_STRING | FR_TYPE_REQUIRED, rlm_eap_fast_t, pac_opaque_key) },
 
@@ -333,8 +333,8 @@ error:
 			fr_assert(t->pac.type == 0);
 			t->pac.type = vp->vp_uint16;
 		} else if (vp->da == attr_eap_fast_pac_info_pac_lifetime) {
-			fr_assert(t->pac.expires == 0);
-			t->pac.expires = request->packet->timestamp + fr_time_delta_from_sec(vp->vp_uint32);
+			fr_assert(fr_time_eq(t->pac.expires, fr_time_wrap(0)));
+			t->pac.expires = fr_time_add(request->packet->timestamp, fr_time_delta_from_sec(vp->vp_uint32));
 			t->pac.expired = false;
 		/*
 		 *	Not sure if this is the correct attr
@@ -365,7 +365,7 @@ error:
 		goto error;
 	}
 
-	if (!t->pac.expires) {
+	if (fr_time_eq(t->pac.expires, fr_time_wrap(0))) {
 		errmsg = "PAC missing lifetime TLV";
 		goto error;
 	}
diff --git a/src/modules/rlm_icmp/rlm_icmp.c b/src/modules/rlm_icmp/rlm_icmp.c
index 47f75cd489..411360a973 100644
--- a/src/modules/rlm_icmp/rlm_icmp.c
+++ b/src/modules/rlm_icmp/rlm_icmp.c
@@ -231,7 +231,8 @@ static xlat_action_t xlat_icmp(TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out,
 		return XLAT_ACTION_FAIL;
 	}
 
-	if (unlang_xlat_event_timeout_add(request, _xlat_icmp_timeout, echo, fr_time() + inst->timeout) < 0) {
+	if (unlang_xlat_event_timeout_add(request, _xlat_icmp_timeout, echo,
+					  fr_time_add(fr_time(), inst->timeout)) < 0) {
 		RPEDEBUG("Failed adding timeout");
 		(void) fr_rb_delete(thread->t->tree, echo);
 		talloc_free(echo);
diff --git a/src/modules/rlm_linelog/rlm_linelog.c b/src/modules/rlm_linelog/rlm_linelog.c
index 5df5de76c9..bdf6cf0518 100644
--- a/src/modules/rlm_linelog/rlm_linelog.c
+++ b/src/modules/rlm_linelog/rlm_linelog.c
@@ -324,7 +324,7 @@ static int mod_instantiate(void *instance, CONF_SECTION *conf)
 			return -1;
 		}
 
-		inst->file.ef = module_exfile_init(inst, conf, 256, 30, true, NULL, NULL);
+		inst->file.ef = module_exfile_init(inst, conf, 256, fr_time_delta_from_sec(30), true, NULL, NULL);
 		if (!inst->file.ef) {
 			cf_log_err(conf, "Failed creating log file context");
 			return -1;
diff --git a/src/modules/rlm_perl/rlm_perl.c b/src/modules/rlm_perl/rlm_perl.c
index caa8f5df50..d665ca3c03 100644
--- a/src/modules/rlm_perl/rlm_perl.c
+++ b/src/modules/rlm_perl/rlm_perl.c
@@ -31,6 +31,7 @@ RCSID("$Id$")
 #include <freeradius-devel/util/debug.h>
 #include <freeradius-devel/radius/radius.h>
 
+DIAG_OFF(compound-token-split-by-macro) /* Perl does horrible things with macros */
 #ifdef INADDR_ANY
 #  undef INADDR_ANY
 #endif
diff --git a/src/modules/rlm_radius/rlm_radius_udp.c b/src/modules/rlm_radius/rlm_radius_udp.c
index 70d51fd7eb..97cd8f260a 100644
--- a/src/modules/rlm_radius/rlm_radius_udp.c
+++ b/src/modules/rlm_radius/rlm_radius_udp.c
@@ -322,7 +322,7 @@ static void status_check_reset(udp_handle_t *h, udp_request_t *u)
 
 	h->status_checking = false;
 	u->num_replies = 0;	/* Reset */
-	u->retry.start = 0;
+	u->retry.start = fr_time_wrap(0);
 
 	if (u->ev) (void) fr_event_timer_delete(&u->ev);
 
@@ -485,7 +485,8 @@ static void conn_status_check_timeout(fr_event_list_t *el, fr_time_t now, void *
 	switch (fr_retry_next(&u->retry, now)) {
 	case FR_RETRY_MRD:
 		DEBUG("%s - Reached maximum_retransmit_duration (%pVs > %pVs), failing status checks",
-		      h->module_name, fr_box_time_delta(now - u->retry.start), fr_box_time_delta(u->retry.config->mrd));
+		      h->module_name, fr_box_time_delta(fr_time_sub(now, u->retry.start)),
+		      fr_box_time_delta(u->retry.config->mrd));
 		goto fail;
 
 	case FR_RETRY_MRC:
@@ -592,7 +593,7 @@ static void conn_readable_status_check(fr_event_list_t *el, UNUSED int fd, UNUSE
 	 *	Last trunk event was a failure, be more careful about
 	 *	bringing up the connection (require multiple responses).
 	 */
-	if ((trunk->last_failed && (trunk->last_failed > trunk->last_connected)) &&
+	if ((fr_time_gt(trunk->last_failed, fr_time_wrap(0)) && (fr_time_gt(trunk->last_failed, trunk->last_connected))) &&
 	    (u->num_replies < inst->num_answers_to_alive)) {
 		/*
 		 *	Leave the timer in place.  This timer is BOTH when we
@@ -602,7 +603,7 @@ static void conn_readable_status_check(fr_event_list_t *el, UNUSED int fd, UNUSE
 		DEBUG("%s - Received %u / %u replies for status check, on connection - %s",
 		      h->module_name, u->num_replies, inst->num_answers_to_alive, h->name);
 		DEBUG("%s - Next status check packet will be in %pVs",
-		      h->module_name, fr_box_time_delta(u->retry.next - fr_time()));
+		      h->module_name, fr_box_time_delta(fr_time_sub(u->retry.next, fr_time())));
 
 		/*
 		 *	Set the timer for the next retransmit.
@@ -633,7 +634,7 @@ static void conn_writable_status_check(fr_event_list_t *el, UNUSED int fd, UNUSE
 	udp_request_t		*u = h->status_u;
 	ssize_t			slen;
 
-	if (!u->retry.start) {
+	if (fr_time_eq(u->retry.start, fr_time_wrap(0))) {
 		u->id = fr_rand() & 0xff;	/* We don't care what the value is here */
 		h->status_checking = true;	/* Ensure this is valid */
 		(void) fr_retry_init(&u->retry, fr_time(), &h->inst->parent->retry[u->code]);
@@ -1151,13 +1152,13 @@ static int8_t request_prioritise(void const *one, void const *two)
 	/*
 	 *	Larger priority is more important.
 	 */
-	ret = (a->priority < b->priority) - (a->priority > b->priority);
+	ret = CMP(a->priority, b->priority);
 	if (ret != 0) return ret;
 
 	/*
 	 *	Smaller timestamp (i.e. earlier) is more important.
 	 */
-	return (a->recv_time > b->recv_time) - (a->recv_time < b->recv_time);
+	return CMP_PREFER_SMALLER(fr_time_unwrap(a->recv_time), fr_time_unwrap(b->recv_time));
 }
 
 /** Decode response packet data, extracting relevant information and validating the packet
@@ -1262,7 +1263,7 @@ static decode_fail_t decode(TALLOC_CTX *ctx, fr_pair_list_t *reply, uint8_t *res
 	/*
 	 *	Fixup retry times
 	 */
-	if (u->retry.start > h->mrs_time) h->mrs_time = u->retry.start;
+	if (fr_time_gt(u->retry.start, h->mrs_time)) h->mrs_time = u->retry.start;
 
 	return DECODE_FAIL_NONE;
 }
@@ -1491,7 +1492,7 @@ static int encode(rlm_radius_udp_t const *inst, request_t *request, udp_request_
 			 */
 			memcpy(&delay, attr + 2, 4);
 			delay = ntohl(delay);
-			delay += fr_time_delta_to_sec(now - u->recv_time);
+			delay += fr_time_delta_to_sec(fr_time_sub(now, u->recv_time));
 			delay = htonl(delay);
 			memcpy(attr + 2, &delay, 4);
 			break;
@@ -1570,7 +1571,8 @@ static void zombie_timeout(fr_event_list_t *el, fr_time_t now, void *uctx)
 	/*
 	 *	Revive the connection after a time.
 	 */
-	if (fr_event_timer_at(h, el, &h->zombie_ev, now + h->inst->parent->revive_interval, revive_timeout, h) < 0) {
+	if (fr_event_timer_at(h, el, &h->zombie_ev,
+			      fr_time_add(now, h->inst->parent->revive_interval), revive_timeout, h) < 0) {
 		ERROR("Failed inserting revive timeout for connection");
 		fr_trunk_connection_signal_reconnect(tconn, FR_CONNECTION_FAILED);
 	}
@@ -1616,17 +1618,18 @@ static bool check_for_zombie(fr_event_list_t *el, fr_trunk_connection_t *tconn,
 	 */
 	if (h->status_checking || h->zombie_ev) return true;
 
-	if (now == 0) now = fr_time();
+	if (fr_time_eq(now, fr_time_wrap(0))) now = fr_time();
 
 	/*
 	 *	We received a reply since this packet was sent, the connection isn't zombie.
 	 */
-	if (h->last_reply >= last_sent) return false;
+	if (fr_time_gteq(h->last_reply, last_sent)) return false;
 
 	/*
 	 *	If we've seen ANY response in the allowed window, then the connection is still alive.
 	 */
-	if (h->inst->parent->synchronous && last_sent && ((last_sent + h->inst->parent->response_window) < now)) return false;
+	if (h->inst->parent->synchronous && fr_time_gt(last_sent, fr_time_wrap(0)) &&
+	    (fr_time_lt(fr_time_add(last_sent, h->inst->parent->response_window), now))) return false;
 
 	/*
 	 *	Mark the connection as inactive, but keep sending
@@ -1642,7 +1645,7 @@ static bool check_for_zombie(fr_event_list_t *el, fr_trunk_connection_t *tconn,
 		 *	Queue up the status check packet.  It will be sent
 		 *	when the connection is writable.
 		 */
-		h->status_u->retry.start = 0;
+		h->status_u->retry.start = fr_time_wrap(0);
 		h->status_r->treq = NULL;
 
 		if (fr_trunk_request_enqueue_on_conn(&h->status_r->treq, tconn, h->status_request,
@@ -1650,7 +1653,8 @@ static bool check_for_zombie(fr_event_list_t *el, fr_trunk_connection_t *tconn,
 			fr_trunk_connection_signal_reconnect(tconn, FR_CONNECTION_FAILED);
 		}
 	} else {
-		if (fr_event_timer_at(h, el, &h->zombie_ev, now + h->inst->parent->zombie_period, zombie_timeout, h) < 0) {
+		if (fr_event_timer_at(h, el, &h->zombie_ev, fr_time_add(now, h->inst->parent->zombie_period),
+				      zombie_timeout, h) < 0) {
 			ERROR("Failed inserting zombie timeout for connection");
 			fr_trunk_connection_signal_reconnect(tconn, FR_CONNECTION_FAILED);
 		}
@@ -1715,7 +1719,7 @@ static void request_retry(fr_event_list_t *el, fr_time_t now, void *uctx)
 
 	case FR_RETRY_MRD:
 		REDEBUG("Reached maximum_retransmit_duration (%pVs > %pVs), failing request",
-			fr_box_time_delta(now - u->retry.start), fr_box_time_delta(u->retry.config->mrd));
+			fr_box_time_delta(fr_time_sub(now, u->retry.start)), fr_box_time_delta(u->retry.config->mrd));
 		break;
 
 	case FR_RETRY_MRC:
@@ -1763,7 +1767,7 @@ static void status_check_retry(UNUSED fr_event_list_t *el, fr_time_t now, void *
 
 	case FR_RETRY_MRD:
 		REDEBUG("Reached maximum_retransmit_duration (%pVs > %pVs), failing request",
-			fr_box_time_delta(now - u->retry.start), fr_box_time_delta(u->retry.config->mrd));
+			fr_box_time_delta(fr_time_sub(now, u->retry.start)), fr_box_time_delta(u->retry.config->mrd));
 		break;
 
 	case FR_RETRY_MRC:
@@ -1798,7 +1802,7 @@ static void request_mux(fr_event_list_t *el,
 	 *	If the connection is zombie, then don't try to enqueue
 	 *	things on it!
 	 */
-	if (check_for_zombie(el, tconn, 0, h->last_sent)) return;
+	if (check_for_zombie(el, tconn, fr_time_wrap(0), h->last_sent)) return;
 
 	/*
 	 *	Encode multiple packets in preparation
@@ -1825,10 +1829,10 @@ static void request_mux(fr_event_list_t *el,
 		/*
 		 *	Start retransmissions from when the socket is writable.
 		 */
-		if (!u->retry.start) {
+		if (fr_time_eq(u->retry.start, fr_time_wrap(0))) {
 			(void) fr_retry_init(&u->retry, fr_time(), &h->inst->parent->retry[u->code]);
 			fr_assert(u->retry.rt > 0);
-			fr_assert(u->retry.next > 0);
+			fr_assert(fr_time_gt(u->retry.next, fr_time_wrap(0)));
 		}
 
 		/*
@@ -1995,7 +1999,7 @@ static void request_mux(fr_event_list_t *el,
 		if (u->retry.count == 1) {
 			action = inst->parent->originate ? "Originated" : "Proxied";
 			h->last_sent = u->retry.start;
-			if (h->first_sent <= h->last_idle) h->first_sent = h->last_sent;
+			if (fr_time_lteq(h->first_sent, h->last_idle)) h->first_sent = h->last_sent;
 
 		} else {
 			action = "Retransmitted";
@@ -2022,7 +2026,9 @@ static void request_mux(fr_event_list_t *el,
 			}
 
 		} else if (u->retry.count == 1) {
-			if (fr_event_timer_at(u, el, &u->ev, u->retry.start + h->inst->parent->response_window, request_timeout, treq) < 0) {
+			if (fr_event_timer_at(u, el, &u->ev,
+					      fr_time_add(u->retry.start, h->inst->parent->response_window),
+					      request_timeout, treq) < 0) {
 				RERROR("Failed inserting timeout for connection");
 				fr_trunk_request_signal_fail(treq);
 				continue;
@@ -2326,7 +2332,7 @@ static void status_check_reply(fr_trunk_request_t *treq, fr_time_t now)
 	if (u->num_replies < inst->num_answers_to_alive) {
 		DEBUG("Received %d / %u replies for status check, on connection - %s",
 		      u->num_replies, inst->num_answers_to_alive, h->name);
-		DEBUG("Next status check packet will be in %pVs", fr_box_time_delta(u->retry.next - now));
+		DEBUG("Next status check packet will be in %pVs", fr_box_time_delta(fr_time_sub(u->retry.next, now)));
 
 		/*
 		 *	If we're retransmitting, leave the ID,
diff --git a/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c b/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c
index 1fd2241ff4..7c6e8006ef 100644
--- a/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c
+++ b/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c
@@ -296,7 +296,7 @@ static CC_HINT(nonnull) sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_
 		FD_SET(sockfd, &read_fd);
 
 		if (config->query_timeout) {
-			elapsed = fr_time() - start;
+			elapsed = fr_time_sub(fr_time(), start);
 			if (elapsed >= timeout) goto too_long;
 		}
 
diff --git a/src/modules/rlm_sql/rlm_sql.c b/src/modules/rlm_sql/rlm_sql.c
index 7ae578e6e6..14b60017bc 100644
--- a/src/modules/rlm_sql/rlm_sql.c
+++ b/src/modules/rlm_sql/rlm_sql.c
@@ -1163,7 +1163,7 @@ static int mod_instantiate(void *instance, CONF_SECTION *conf)
 				inst->driver->sql_escape_func :
 				sql_escape_func;
 
-	inst->ef = module_exfile_init(inst, conf, 256, 30, true, NULL, NULL);
+	inst->ef = module_exfile_init(inst, conf, 256, fr_time_delta_from_sec(30), true, NULL, NULL);
 	if (!inst->ef) {
 		cf_log_err(conf, "Failed creating log file context");
 		return -1;
diff --git a/src/modules/rlm_sqlcounter/rlm_sqlcounter.c b/src/modules/rlm_sqlcounter/rlm_sqlcounter.c
index 8e1016ec51..3318e56b9f 100644
--- a/src/modules/rlm_sqlcounter/rlm_sqlcounter.c
+++ b/src/modules/rlm_sqlcounter/rlm_sqlcounter.c
@@ -111,19 +111,16 @@ fr_dict_attr_autoload_t rlm_sqlcounter_dict_attr[] = {
 	{ NULL }
 };
 
-static int find_next_reset(rlm_sqlcounter_t *inst, time_t timeval)
+static int find_next_reset(rlm_sqlcounter_t *inst, fr_time_t now)
 {
 	int		ret = 0;
 	size_t		len;
 	unsigned int	num = 1;
 	char		last = '\0';
 	struct tm	*tm, s_tm;
-	char		sCurrentTime[40], sNextTime[40];
-	time_t		date;
+	time_t		time_s = fr_time_to_sec(now);
 
-	tm = localtime_r(&timeval, &s_tm);
-	len = strftime(sCurrentTime, sizeof(sCurrentTime), "%Y-%m-%d %H:%M:%S", tm);
-	if (len == 0) *sCurrentTime = '\0';
+	tm = localtime_r(&time_s, &s_tm);
 	tm->tm_sec = tm->tm_min = 0;
 
 	fr_assert(inst->reset != NULL);
@@ -143,38 +140,33 @@ static int find_next_reset(rlm_sqlcounter_t *inst, time_t timeval)
 		 *  Round up to the next nearest hour.
 		 */
 		tm->tm_hour += num;
-		date = mktime(tm);
+		inst->reset_time = fr_time_from_sec(mktime(tm));
 	} else if (strcmp(inst->reset, "daily") == 0 || last == 'd') {
 		/*
 		 *  Round up to the next nearest day.
 		 */
 		tm->tm_hour = 0;
 		tm->tm_mday += num;
-		date = mktime(tm);
+		inst->reset_time = fr_time_from_sec(mktime(tm));
 	} else if (strcmp(inst->reset, "weekly") == 0 || last == 'w') {
 		/*
 		 *  Round up to the next nearest week.
 		 */
 		tm->tm_hour = 0;
 		tm->tm_mday += (7 - tm->tm_wday) +(7*(num-1));
-		date = mktime(tm);
+		inst->reset_time = fr_time_from_sec(mktime(tm));
 	} else if (strcmp(inst->reset, "monthly") == 0 || last == 'm') {
 		tm->tm_hour = 0;
 		tm->tm_mday = 1;
 		tm->tm_mon += num;
-		date = mktime(tm);
+		inst->reset_time = fr_time_from_sec(mktime(tm));
 	} else if (strcmp(inst->reset, "never") == 0) {
-		date = 0;
+		inst->reset_time = fr_time_wrap(0);
 	} else {
 		return -1;
 	}
 
-	inst->reset_time = fr_time_from_sec(date);
-
-	len = strftime(sNextTime, sizeof(sNextTime),"%Y-%m-%d %H:%M:%S",tm);
-	if (len == 0) *sNextTime = '\0';
-	DEBUG2("Current Time: %" PRId64 " [%s], Next reset %" PRId64 " [%s]",
-	       (int64_t) timeval, sCurrentTime, (int64_t) date, sNextTime);
+	DEBUG2("Current Time: %pV, Next reset %pV", fr_box_time(now), fr_box_time(inst->reset_time));
 
 	return ret;
 }
@@ -183,18 +175,16 @@ static int find_next_reset(rlm_sqlcounter_t *inst, time_t timeval)
 /*  I don't believe that this routine handles Daylight Saving Time adjustments
     properly.  Any suggestions?
 */
-static int find_prev_reset(rlm_sqlcounter_t *inst, time_t timeval)
+static int find_prev_reset(rlm_sqlcounter_t *inst, fr_time_t now)
 {
 	int		ret = 0;
 	size_t		len;
 	unsigned	int num = 1;
 	char		last = '\0';
 	struct		tm *tm, s_tm;
-	char		sCurrentTime[40], sPrevTime[40];
+	time_t		time_s = fr_time_to_sec(now);
 
-	tm = localtime_r(&timeval, &s_tm);
-	len = strftime(sCurrentTime, sizeof(sCurrentTime), "%Y-%m-%d %H:%M:%S", tm);
-	if (len == 0) *sCurrentTime = '\0';
+	tm = localtime_r(&time_s, &s_tm);
 	tm->tm_sec = tm->tm_min = 0;
 
 	fr_assert(inst->reset != NULL);
@@ -207,42 +197,40 @@ static int find_prev_reset(rlm_sqlcounter_t *inst, time_t timeval)
 		if (!isalpha((int) last))
 			last = 'd';
 		num = atoi(inst->reset);
-		DEBUG("num=%d, last=%c",num,last);
+		DEBUG("num=%d, last=%c", num, last);
 	}
 	if (strcmp(inst->reset, "hourly") == 0 || last == 'h') {
 		/*
 		 *  Round down to the prev nearest hour.
 		 */
 		tm->tm_hour -= num - 1;
-		inst->last_reset = mktime(tm);
+		inst->last_reset = fr_time_from_sec(mktime(tm));
 	} else if (strcmp(inst->reset, "daily") == 0 || last == 'd') {
 		/*
 		 *  Round down to the prev nearest day.
 		 */
 		tm->tm_hour = 0;
 		tm->tm_mday -= num - 1;
-		inst->last_reset = mktime(tm);
+		inst->last_reset = fr_time_from_sec(mktime(tm));
 	} else if (strcmp(inst->reset, "weekly") == 0 || last == 'w') {
 		/*
 		 *  Round down to the prev nearest week.
 		 */
 		tm->tm_hour = 0;
 		tm->tm_mday -= tm->tm_wday +(7*(num-1));
-		inst->last_reset = mktime(tm);
+		inst->last_reset = fr_time_from_sec(mktime(tm));
 	} else if (strcmp(inst->reset, "monthly") == 0 || last == 'm') {
 		tm->tm_hour = 0;
 		tm->tm_mday = 1;
 		tm->tm_mon -= num - 1;
-		inst->last_reset = mktime(tm);
+		inst->last_reset = fr_time_from_sec(mktime(tm));
 	} else if (strcmp(inst->reset, "never") == 0) {
-		inst->reset_time = 0;
+		inst->reset_time = fr_time_wrap(0);
 	} else {
 		return -1;
 	}
-	len = strftime(sPrevTime, sizeof(sPrevTime), "%Y-%m-%d %H:%M:%S", tm);
-	if (len == 0) *sPrevTime = '\0';
-	DEBUG2("Current Time: %" PRId64 " [%s], Prev reset %" PRId64 " [%s]",
-	       (int64_t) timeval, sCurrentTime, (int64_t) inst->last_reset, sPrevTime);
+
+	DEBUG2("Current Time: %pV, Prev reset %pV", fr_box_time(now), fr_box_time(inst->last_reset));
 
 	return ret;
 }
@@ -307,13 +295,13 @@ static ssize_t sqlcounter_expand(char *out, int outlen, rlm_sqlcounter_t const *
 
 		switch (*p) {
 			case 'b': /* last_reset */
-				snprintf(tmpdt, sizeof(tmpdt), "%" PRId64, (int64_t) inst->last_reset);
+				snprintf(tmpdt, sizeof(tmpdt), "%" PRId64, fr_time_to_sec(inst->last_reset));
 				strlcpy(q, tmpdt, freespace);
 				q += strlen(q);
 				p++;
 				break;
 			case 'e': /* reset_time */
-				snprintf(tmpdt, sizeof(tmpdt), "%" PRId64, (int64_t) inst->reset_time);
+				snprintf(tmpdt, sizeof(tmpdt), "%" PRId64, fr_time_to_sec(inst->reset_time));
 				strlcpy(q, tmpdt, freespace);
 				q += strlen(q);
 				p++;
@@ -403,12 +391,13 @@ static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, mod
 	 *	Before doing anything else, see if we have to reset
 	 *	the counters.
 	 */
-	if (inst->reset_time && (inst->reset_time <= fr_time_to_sec(request->packet->timestamp))) {
+	if (fr_time_eq(inst->reset_time, fr_time_wrap(0)) &&
+	    (fr_time_lteq(inst->reset_time, request->packet->timestamp))) {
 		/*
 		 *	Re-set the next time and prev_time for this counters range
 		 */
 		inst->last_reset = inst->reset_time;
-		find_next_reset(inst, fr_time_to_sec(request->packet->timestamp));
+		find_next_reset(inst, request->packet->timestamp);
 	}
 
 	if (tmpl_find_vp(&limit, request, inst->limit_attr) < 0) {
@@ -446,7 +435,7 @@ static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, mod
 	/*
 	 *	Check if check item > counter
 	 */
-	if (limit->vp_uint64 <= counter) {
+	if (limit->vp_uint64 <= (uint64_t)fr_time_delta_from_sec(counter)) {
 		fr_pair_t *vp;
 
 		/* User is denied access, send back a reply message */
@@ -479,13 +468,14 @@ static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, mod
 		 *	again.  Do this only for Session-Timeout.
 		 */
 		if ((tmpl_da(inst->reply_attr) == attr_session_timeout) &&
-		    inst->reset_time &&
-		    (res >= (uint64_t)(inst->reset_time - fr_time_to_sec(request->packet->timestamp)))) {
-			uint64_t to_reset = inst->reset_time - fr_time_to_sec(request->packet->timestamp);
+		    fr_time_gt(inst->reset_time, fr_time_wrap(0)) &&
+		    ((int64_t)res >= fr_time_delta_to_sec(fr_time_sub(inst->reset_time, request->packet->timestamp)))) {
+			fr_time_delta_t to_reset = fr_time_sub(inst->reset_time, request->packet->timestamp);
 
-			RDEBUG2("Time remaining (%" PRIu64 "s) is greater than time to reset (%" PRIu64 "s).  "
-				"Adding %" PRIu64 "s to reply value", to_reset, res, to_reset);
-			res = to_reset + limit->vp_uint64;
+			RDEBUG2("Time remaining (%pV) is greater than time to reset (%" PRIu64 "s).  "
+				"Adding %pV to reply value",
+				fr_box_time_delta(to_reset), res, fr_box_time_delta(to_reset));
+			res = fr_time_delta_to_sec(to_reset) + limit->vp_uint64;
 
 			/*
 			 *	Limit the reply attribute to the minimum of the existing value, or this new one.
@@ -565,14 +555,12 @@ static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, mod
 static int mod_instantiate(void *instance, CONF_SECTION *conf)
 {
 	rlm_sqlcounter_t	*inst = instance;
-	time_t			now;
 
 	fr_assert(inst->query && *inst->query);
 
-	now = time(NULL);
-	inst->reset_time = 0;
+	inst->reset_time = fr_time_wrap(0);
 
-	if (find_next_reset(inst, now) == -1) {
+	if (find_next_reset(inst, fr_time()) == -1) {
 		cf_log_err(conf, "Invalid reset '%s'", inst->reset);
 		return -1;
 	}
@@ -580,9 +568,9 @@ static int mod_instantiate(void *instance, CONF_SECTION *conf)
 	/*
 	 *  Discover the beginning of the current time period.
 	 */
-	inst->last_reset = 0;
+	inst->last_reset = fr_time_wrap(0);
 
-	if (find_prev_reset(inst, now) < 0) {
+	if (find_prev_reset(inst, fr_time()) < 0) {
 		cf_log_err(conf, "Invalid reset '%s'", inst->reset);
 		return -1;
 	}
diff --git a/src/protocols/dhcpv6/decode.c b/src/protocols/dhcpv6/decode.c
index cee8772081..ac9b311ddb 100644
--- a/src/protocols/dhcpv6/decode.c
+++ b/src/protocols/dhcpv6/decode.c
@@ -229,7 +229,7 @@ static ssize_t decode_value(TALLOC_CTX *ctx, fr_dcursor_t *cursor, fr_dict_t con
 			talloc_free(vp);
 			goto raw;
 		}
-		vp->vp_date += ((fr_time_t) DHCPV6_DATE_OFFSET) * NSEC;
+		vp->vp_date += fr_time_delta_from_sec(DHCPV6_DATE_OFFSET);
 		break;
 
 	case FR_TYPE_STRUCT: