src/lib/time/tvdiff.c

   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
  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 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  */
  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