Tor  0.4.3.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-2019, 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 
13 #include "lib/cc/compat_compiler.h"
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  */
27 static int64_t
28 tv_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 implemeting 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  */
52 long
53 tv_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  */
101 long
102 tv_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  */
159 int64_t
160 tv_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  */
180 time_t
181 time_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 
Definitions for timing-related constants.
#define LD_GENERAL
Definition: log.h:62
long tv_mdiff(const struct timeval *start, const struct timeval *end)
Definition: tvdiff.c:102
int64_t tv_to_msec(const struct timeval *tv)
Definition: tvdiff.c:160
Header for tvdiff.c.
time_t time_diff(const time_t t1, const time_t t2)
Definition: tvdiff.c:181
Utility macros to handle different features and behavior in different compilers.
#define TOR_USEC_PER_SEC
Definition: time.h:17
long tv_udiff(const struct timeval *start, const struct timeval *end)
Definition: tvdiff.c:53
static int64_t tv_secdiff_impl(const struct timeval *start, const struct timeval *end)
Definition: tvdiff.c:28
Headers for log.c.