Tor 0.4.9.0-alpha-dev
tvdiff.c
Go to the documentation of this file.
1/* Copyright (c) 2003-2004, Roger Dingledine
2 * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
3 * Copyright (c) 2007-2021, The Tor Project, Inc. */
4/* See LICENSE for licensing information */
5
6/**
7 * \file tvdiff.c
8 * \brief Compute the difference between timevals, in various units.
9 **/
10
11#include "lib/time/tvdiff.h"
12
14#include "lib/defs/time.h"
15#include "lib/log/log.h"
16
17#ifdef _WIN32
18#include <winsock2.h>
19#endif
20#ifdef HAVE_SYS_TIME_H
21#include <sys/time.h>
22#endif
23
24/** Return the difference between start->tv_sec and end->tv_sec.
25 * Returns INT64_MAX on overflow and underflow.
26 */
27static int64_t
28tv_secdiff_impl(const struct timeval *start, const struct timeval *end)
29{
30 const int64_t s = (int64_t)start->tv_sec;
31 const int64_t e = (int64_t)end->tv_sec;
32
33 /* This may not be the most efficient way of implementing this check,
34 * but it's easy to see that it's correct and doesn't overflow */
35
36 if (s > 0 && e < INT64_MIN + s) {
37 /* s is positive: equivalent to e - s < INT64_MIN, but without any
38 * overflow */
39 return INT64_MAX;
40 } else if (s < 0 && e > INT64_MAX + s) {
41 /* s is negative: equivalent to e - s > INT64_MAX, but without any
42 * overflow */
43 return INT64_MAX;
44 }
45
46 return e - s;
47}
48
49/** Return the number of microseconds elapsed between *start and *end.
50 * Returns LONG_MAX on overflow and underflow.
51 */
52long
53tv_udiff(const struct timeval *start, const struct timeval *end)
54{
55 /* Sanity check tv_usec */
56 if (start->tv_usec > TOR_USEC_PER_SEC || start->tv_usec < 0) {
57 log_warn(LD_GENERAL, "comparing times on microsecond detail with bad "
58 "start tv_usec: %"PRId64 " microseconds",
59 (int64_t)start->tv_usec);
60 return LONG_MAX;
61 }
62
63 if (end->tv_usec > TOR_USEC_PER_SEC || end->tv_usec < 0) {
64 log_warn(LD_GENERAL, "comparing times on microsecond detail with bad "
65 "end tv_usec: %"PRId64 " microseconds",
66 (int64_t)end->tv_usec);
67 return LONG_MAX;
68 }
69
70 /* Some BSDs have struct timeval.tv_sec 64-bit, but time_t (and long) 32-bit
71 */
72 int64_t udiff;
73 const int64_t secdiff = tv_secdiff_impl(start, end);
74
75 /* end->tv_usec - start->tv_usec can be up to 1 second either way */
76 if (secdiff > (int64_t)(LONG_MAX/1000000 - 1) ||
77 secdiff < (int64_t)(LONG_MIN/1000000 + 1)) {
78 log_warn(LD_GENERAL, "comparing times on microsecond detail too far "
79 "apart: %"PRId64 " seconds", (secdiff));
80 return LONG_MAX;
81 }
82
83 /* we'll never get an overflow here, because we check that both usecs are
84 * between 0 and TV_USEC_PER_SEC. */
85 udiff = secdiff*1000000 + ((int64_t)end->tv_usec - (int64_t)start->tv_usec);
86
87 /* Some compilers are smart enough to work out this is a no-op on L64 */
88#if SIZEOF_LONG < 8
89 if (udiff > (int64_t)LONG_MAX || udiff < (int64_t)LONG_MIN) {
90 return LONG_MAX;
91 }
92#endif
93
94 return (long)udiff;
95}
96
97/** Return the number of milliseconds elapsed between *start and *end.
98 * If the tv_usec difference is 500, rounds away from zero.
99 * Returns LONG_MAX on overflow and underflow.
100 */
101long
102tv_mdiff(const struct timeval *start, const struct timeval *end)
103{
104 /* Sanity check tv_usec */
105 if (start->tv_usec > TOR_USEC_PER_SEC || start->tv_usec < 0) {
106 log_warn(LD_GENERAL, "comparing times on millisecond detail with bad "
107 "start tv_usec: %"PRId64 " microseconds",
108 (int64_t)start->tv_usec);
109 return LONG_MAX;
110 }
111
112 if (end->tv_usec > TOR_USEC_PER_SEC || end->tv_usec < 0) {
113 log_warn(LD_GENERAL, "comparing times on millisecond detail with bad "
114 "end tv_usec: %"PRId64 " microseconds",
115 (int64_t)end->tv_usec);
116 return LONG_MAX;
117 }
118
119 /* Some BSDs have struct timeval.tv_sec 64-bit, but time_t (and long) 32-bit
120 */
121 int64_t mdiff;
122 const int64_t secdiff = tv_secdiff_impl(start, end);
123
124 /* end->tv_usec - start->tv_usec can be up to 1 second either way, but the
125 * mdiff calculation may add another temporary second for rounding.
126 * Whether this actually causes overflow depends on the compiler's constant
127 * folding and order of operations. */
128 if (secdiff > (int64_t)(LONG_MAX/1000 - 2) ||
129 secdiff < (int64_t)(LONG_MIN/1000 + 1)) {
130 log_warn(LD_GENERAL, "comparing times on millisecond detail too far "
131 "apart: %"PRId64 " seconds", (int64_t)secdiff);
132 return LONG_MAX;
133 }
134
135 /* Subtract and round */
136 mdiff = secdiff*1000 +
137 /* We add a million usec here to ensure that the result is positive,
138 * so that the round-towards-zero behavior of the division will give
139 * the right result for rounding to the nearest msec. Later we subtract
140 * 1000 in order to get the correct result.
141 * We'll never get an overflow here, because we check that both usecs are
142 * between 0 and TV_USEC_PER_SEC. */
143 ((int64_t)end->tv_usec - (int64_t)start->tv_usec + 500 + 1000000) / 1000
144 - 1000;
145
146 /* Some compilers are smart enough to work out this is a no-op on L64 */
147#if SIZEOF_LONG < 8
148 if (mdiff > (int64_t)LONG_MAX || mdiff < (int64_t)LONG_MIN) {
149 return LONG_MAX;
150 }
151#endif
152
153 return (long)mdiff;
154}
155
156/**
157 * Converts timeval to milliseconds.
158 */
159int64_t
160tv_to_msec(const struct timeval *tv)
161{
162 int64_t conv = ((int64_t)tv->tv_sec)*1000L;
163 /* Round ghetto-style */
164 conv += ((int64_t)tv->tv_usec+500)/1000L;
165 return conv;
166}
167
168/**
169 * Return duration in seconds between time_t values
170 * <b>t1</b> and <b>t2</b> iff <b>t1</b> is numerically
171 * less or equal than <b>t2</b>. Otherwise, return TIME_MAX.
172 *
173 * This provides a safe way to compute difference between
174 * two UNIX timestamps (<b>t2</b> can be assumed by calling
175 * code to be later than <b>t1</b>) or two durations measured
176 * in seconds (<b>t2</b> can be assumed to be longer than
177 * <b>t1</b>). Calling code is expected to check for TIME_MAX
178 * return value and interpret that as error condition.
179 */
180time_t
181time_diff(const time_t t1, const time_t t2)
182{
183 if (t1 <= t2)
184 return t2 - t1;
185
186 return TIME_MAX;
187}
188
Utility macros to handle different features and behavior in different compilers.
#define LD_GENERAL
Definition: log.h:62
Definitions for timing-related constants.
#define TOR_USEC_PER_SEC
Definition: time.h:17
static int64_t tv_secdiff_impl(const struct timeval *start, const struct timeval *end)
Definition: tvdiff.c:28
time_t time_diff(const time_t t1, const time_t t2)
Definition: tvdiff.c:181
int64_t tv_to_msec(const struct timeval *tv)
Definition: tvdiff.c:160
long tv_udiff(const struct timeval *start, const struct timeval *end)
Definition: tvdiff.c:53
long tv_mdiff(const struct timeval *start, const struct timeval *end)
Definition: tvdiff.c:102