/* * Copyright (C) 2004 Internet Systems Consortium, Inc. ("ISC") * Copyright (C) 1998-2001, 2003 Internet Software Consortium. * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. */ /* $Id: time.c,v 1.34.2.8 2004/03/09 06:12:12 marka Exp $ */ #include #include #include #include #include #include /* Required for struct timeval on some platforms. */ #include #include #include #include #include #include #define NS_PER_S 1000000000 /* Nanoseconds per second. */ #define NS_PER_US 1000 /* Nanoseconds per microsecond. */ #define US_PER_S 1000000 /* Microseconds per second. */ /* * All of the INSIST()s checks of nanoseconds < NS_PER_S are for * consistency checking of the type. In lieu of magic numbers, it * is the best we've got. The check is only performed on functions which * need an initialized type. */ #ifndef ISC_FIX_TV_USEC #define ISC_FIX_TV_USEC 1 #endif /*** *** Intervals ***/ static isc_interval_t zero_interval = { 0, 0 }; isc_interval_t *isc_interval_zero = &zero_interval; #if ISC_FIX_TV_USEC static inline void fix_tv_usec(struct timeval *tv) { isc_boolean_t fixed = ISC_FALSE; if (tv->tv_usec < 0) { fixed = ISC_TRUE; do { tv->tv_sec -= 1; tv->tv_usec += US_PER_S; } while (tv->tv_usec < 0); } else if (tv->tv_usec >= US_PER_S) { fixed = ISC_TRUE; do { tv->tv_sec += 1; tv->tv_usec -= US_PER_S; } while (tv->tv_usec >=US_PER_S); } /* * Call syslog directly as was are called from the logging functions. */ if (fixed) syslog(LOG_ERR, "gettimeofday returned bad tv_usec: corrected"); } #endif void isc_interval_set(isc_interval_t *i, unsigned int seconds, unsigned int nanoseconds) { REQUIRE(i != NULL); REQUIRE(nanoseconds < NS_PER_S); i->seconds = seconds; i->nanoseconds = nanoseconds; } isc_boolean_t isc_interval_iszero(isc_interval_t *i) { REQUIRE(i != NULL); INSIST(i->nanoseconds < NS_PER_S); if (i->seconds == 0 && i->nanoseconds == 0) return (ISC_TRUE); return (ISC_FALSE); } /*** *** Absolute Times ***/ static isc_time_t epoch = { 0, 0 }; isc_time_t *isc_time_epoch = &epoch; void isc_time_set(isc_time_t *t, unsigned int seconds, unsigned int nanoseconds) { REQUIRE(t != NULL); REQUIRE(nanoseconds < NS_PER_S); t->seconds = seconds; t->nanoseconds = nanoseconds; } void isc_time_settoepoch(isc_time_t *t) { REQUIRE(t != NULL); t->seconds = 0; t->nanoseconds = 0; } isc_boolean_t isc_time_isepoch(isc_time_t *t) { REQUIRE(t != NULL); INSIST(t->nanoseconds < NS_PER_S); if (t->seconds == 0 && t->nanoseconds == 0) return (ISC_TRUE); return (ISC_FALSE); } isc_result_t isc_time_now(isc_time_t *t) { struct timeval tv; char strbuf[ISC_STRERRORSIZE]; REQUIRE(t != NULL); if (gettimeofday(&tv, NULL) == -1) { isc__strerror(errno, strbuf, sizeof(strbuf)); UNEXPECTED_ERROR(__FILE__, __LINE__, "%s", strbuf); return (ISC_R_UNEXPECTED); } /* * Does POSIX guarantee the signedness of tv_sec and tv_usec? If not, * then this test will generate warnings for platforms on which it is * unsigned. In any event, the chances of any of these problems * happening are pretty much zero, but since the libisc library ensures * certain things to be true ... */ #if ISC_FIX_TV_USEC fix_tv_usec(&tv); if (tv.tv_sec < 0) return (ISC_R_UNEXPECTED); #else if (tv.tv_sec < 0 || tv.tv_usec < 0 || tv.tv_usec >= US_PER_S) return (ISC_R_UNEXPECTED); #endif /* * Ensure the tv_sec value fits in t->seconds. */ if (sizeof(tv.tv_sec) > sizeof(t->seconds) && ((tv.tv_sec | (unsigned int)-1) ^ (unsigned int)-1) != 0U) return (ISC_R_RANGE); t->seconds = tv.tv_sec; t->nanoseconds = tv.tv_usec * NS_PER_US; return (ISC_R_SUCCESS); } isc_result_t isc_time_nowplusinterval(isc_time_t *t, isc_interval_t *i) { struct timeval tv; char strbuf[ISC_STRERRORSIZE]; REQUIRE(t != NULL); REQUIRE(i != NULL); INSIST(i->nanoseconds < NS_PER_S); if (gettimeofday(&tv, NULL) == -1) { isc__strerror(errno, strbuf, sizeof(strbuf)); UNEXPECTED_ERROR(__FILE__, __LINE__, "%s", strbuf); return (ISC_R_UNEXPECTED); } /* * Does POSIX guarantee the signedness of tv_sec and tv_usec? If not, * then this test will generate warnings for platforms on which it is * unsigned. In any event, the chances of any of these problems * happening are pretty much zero, but since the libisc library ensures * certain things to be true ... */ #if ISC_FIX_TV_USEC fix_tv_usec(&tv); if (tv.tv_sec < 0) return (ISC_R_UNEXPECTED); #else if (tv.tv_sec < 0 || tv.tv_usec < 0 || tv.tv_usec >= US_PER_S) return (ISC_R_UNEXPECTED); #endif /* * Ensure the resulting seconds value fits in the size of an * unsigned int. (It is written this way as a slight optimization; * note that even if both values == INT_MAX, then when added * and getting another 1 added below the result is UINT_MAX.) */ if ((tv.tv_sec > INT_MAX || i->seconds > INT_MAX) && ((long long)tv.tv_sec + i->seconds > UINT_MAX)) return (ISC_R_RANGE); t->seconds = tv.tv_sec + i->seconds; t->nanoseconds = tv.tv_usec * NS_PER_US + i->nanoseconds; if (t->nanoseconds > NS_PER_S) { t->seconds++; t->nanoseconds -= NS_PER_S; } return (ISC_R_SUCCESS); } int isc_time_compare(isc_time_t *t1, isc_time_t *t2) { REQUIRE(t1 != NULL && t2 != NULL); INSIST(t1->nanoseconds < NS_PER_S && t2->nanoseconds < NS_PER_S); if (t1->seconds < t2->seconds) return (-1); if (t1->seconds > t2->seconds) return (1); if (t1->nanoseconds < t2->nanoseconds) return (-1); if (t1->nanoseconds > t2->nanoseconds) return (1); return (0); } isc_result_t isc_time_add(isc_time_t *t, isc_interval_t *i, isc_time_t *result) { REQUIRE(t != NULL && i != NULL && result != NULL); INSIST(t->nanoseconds < NS_PER_S && i->nanoseconds < NS_PER_S); /* * Ensure the resulting seconds value fits in the size of an * unsigned int. (It is written this way as a slight optimization; * note that even if both values == INT_MAX, then when added * and getting another 1 added below the result is UINT_MAX.) */ if ((t->seconds > INT_MAX || i->seconds > INT_MAX) && ((long long)t->seconds + i->seconds > UINT_MAX)) return (ISC_R_RANGE); result->seconds = t->seconds + i->seconds; result->nanoseconds = t->nanoseconds + i->nanoseconds; if (result->nanoseconds >= NS_PER_S) { result->seconds++; result->nanoseconds -= NS_PER_S; } return (ISC_R_SUCCESS); } isc_result_t isc_time_subtract(isc_time_t *t, isc_interval_t *i, isc_time_t *result) { REQUIRE(t != NULL && i != NULL && result != NULL); INSIST(t->nanoseconds < NS_PER_S && i->nanoseconds < NS_PER_S); if ((unsigned int)t->seconds < i->seconds || ((unsigned int)t->seconds == i->seconds && t->nanoseconds < i->nanoseconds)) return (ISC_R_RANGE); result->seconds = t->seconds - i->seconds; if (t->nanoseconds >= i->nanoseconds) result->nanoseconds = t->nanoseconds - i->nanoseconds; else { result->nanoseconds = NS_PER_S - i->nanoseconds + t->nanoseconds; result->seconds--; } return (ISC_R_SUCCESS); } isc_uint64_t isc_time_microdiff(isc_time_t *t1, isc_time_t *t2) { isc_uint64_t i1, i2, i3; REQUIRE(t1 != NULL && t2 != NULL); INSIST(t1->nanoseconds < NS_PER_S && t2->nanoseconds < NS_PER_S); i1 = (isc_uint64_t)t1->seconds * NS_PER_S + t1->nanoseconds; i2 = (isc_uint64_t)t2->seconds * NS_PER_S + t2->nanoseconds; if (i1 <= i2) return (0); i3 = i1 - i2; /* * Convert to microseconds. */ i3 = (i1 - i2) / NS_PER_US; return (i3); } isc_uint32_t isc_time_seconds(isc_time_t *t) { REQUIRE(t != NULL); INSIST(t->nanoseconds < NS_PER_S); return ((isc_uint32_t)t->seconds); } isc_result_t isc_time_secondsastimet(isc_time_t *t, time_t *secondsp) { isc_uint64_t i; time_t seconds; REQUIRE(t != NULL); INSIST(t->nanoseconds < NS_PER_S); /* * Ensure that the number of seconds represented by t->seconds * can be represented by a time_t. Since t->seconds is an unsigned * int and since time_t is mostly opaque, this is trickier than * it seems. (This standardized opaqueness of time_t is *very* * frustrating; time_t is not even limited to being an integral * type.) * * The mission, then, is to avoid generating any kind of warning * about "signed versus unsigned" while trying to determine if the * the unsigned int t->seconds is out range for tv_sec, which is * pretty much only true if time_t is a signed integer of the same * size as the return value of isc_time_seconds. * * The use of the 64 bit integer ``i'' takes advantage of C's * conversion rules to either zero fill or sign extend the widened * type. * * Solaris 5.6 gives this warning about the left shift: * warning: integer overflow detected: op "<<" * if the U(nsigned) qualifier is not on the 1. */ seconds = (time_t)t->seconds; INSIST(sizeof(unsigned int) == sizeof(isc_uint32_t)); INSIST(sizeof(time_t) >= sizeof(isc_uint32_t)); if (sizeof(time_t) == sizeof(isc_uint32_t) && /* Same size. */ (time_t)0.5 != 0.5 && /* Not a floating point type. */ (i = (time_t)-1) != 4294967295u && /* Is signed. */ (seconds & (1U << (sizeof(time_t) * CHAR_BIT - 1))) != 0U) { /* Negative. */ /* * This UNUSED() is here to shut up the IRIX compiler: * variable "i" was set but never used * when the value of i *was* used in the third test. * (Let's hope the compiler got the actual test right.) */ UNUSED(i); return (ISC_R_RANGE); } *secondsp = seconds; return (ISC_R_SUCCESS); } isc_uint32_t isc_time_nanoseconds(isc_time_t *t) { REQUIRE(t != NULL); ENSURE(t->nanoseconds < NS_PER_S); return ((isc_uint32_t)t->nanoseconds); } void isc_time_formattimestamp(const isc_time_t *t, char *buf, unsigned int len) { time_t now; unsigned int flen; REQUIRE(len > 0); now = (time_t) t->seconds; flen = strftime(buf, len, "%b %d %X", localtime(&now)); INSIST(flen < len); if (flen != 0) snprintf(buf + flen, len - flen, ".%03u", t->nanoseconds / 1000000); else snprintf(buf, len, "Bad 00 99:99:99.999"); }