contrib/bind-9.5.2/lib/isc/unix/time.c

   1 /*
   2  * Copyright (C) 2004-2008  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1998-2001, 2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: time.c,v 1.54.128.2 2008/02/18 23:46:30 tbox Exp $ */
  19
  20 /*! \file */
  21
  22 #include <config.h>
  23
  24 #include <errno.h>
  25 #include <limits.h>
  26 #include <syslog.h>
  27 #include <time.h>
  28
  29 #include <sys/time.h>   /* Required for struct timeval on some platforms. */
  30
  31 #include <isc/log.h>
  32 #include <isc/print.h>
  33 #include <isc/strerror.h>
  34 #include <isc/string.h>
  35 #include <isc/time.h>
  36 #include <isc/util.h>
  37
  38 #define NS_PER_S        1000000000      /*%< Nanoseconds per second. */
  39 #define NS_PER_US       1000            /*%< Nanoseconds per microsecond. */
  40 #define US_PER_S        1000000         /*%< Microseconds per second. */
  41
  42 /*
  43  * All of the INSIST()s checks of nanoseconds < NS_PER_S are for
  44  * consistency checking of the type. In lieu of magic numbers, it
  45  * is the best we've got.  The check is only performed on functions which
  46  * need an initialized type.
  47  */
  48
  49 #ifndef ISC_FIX_TV_USEC
  50 #define ISC_FIX_TV_USEC 1
  51 #endif
  52
  53 /*%
  54  *** Intervals
  55  ***/
  56
  57 static isc_interval_t zero_interval = { 0, 0 };
  58 isc_interval_t *isc_interval_zero = &zero_interval;
  59
  60 #if ISC_FIX_TV_USEC
  61 static inline void
  62 fix_tv_usec(struct timeval *tv) {
  63         isc_boolean_t fixed = ISC_FALSE;
  64
  65         if (tv->tv_usec < 0) {
  66                 fixed = ISC_TRUE;
  67                 do {
  68                         tv->tv_sec -= 1;
  69                         tv->tv_usec += US_PER_S;
  70                 } while (tv->tv_usec < 0);
  71         } else if (tv->tv_usec >= US_PER_S) {
  72                 fixed = ISC_TRUE;
  73                 do {
  74                         tv->tv_sec += 1;
  75                         tv->tv_usec -= US_PER_S;
  76                 } while (tv->tv_usec >=US_PER_S);
  77         }
  78         /*
  79          * Call syslog directly as was are called from the logging functions.
  80          */
  81         if (fixed)
  82                 (void)syslog(LOG_ERR, "gettimeofday returned bad tv_usec: corrected");
  83 }
  84 #endif
  85
  86 void
  87 isc_interval_set(isc_interval_t *i,
  88                  unsigned int seconds, unsigned int nanoseconds)
  89 {
  90         REQUIRE(i != NULL);
  91         REQUIRE(nanoseconds < NS_PER_S);
  92
  93         i->seconds = seconds;
  94         i->nanoseconds = nanoseconds;
  95 }
  96
  97 isc_boolean_t
  98 isc_interval_iszero(const isc_interval_t *i) {
  99         REQUIRE(i != NULL);
 100         INSIST(i->nanoseconds < NS_PER_S);
 101
 102         if (i->seconds == 0 && i->nanoseconds == 0)
 103                 return (ISC_TRUE);
 104
 105         return (ISC_FALSE);
 106 }
 107
 108
 109 /***
 110  *** Absolute Times
 111  ***/
 112
 113 static isc_time_t epoch = { 0, 0 };
 114 isc_time_t *isc_time_epoch = &epoch;
 115
 116 void
 117 isc_time_set(isc_time_t *t, unsigned int seconds, unsigned int nanoseconds) {
 118         REQUIRE(t != NULL);
 119         REQUIRE(nanoseconds < NS_PER_S);
 120
 121         t->seconds = seconds;
 122         t->nanoseconds = nanoseconds;
 123 }
 124
 125 void
 126 isc_time_settoepoch(isc_time_t *t) {
 127         REQUIRE(t != NULL);
 128
 129         t->seconds = 0;
 130         t->nanoseconds = 0;
 131 }
 132
 133 isc_boolean_t
 134 isc_time_isepoch(const isc_time_t *t) {
 135         REQUIRE(t != NULL);
 136         INSIST(t->nanoseconds < NS_PER_S);
 137
 138         if (t->seconds == 0 && t->nanoseconds == 0)
 139                 return (ISC_TRUE);
 140
 141         return (ISC_FALSE);
 142 }
 143
 144
 145 isc_result_t
 146 isc_time_now(isc_time_t *t) {
 147         struct timeval tv;
 148         char strbuf[ISC_STRERRORSIZE];
 149
 150         REQUIRE(t != NULL);
 151
 152         if (gettimeofday(&tv, NULL) == -1) {
 153                 isc__strerror(errno, strbuf, sizeof(strbuf));
 154                 UNEXPECTED_ERROR(__FILE__, __LINE__, "%s", strbuf);
 155                 return (ISC_R_UNEXPECTED);
 156         }
 157
 158         /*
 159          * Does POSIX guarantee the signedness of tv_sec and tv_usec?  If not,
 160          * then this test will generate warnings for platforms on which it is
 161          * unsigned.  In any event, the chances of any of these problems
 162          * happening are pretty much zero, but since the libisc library ensures
 163          * certain things to be true ...
 164          */
 165 #if ISC_FIX_TV_USEC
 166         fix_tv_usec(&tv);
 167         if (tv.tv_sec < 0)
 168                 return (ISC_R_UNEXPECTED);
 169 #else
 170         if (tv.tv_sec < 0 || tv.tv_usec < 0 || tv.tv_usec >= US_PER_S)
 171                 return (ISC_R_UNEXPECTED);
 172 #endif
 173
 174         /*
 175          * Ensure the tv_sec value fits in t->seconds.
 176          */
 177         if (sizeof(tv.tv_sec) > sizeof(t->seconds) &&
 178             ((tv.tv_sec | (unsigned int)-1) ^ (unsigned int)-1) != 0U)
 179                 return (ISC_R_RANGE);
 180
 181         t->seconds = tv.tv_sec;
 182         t->nanoseconds = tv.tv_usec * NS_PER_US;
 183
 184         return (ISC_R_SUCCESS);
 185 }
 186
 187 isc_result_t
 188 isc_time_nowplusinterval(isc_time_t *t, const isc_interval_t *i) {
 189         struct timeval tv;
 190         char strbuf[ISC_STRERRORSIZE];
 191
 192         REQUIRE(t != NULL);
 193         REQUIRE(i != NULL);
 194         INSIST(i->nanoseconds < NS_PER_S);
 195
 196         if (gettimeofday(&tv, NULL) == -1) {
 197                 isc__strerror(errno, strbuf, sizeof(strbuf));
 198                 UNEXPECTED_ERROR(__FILE__, __LINE__, "%s", strbuf);
 199                 return (ISC_R_UNEXPECTED);
 200         }
 201
 202         /*
 203          * Does POSIX guarantee the signedness of tv_sec and tv_usec?  If not,
 204          * then this test will generate warnings for platforms on which it is
 205          * unsigned.  In any event, the chances of any of these problems
 206          * happening are pretty much zero, but since the libisc library ensures
 207          * certain things to be true ...
 208          */
 209 #if ISC_FIX_TV_USEC
 210         fix_tv_usec(&tv);
 211         if (tv.tv_sec < 0)
 212                 return (ISC_R_UNEXPECTED);
 213 #else
 214         if (tv.tv_sec < 0 || tv.tv_usec < 0 || tv.tv_usec >= US_PER_S)
 215                 return (ISC_R_UNEXPECTED);
 216 #endif
 217
 218         /*
 219          * Ensure the resulting seconds value fits in the size of an
 220          * unsigned int.  (It is written this way as a slight optimization;
 221          * note that even if both values == INT_MAX, then when added
 222          * and getting another 1 added below the result is UINT_MAX.)
 223          */
 224         if ((tv.tv_sec > INT_MAX || i->seconds > INT_MAX) &&
 225             ((long long)tv.tv_sec + i->seconds > UINT_MAX))
 226                 return (ISC_R_RANGE);
 227
 228         t->seconds = tv.tv_sec + i->seconds;
 229         t->nanoseconds = tv.tv_usec * NS_PER_US + i->nanoseconds;
 230         if (t->nanoseconds >= NS_PER_S) {
 231                 t->seconds++;
 232                 t->nanoseconds -= NS_PER_S;
 233         }
 234
 235         return (ISC_R_SUCCESS);
 236 }
 237
 238 int
 239 isc_time_compare(const isc_time_t *t1, const isc_time_t *t2) {
 240         REQUIRE(t1 != NULL && t2 != NULL);
 241         INSIST(t1->nanoseconds < NS_PER_S && t2->nanoseconds < NS_PER_S);
 242
 243         if (t1->seconds < t2->seconds)
 244                 return (-1);
 245         if (t1->seconds > t2->seconds)
 246                 return (1);
 247         if (t1->nanoseconds < t2->nanoseconds)
 248                 return (-1);
 249         if (t1->nanoseconds > t2->nanoseconds)
 250                 return (1);
 251         return (0);
 252 }
 253
 254 isc_result_t
 255 isc_time_add(const isc_time_t *t, const isc_interval_t *i, isc_time_t *result)
 256 {
 257         REQUIRE(t != NULL && i != NULL && result != NULL);
 258         INSIST(t->nanoseconds < NS_PER_S && i->nanoseconds < NS_PER_S);
 259
 260         /*
 261          * Ensure the resulting seconds value fits in the size of an
 262          * unsigned int.  (It is written this way as a slight optimization;
 263          * note that even if both values == INT_MAX, then when added
 264          * and getting another 1 added below the result is UINT_MAX.)
 265          */
 266         if ((t->seconds > INT_MAX || i->seconds > INT_MAX) &&
 267             ((long long)t->seconds + i->seconds > UINT_MAX))
 268                 return (ISC_R_RANGE);
 269
 270         result->seconds = t->seconds + i->seconds;
 271         result->nanoseconds = t->nanoseconds + i->nanoseconds;
 272         if (result->nanoseconds >= NS_PER_S) {
 273                 result->seconds++;
 274                 result->nanoseconds -= NS_PER_S;
 275         }
 276
 277         return (ISC_R_SUCCESS);
 278 }
 279
 280 isc_result_t
 281 isc_time_subtract(const isc_time_t *t, const isc_interval_t *i,
 282                   isc_time_t *result)
 283 {
 284         REQUIRE(t != NULL && i != NULL && result != NULL);
 285         INSIST(t->nanoseconds < NS_PER_S && i->nanoseconds < NS_PER_S);
 286
 287         if ((unsigned int)t->seconds < i->seconds ||
 288             ((unsigned int)t->seconds == i->seconds &&
 289              t->nanoseconds < i->nanoseconds))
 290             return (ISC_R_RANGE);
 291
 292         result->seconds = t->seconds - i->seconds;
 293         if (t->nanoseconds >= i->nanoseconds)
 294                 result->nanoseconds = t->nanoseconds - i->nanoseconds;
 295         else {
 296                 result->nanoseconds = NS_PER_S - i->nanoseconds +
 297                         t->nanoseconds;
 298                 result->seconds--;
 299         }
 300
 301         return (ISC_R_SUCCESS);
 302 }
 303
 304 isc_uint64_t
 305 isc_time_microdiff(const isc_time_t *t1, const isc_time_t *t2) {
 306         isc_uint64_t i1, i2, i3;
 307
 308         REQUIRE(t1 != NULL && t2 != NULL);
 309         INSIST(t1->nanoseconds < NS_PER_S && t2->nanoseconds < NS_PER_S);
 310
 311         i1 = (isc_uint64_t)t1->seconds * NS_PER_S + t1->nanoseconds;
 312         i2 = (isc_uint64_t)t2->seconds * NS_PER_S + t2->nanoseconds;
 313
 314         if (i1 <= i2)
 315                 return (0);
 316
 317         i3 = i1 - i2;
 318
 319         /*
 320          * Convert to microseconds.
 321          */
 322         i3 = (i1 - i2) / NS_PER_US;
 323
 324         return (i3);
 325 }
 326
 327 isc_uint32_t
 328 isc_time_seconds(const isc_time_t *t) {
 329         REQUIRE(t != NULL);
 330         INSIST(t->nanoseconds < NS_PER_S);
 331
 332         return ((isc_uint32_t)t->seconds);
 333 }
 334
 335 isc_result_t
 336 isc_time_secondsastimet(const isc_time_t *t, time_t *secondsp) {
 337         isc_uint64_t i;
 338         time_t seconds;
 339
 340         REQUIRE(t != NULL);
 341         INSIST(t->nanoseconds < NS_PER_S);
 342
 343         /*
 344          * Ensure that the number of seconds represented by t->seconds
 345          * can be represented by a time_t.  Since t->seconds is an unsigned
 346          * int and since time_t is mostly opaque, this is trickier than
 347          * it seems.  (This standardized opaqueness of time_t is *very*
 348          * frustrating; time_t is not even limited to being an integral
 349          * type.)
 350          *
 351          * The mission, then, is to avoid generating any kind of warning
 352          * about "signed versus unsigned" while trying to determine if the
 353          * the unsigned int t->seconds is out range for tv_sec, which is
 354          * pretty much only true if time_t is a signed integer of the same
 355          * size as the return value of isc_time_seconds.
 356          *
 357          * The use of the 64 bit integer ``i'' takes advantage of C's
 358          * conversion rules to either zero fill or sign extend the widened
 359          * type.
 360          *
 361          * Solaris 5.6 gives this warning about the left shift:
 362          *      warning: integer overflow detected: op "<<"
 363          * if the U(nsigned) qualifier is not on the 1.
 364          */
 365         seconds = (time_t)t->seconds;
 366
 367         INSIST(sizeof(unsigned int) == sizeof(isc_uint32_t));
 368         INSIST(sizeof(time_t) >= sizeof(isc_uint32_t));
 369
 370         if (sizeof(time_t) == sizeof(isc_uint32_t) &&          /* Same size. */
 371             (time_t)0.5 != 0.5 &&              /* Not a floating point type. */
 372             (i = (time_t)-1) != 4294967295u &&                 /* Is signed. */
 373             (seconds &
 374              (1U << (sizeof(time_t) * CHAR_BIT - 1))) != 0U) {   /* Negative. */
 375                 /*
 376                  * This UNUSED() is here to shut up the IRIX compiler:
 377                  *      variable "i" was set but never used
 378                  * when the value of i *was* used in the third test.
 379                  * (Let's hope the compiler got the actual test right.)
 380                  */
 381                 UNUSED(i);
 382                 return (ISC_R_RANGE);
 383         }
 384
 385         *secondsp = seconds;
 386
 387         return (ISC_R_SUCCESS);
 388 }
 389
 390 isc_uint32_t
 391 isc_time_nanoseconds(const isc_time_t *t) {
 392         REQUIRE(t != NULL);
 393
 394         ENSURE(t->nanoseconds < NS_PER_S);
 395
 396         return ((isc_uint32_t)t->nanoseconds);
 397 }
 398
 399 void
 400 isc_time_formattimestamp(const isc_time_t *t, char *buf, unsigned int len) {
 401         time_t now;
 402         unsigned int flen;
 403
 404         REQUIRE(len > 0);
 405
 406         now = (time_t) t->seconds;
 407         flen = strftime(buf, len, "%d-%b-%Y %X", localtime(&now));
 408         INSIST(flen < len);
 409         if (flen != 0)
 410                 snprintf(buf + flen, len - flen,
 411                          ".%03u", t->nanoseconds / 1000000);
 412         else
 413                 snprintf(buf, len, "99-Bad-9999 99:99:99.999");
 414 }
 415
 416 void
 417 isc_time_formathttptimestamp(const isc_time_t *t, char *buf, unsigned int len) {
 418         time_t now;
 419         unsigned int flen;
 420
 421         REQUIRE(len > 0);
 422
 423         now = (time_t)t->seconds;
 424         flen = strftime(buf, len, "%a, %d %b %Y %H:%M:%S GMT", gmtime(&now));
 425         INSIST(flen < len);
 426 }
 427
 428 void
 429 isc_time_formatISO8601(const isc_time_t *t, char *buf, unsigned int len) {
 430         time_t now;
 431         unsigned int flen;
 432
 433         REQUIRE(len > 0);
 434
 435         now = (time_t)t->seconds;
 436         flen = strftime(buf, len, "%Y-%m-%dT%H:%M:%SZ", gmtime(&now));
 437         INSIST(flen < len);
 438 }