Annotation of embedaddon/ntp/lib/isc/unix/time.c, revision 1.1.1.1
1.1 misho 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.56 2008/02/15 23:46:51 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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to time.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ntp / lib / isc / unix