Annotation of src/lib/libc/time/zdump.c, Revision 1.52
1.52 ! pgoyette 1: /* $NetBSD$ */
1.50 christos 2: /* Dump time zone data in a textual format. */
3:
1.17 mlelstv 4: /*
5: ** This file is in the public domain, so clarified as of
6: ** 2009-05-17 by Arthur David Olson.
7: */
1.2 jtc 8:
1.6 christos 9: #include <sys/cdefs.h>
1.1 jtc 10: #ifndef lint
1.52 ! pgoyette 11: __RCSID("$NetBSD: zdump.c,v 1.51 2019/01/01 03:04:56 christos Exp $");
1.1 jtc 12: #endif /* !defined lint */
13:
1.36 christos 14: #ifndef NETBSD_INSPIRED
15: # define NETBSD_INSPIRED 1
16: #endif
17:
1.46 christos 18: #include <err.h>
1.29 christos 19: #include "private.h"
1.47 christos 20: #include <stdio.h>
21:
22: #ifndef HAVE_SNPRINTF
23: # define HAVE_SNPRINTF (199901 <= __STDC_VERSION__)
24: #endif
1.36 christos 25:
26: #ifndef HAVE_LOCALTIME_R
27: # define HAVE_LOCALTIME_R 1
28: #endif
29:
30: #ifndef HAVE_LOCALTIME_RZ
31: # ifdef TM_ZONE
32: # define HAVE_LOCALTIME_RZ (NETBSD_INSPIRED && USE_LTZ)
33: # else
34: # define HAVE_LOCALTIME_RZ 0
35: # endif
36: #endif
37:
38: #ifndef HAVE_TZSET
39: # define HAVE_TZSET 1
40: #endif
1.27 christos 41:
1.17 mlelstv 42: #ifndef ZDUMP_LO_YEAR
43: #define ZDUMP_LO_YEAR (-500)
44: #endif /* !defined ZDUMP_LO_YEAR */
45:
46: #ifndef ZDUMP_HI_YEAR
47: #define ZDUMP_HI_YEAR 2500
48: #endif /* !defined ZDUMP_HI_YEAR */
1.1 jtc 49:
50: #ifndef MAX_STRING_LENGTH
51: #define MAX_STRING_LENGTH 1024
52: #endif /* !defined MAX_STRING_LENGTH */
53:
1.17 mlelstv 54: #define SECSPERNYEAR (SECSPERDAY * DAYSPERNYEAR)
55: #define SECSPERLYEAR (SECSPERNYEAR + SECSPERDAY)
1.31 christos 56: #define SECSPER400YEARS (SECSPERNYEAR * (intmax_t) (300 + 3) \
57: + SECSPERLYEAR * (intmax_t) (100 - 3))
58:
59: /*
60: ** True if SECSPER400YEARS is known to be representable as an
61: ** intmax_t. It's OK that SECSPER400YEARS_FITS can in theory be false
62: ** even if SECSPER400YEARS is representable, because when that happens
63: ** the code merely runs a bit more slowly, and this slowness doesn't
64: ** occur on any practical platform.
65: */
66: enum { SECSPER400YEARS_FITS = SECSPERLYEAR <= INTMAX_MAX / 400 };
1.17 mlelstv 67:
68: #if HAVE_GETTEXT
1.46 christos 69: #include <locale.h> /* for setlocale */
1.17 mlelstv 70: #endif /* HAVE_GETTEXT */
1.3 jtc 71:
1.36 christos 72: #if ! HAVE_LOCALTIME_RZ
73: # undef timezone_t
74: # define timezone_t char **
75: #endif
76:
1.43 christos 77: #if !HAVE_POSIX_DECLS
1.17 mlelstv 78: extern int getopt(int argc, char * const argv[],
79: const char * options);
1.1 jtc 80: extern char * optarg;
81: extern int optind;
1.43 christos 82: #endif
1.1 jtc 83:
1.29 christos 84: /* The minimum and maximum finite time values. */
1.41 christos 85: enum { atime_shift = CHAR_BIT * sizeof (time_t) - 2 };
1.29 christos 86: static time_t absolute_min_time =
1.31 christos 87: ((time_t) -1 < 0
1.41 christos 88: ? (- ((time_t) ~ (time_t) 0 < 0)
89: - (((time_t) 1 << atime_shift) - 1 + ((time_t) 1 << atime_shift)))
1.29 christos 90: : 0);
91: static time_t absolute_max_time =
1.31 christos 92: ((time_t) -1 < 0
1.41 christos 93: ? (((time_t) 1 << atime_shift) - 1 + ((time_t) 1 << atime_shift))
1.29 christos 94: : -1);
1.5 jtc 95: static size_t longest;
1.1 jtc 96: static char * progname;
1.36 christos 97: static bool warned;
98: static bool errout;
1.17 mlelstv 99:
1.36 christos 100: static char const *abbr(struct tm const *);
101: static intmax_t delta(struct tm *, struct tm *) ATTRIBUTE_PURE;
102: static void dumptime(struct tm const *);
103: static time_t hunt(timezone_t, char *, time_t, time_t);
104: static void show(timezone_t, char *, time_t, bool);
1.44 christos 105: static void showtrans(char const *, struct tm const *, time_t, char const *,
106: char const *);
1.36 christos 107: static const char *tformat(void);
108: static time_t yeartot(intmax_t) ATTRIBUTE_PURE;
1.17 mlelstv 109:
1.42 christos 110: /* Unlike <ctype.h>'s isdigit, this also works if c < 0 | c > UCHAR_MAX. */
111: #define is_digit(c) ((unsigned)(c) - '0' <= 9)
112:
1.34 christos 113: /* Is A an alphabetic character in the C locale? */
1.36 christos 114: static bool
1.34 christos 115: is_alpha(char a)
116: {
117: switch (a) {
118: default:
1.36 christos 119: return false;
1.34 christos 120: case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
121: case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
122: case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
123: case 'V': case 'W': case 'X': case 'Y': case 'Z':
124: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
125: case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
126: case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
127: case 'v': case 'w': case 'x': case 'y': case 'z':
1.36 christos 128: return true;
1.34 christos 129: }
130: }
131:
1.36 christos 132: /* Return A + B, exiting if the result would overflow. */
133: static size_t
134: sumsize(size_t a, size_t b)
135: {
136: size_t sum = a + b;
137: if (sum < a)
138: errx(EXIT_FAILURE, "size overflow");
139: return sum;
140: }
141:
1.44 christos 142: /* Return a pointer to a newly allocated buffer of size SIZE, exiting
143: on failure. SIZE should be nonzero. */
1.49 christos 144: static void * ATTRIBUTE_MALLOC
1.44 christos 145: xmalloc(size_t size)
146: {
147: void *p = malloc(size);
148: if (!p) {
149: perror(progname);
150: exit(EXIT_FAILURE);
151: }
152: return p;
153: }
154:
1.36 christos 155: #if ! HAVE_TZSET
156: # undef tzset
157: # define tzset zdump_tzset
158: static void tzset(void) { }
159: #endif
160:
161: /* Assume gmtime_r works if localtime_r does.
162: A replacement localtime_r is defined below if needed. */
163: #if ! HAVE_LOCALTIME_R
164:
165: # undef gmtime_r
166: # define gmtime_r zdump_gmtime_r
167:
168: static struct tm *
169: gmtime_r(time_t *tp, struct tm *tmp)
170: {
171: struct tm *r = gmtime(tp);
172: if (r) {
173: *tmp = *r;
174: r = tmp;
175: }
176: return r;
177: }
178:
179: #endif
180:
181: /* Platforms with TM_ZONE don't need tzname, so they can use the
182: faster localtime_rz or localtime_r if available. */
183:
184: #if defined TM_ZONE && HAVE_LOCALTIME_RZ
185: # define USE_LOCALTIME_RZ true
186: #else
187: # define USE_LOCALTIME_RZ false
188: #endif
189:
190: #if ! USE_LOCALTIME_RZ
191:
192: # if !defined TM_ZONE || ! HAVE_LOCALTIME_R || ! HAVE_TZSET
193: # undef localtime_r
194: # define localtime_r zdump_localtime_r
195: static struct tm *
196: localtime_r(time_t *tp, struct tm *tmp)
197: {
198: struct tm *r = localtime(tp);
199: if (r) {
200: *tmp = *r;
201: r = tmp;
202: }
203: return r;
204: }
205: # endif
206:
207: # undef localtime_rz
208: # define localtime_rz zdump_localtime_rz
209: static struct tm *
210: localtime_rz(timezone_t rz, time_t *tp, struct tm *tmp)
211: {
212: return localtime_r(tp, tmp);
213: }
214:
215: # ifdef TYPECHECK
216: # undef mktime_z
217: # define mktime_z zdump_mktime_z
218: static time_t
219: mktime_z(timezone_t tz, struct tm *tmp)
220: {
221: return mktime(tmp);
222: }
223: # endif
224:
225: # undef tzalloc
226: # undef tzfree
227: # define tzalloc zdump_tzalloc
228: # define tzfree zdump_tzfree
229:
230: static timezone_t
231: tzalloc(char const *val)
232: {
233: static char **fakeenv;
234: char **env = fakeenv;
235: char *env0;
236: if (! env) {
237: char **e = environ;
238: int to;
239:
240: while (*e++)
241: continue;
1.44 christos 242: env = xmalloc(sumsize(sizeof *environ,
1.36 christos 243: (e - environ) * sizeof *environ));
244: to = 1;
245: for (e = environ; (env[to] = *e); e++)
246: to += strncmp(*e, "TZ=", 3) != 0;
247: }
1.44 christos 248: env0 = xmalloc(sumsize(sizeof "TZ=", strlen(val)));
1.36 christos 249: env[0] = strcat(strcpy(env0, "TZ="), val);
250: environ = fakeenv = env;
251: tzset();
252: return env;
253: }
254:
255: static void
256: tzfree(timezone_t env)
257: {
258: environ = env + 1;
259: free(env[0]);
260: }
261: #endif /* ! USE_LOCALTIME_RZ */
262:
1.48 christos 263: /* A UT time zone, and its initializer. */
1.36 christos 264: static timezone_t gmtz;
265: static void
266: gmtzinit(void)
267: {
268: if (USE_LOCALTIME_RZ) {
269: static char const utc[] = "UTC0";
270: gmtz = tzalloc(utc);
271: if (!gmtz) {
272: err(EXIT_FAILURE, "Cannot create %s", utc);
273: }
274: }
275: }
276:
1.48 christos 277: /* Convert *TP to UT, storing the broken-down time into *TMP.
1.36 christos 278: Return TMP if successful, NULL otherwise. This is like gmtime_r(TP, TMP),
279: except typically faster if USE_LOCALTIME_RZ. */
280: static struct tm *
281: my_gmtime_r(time_t *tp, struct tm *tmp)
282: {
283: return USE_LOCALTIME_RZ ?
284: localtime_rz(gmtz, tp, tmp) : gmtime_r(tp, tmp);
285: }
286:
1.17 mlelstv 287: #ifndef TYPECHECK
1.36 christos 288: #define my_localtime_rz localtime_rz
1.17 mlelstv 289: #else /* !defined TYPECHECK */
290: static struct tm *
1.36 christos 291: my_localtime_rz(timezone_t tz, const time_t *tp, struct tm *tmp)
1.17 mlelstv 292: {
1.36 christos 293: tmp = localtime_rz(tz, tp, tmp);
294: if (tmp) {
1.17 mlelstv 295: struct tm tm;
1.26 christos 296: time_t t;
1.17 mlelstv 297:
298: tm = *tmp;
1.36 christos 299: t = mktime_z(tz, &tm);
1.31 christos 300: if (t != *tp) {
1.17 mlelstv 301: (void) fflush(stdout);
302: (void) fprintf(stderr, "\n%s: ", progname);
303: (void) fprintf(stderr, tformat(), *tp);
304: (void) fprintf(stderr, " ->");
305: (void) fprintf(stderr, " year=%d", tmp->tm_year);
306: (void) fprintf(stderr, " mon=%d", tmp->tm_mon);
307: (void) fprintf(stderr, " mday=%d", tmp->tm_mday);
308: (void) fprintf(stderr, " hour=%d", tmp->tm_hour);
309: (void) fprintf(stderr, " min=%d", tmp->tm_min);
310: (void) fprintf(stderr, " sec=%d", tmp->tm_sec);
311: (void) fprintf(stderr, " isdst=%d", tmp->tm_isdst);
312: (void) fprintf(stderr, " -> ");
313: (void) fprintf(stderr, tformat(), t);
314: (void) fprintf(stderr, "\n");
1.36 christos 315: errout = true;
1.17 mlelstv 316: }
317: }
318: return tmp;
319: }
320: #endif /* !defined TYPECHECK */
321:
322: static void
1.26 christos 323: abbrok(const char *const abbrp, const char *const zone)
1.17 mlelstv 324: {
1.26 christos 325: const char *cp;
326: const char *wp;
1.17 mlelstv 327:
328: if (warned)
329: return;
330: cp = abbrp;
1.42 christos 331: while (is_alpha(*cp) || is_digit(*cp) || *cp == '-' || *cp == '+')
1.17 mlelstv 332: ++cp;
1.42 christos 333: if (cp - abbrp < 3)
334: wp = _("has fewer than 3 characters");
1.17 mlelstv 335: else if (cp - abbrp > 6)
1.42 christos 336: wp = _("has more than 6 characters");
337: else if (*cp)
338: wp = _("has characters other than ASCII alphanumerics, '-' or '+'");
339: else
1.17 mlelstv 340: return;
341: (void) fflush(stdout);
342: (void) fprintf(stderr,
343: _("%s: warning: zone \"%s\" abbreviation \"%s\" %s\n"),
344: progname, zone, abbrp, wp);
1.36 christos 345: warned = errout = true;
346: }
347:
348: /* Return a time zone abbreviation. If the abbreviation needs to be
349: saved, use *BUF (of size *BUFALLOC) to save it, and return the
350: abbreviation in the possibly-reallocated *BUF. Otherwise, just
351: return the abbreviation. Get the abbreviation from TMP.
352: Exit on memory allocation failure. */
353: static char const *
354: saveabbr(char **buf, size_t *bufalloc, struct tm const *tmp)
355: {
356: char const *ab = abbr(tmp);
357: if (HAVE_LOCALTIME_RZ)
358: return ab;
359: else {
360: size_t ablen = strlen(ab);
361: if (*bufalloc <= ablen) {
362: free(*buf);
363:
364: /* Make the new buffer at least twice as long as the
365: old, to avoid O(N**2) behavior on repeated calls. */
366: *bufalloc = sumsize(*bufalloc, ablen + 1);
1.44 christos 367: *buf = xmalloc(*bufalloc);
1.36 christos 368: }
369: return strcpy(*buf, ab);
370: }
371: }
372:
373: static void
374: close_file(FILE *stream)
375: {
376: char const *e = (ferror(stream) ? _("I/O error")
377: : fclose(stream) != 0 ? strerror(errno) : NULL);
378: if (e) {
379: errx(EXIT_FAILURE, "%s", e);
380: }
1.17 mlelstv 381: }
382:
1.24 joerg 383: __dead static void
1.26 christos 384: usage(FILE *const stream, const int status)
1.17 mlelstv 385: {
386: (void) fprintf(stream,
1.50 christos 387: _("%s: usage: %s OPTIONS TIMEZONE ...\n"
1.44 christos 388: "Options include:\n"
389: " -c [L,]U Start at year L (default -500), end before year U (default 2500)\n"
390: " -t [L,]U Start at time L, end before time U (in seconds since 1970)\n"
391: " -i List transitions briefly (format is experimental)\n" \
392: " -v List transitions verbosely\n"
393: " -V List transitions a bit less verbosely\n"
394: " --help Output this help\n"
395: " --version Output version info\n"
1.29 christos 396: "\n"
397: "Report bugs to %s.\n"),
1.44 christos 398: progname, progname, REPORT_BUGS_TO);
1.36 christos 399: if (status == EXIT_SUCCESS)
400: close_file(stream);
1.17 mlelstv 401: exit(status);
402: }
1.1 jtc 403:
404: int
1.26 christos 405: main(int argc, char *argv[])
406: {
1.36 christos 407: /* These are static so that they're initially zero. */
408: static char * abbrev;
409: static size_t abbrevsize;
410:
1.26 christos 411: int i;
1.36 christos 412: bool vflag;
413: bool Vflag;
1.26 christos 414: char * cutarg;
1.29 christos 415: char * cuttimes;
1.26 christos 416: time_t cutlotime;
417: time_t cuthitime;
418: time_t now;
1.44 christos 419: bool iflag = false;
1.1 jtc 420:
1.29 christos 421: cutlotime = absolute_min_time;
422: cuthitime = absolute_max_time;
1.17 mlelstv 423: #if HAVE_GETTEXT
424: (void) setlocale(LC_ALL, "");
1.3 jtc 425: #ifdef TZ_DOMAINDIR
426: (void) bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR);
1.17 mlelstv 427: #endif /* defined TEXTDOMAINDIR */
1.3 jtc 428: (void) textdomain(TZ_DOMAIN);
1.17 mlelstv 429: #endif /* HAVE_GETTEXT */
1.1 jtc 430: progname = argv[0];
1.14 kleink 431: for (i = 1; i < argc; ++i)
432: if (strcmp(argv[i], "--version") == 0) {
1.28 christos 433: (void) printf("zdump %s%s\n", PKGVERSION, TZVERSION);
1.36 christos 434: return EXIT_SUCCESS;
1.17 mlelstv 435: } else if (strcmp(argv[i], "--help") == 0) {
1.22 christos 436: usage(stdout, EXIT_SUCCESS);
1.14 kleink 437: }
1.36 christos 438: vflag = Vflag = false;
1.29 christos 439: cutarg = cuttimes = NULL;
440: for (;;)
1.44 christos 441: switch (getopt(argc, argv, "c:it:vV")) {
1.29 christos 442: case 'c': cutarg = optarg; break;
443: case 't': cuttimes = optarg; break;
1.44 christos 444: case 'i': iflag = true; break;
1.36 christos 445: case 'v': vflag = true; break;
446: case 'V': Vflag = true; break;
1.29 christos 447: case -1:
448: if (! (optind == argc - 1 && strcmp(argv[optind], "=") == 0))
449: goto arg_processing_done;
450: /* Fall through. */
451: default:
452: usage(stderr, EXIT_FAILURE);
453: }
454: arg_processing_done:;
455:
1.44 christos 456: if (iflag | vflag | Vflag) {
1.29 christos 457: intmax_t lo;
458: intmax_t hi;
1.32 christos 459: char *loend, *hiend;
1.30 christos 460: intmax_t cutloyear = ZDUMP_LO_YEAR;
461: intmax_t cuthiyear = ZDUMP_HI_YEAR;
1.17 mlelstv 462: if (cutarg != NULL) {
1.32 christos 463: lo = strtoimax(cutarg, &loend, 10);
464: if (cutarg != loend && !*loend) {
465: hi = lo;
466: cuthiyear = hi;
467: } else if (cutarg != loend && *loend == ','
468: && (hi = strtoimax(loend + 1, &hiend, 10),
469: loend + 1 != hiend && !*hiend)) {
470: cutloyear = lo;
1.17 mlelstv 471: cuthiyear = hi;
472: } else {
1.36 christos 473: fprintf(stderr, _("%s: wild -c argument %s\n"),
1.17 mlelstv 474: progname, cutarg);
1.36 christos 475: return EXIT_FAILURE;
1.17 mlelstv 476: }
477: }
1.29 christos 478: if (cutarg != NULL || cuttimes == NULL) {
479: cutlotime = yeartot(cutloyear);
480: cuthitime = yeartot(cuthiyear);
481: }
482: if (cuttimes != NULL) {
1.32 christos 483: lo = strtoimax(cuttimes, &loend, 10);
484: if (cuttimes != loend && !*loend) {
485: hi = lo;
1.29 christos 486: if (hi < cuthitime) {
487: if (hi < absolute_min_time)
488: hi = absolute_min_time;
489: cuthitime = hi;
490: }
1.32 christos 491: } else if (cuttimes != loend && *loend == ','
492: && (hi = strtoimax(loend + 1, &hiend, 10),
493: loend + 1 != hiend && !*hiend)) {
1.29 christos 494: if (cutlotime < lo) {
495: if (absolute_max_time < lo)
496: lo = absolute_max_time;
497: cutlotime = lo;
498: }
499: if (hi < cuthitime) {
500: if (hi < absolute_min_time)
501: hi = absolute_min_time;
502: cuthitime = hi;
503: }
504: } else {
505: (void) fprintf(stderr,
506: _("%s: wild -t argument %s\n"),
507: progname, cuttimes);
1.36 christos 508: return EXIT_FAILURE;
1.29 christos 509: }
510: }
1.1 jtc 511: }
1.36 christos 512: gmtzinit();
1.44 christos 513: INITIALIZE (now);
514: if (! (iflag | vflag | Vflag))
515: now = time(NULL);
1.1 jtc 516: longest = 0;
1.36 christos 517: for (i = optind; i < argc; i++) {
518: size_t arglen = strlen(argv[i]);
519: if (longest < arglen)
520: longest = arglen < INT_MAX ? arglen : INT_MAX;
521: }
1.1 jtc 522:
523: for (i = optind; i < argc; ++i) {
1.36 christos 524: timezone_t tz = tzalloc(argv[i]);
525: char const *ab;
1.44 christos 526: time_t t;
527: struct tm tm, newtm;
528: bool tm_ok;
529:
1.36 christos 530: if (!tz) {
531: errx(EXIT_FAILURE, "%s", argv[i]);
532: }
1.44 christos 533: if (! (iflag | vflag | Vflag)) {
1.36 christos 534: show(tz, argv[i], now, false);
535: tzfree(tz);
1.1 jtc 536: continue;
1.3 jtc 537: }
1.36 christos 538: warned = false;
1.17 mlelstv 539: t = absolute_min_time;
1.44 christos 540: if (! (iflag | Vflag)) {
1.36 christos 541: show(tz, argv[i], t, true);
1.31 christos 542: t += SECSPERDAY;
1.36 christos 543: show(tz, argv[i], t, true);
1.29 christos 544: }
1.17 mlelstv 545: if (t < cutlotime)
546: t = cutlotime;
1.48 christos 547: INITIALIZE (ab);
1.44 christos 548: tm_ok = my_localtime_rz(tz, &t, &tm) != NULL;
549: if (tm_ok) {
1.36 christos 550: ab = saveabbr(&abbrev, &abbrevsize, &tm);
1.44 christos 551: if (iflag) {
552: showtrans("\nTZ=%f", &tm, t, ab, argv[i]);
553: showtrans("-\t-\t%Q", &tm, t, ab, argv[i]);
554: }
555: } else
1.36 christos 556: ab = NULL;
557: while (t < cuthitime) {
1.44 christos 558: time_t newt = ((t < absolute_max_time - SECSPERDAY / 2
559: && t + SECSPERDAY / 2 < cuthitime)
560: ? t + SECSPERDAY / 2 : cuthitime);
561: struct tm *newtmp = localtime_rz(tz, &newt, &newtm);
562: bool newtm_ok = newtmp != NULL;
1.48 christos 563: if (tm_ok != newtm_ok
564: || (tm_ok && (delta(&newtm, &tm) != newt - t
565: || newtm.tm_isdst != tm.tm_isdst
566: || strcmp(abbr(&newtm), ab) != 0))) {
1.36 christos 567: newt = hunt(tz, argv[i], t, newt);
568: newtmp = localtime_rz(tz, &newt, &newtm);
1.44 christos 569: newtm_ok = newtmp != NULL;
570: if (iflag)
571: showtrans("%Y-%m-%d\t%L\t%Q",
572: newtmp, newt, newtm_ok ?
573: abbr(&newtm) : NULL, argv[i]);
574: else {
575: show(tz, argv[i], newt - 1, true);
576: show(tz, argv[i], newt, true);
577: }
1.1 jtc 578: }
579: t = newt;
1.44 christos 580: tm_ok = newtm_ok;
581: if (newtm_ok) {
582: ab = saveabbr(&abbrev, &abbrevsize, &newtm);
583: tm = newtm;
584: }
1.1 jtc 585: }
1.44 christos 586: if (! (iflag | Vflag)) {
1.29 christos 587: t = absolute_max_time;
1.31 christos 588: t -= SECSPERDAY;
1.36 christos 589: show(tz, argv[i], t, true);
1.31 christos 590: t += SECSPERDAY;
1.36 christos 591: show(tz, argv[i], t, true);
1.29 christos 592: }
1.36 christos 593: tzfree(tz);
1.1 jtc 594: }
1.36 christos 595: close_file(stdout);
596: if (errout && (ferror(stderr) || fclose(stderr) != 0))
597: return EXIT_FAILURE;
598: return EXIT_SUCCESS;
1.17 mlelstv 599: }
1.1 jtc 600:
601: static time_t
1.42 christos 602: yeartot(intmax_t y)
1.17 mlelstv 603: {
1.31 christos 604: intmax_t myy, seconds, years;
1.29 christos 605: time_t t;
1.17 mlelstv 606:
607: myy = EPOCH_YEAR;
608: t = 0;
1.31 christos 609: while (myy < y) {
610: if (SECSPER400YEARS_FITS && 400 <= y - myy) {
611: intmax_t diff400 = (y - myy) / 400;
612: if (INTMAX_MAX / SECSPER400YEARS < diff400)
613: return absolute_max_time;
614: seconds = diff400 * SECSPER400YEARS;
615: years = diff400 * 400;
616: } else {
1.17 mlelstv 617: seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
1.31 christos 618: years = 1;
619: }
620: myy += years;
621: if (t > absolute_max_time - seconds)
622: return absolute_max_time;
623: t += seconds;
624: }
625: while (y < myy) {
626: if (SECSPER400YEARS_FITS && y + 400 <= myy && myy < 0) {
627: intmax_t diff400 = (myy - y) / 400;
628: if (INTMAX_MAX / SECSPER400YEARS < diff400)
629: return absolute_min_time;
630: seconds = diff400 * SECSPER400YEARS;
631: years = diff400 * 400;
1.17 mlelstv 632: } else {
1.31 christos 633: seconds = isleap(myy - 1) ? SECSPERLYEAR : SECSPERNYEAR;
634: years = 1;
1.17 mlelstv 635: }
1.31 christos 636: myy -= years;
637: if (t < absolute_min_time + seconds)
638: return absolute_min_time;
639: t -= seconds;
1.17 mlelstv 640: }
641: return t;
642: }
643:
644: static time_t
1.36 christos 645: hunt(timezone_t tz, char *name, time_t lot, time_t hit)
1.17 mlelstv 646: {
1.36 christos 647: static char * loab;
648: static size_t loabsize;
649: char const * ab;
1.17 mlelstv 650: time_t t;
651: struct tm lotm;
652: struct tm tm;
1.44 christos 653: bool lotm_ok = my_localtime_rz(tz, &lot, &lotm) != NULL;
654: bool tm_ok;
1.17 mlelstv 655:
1.44 christos 656: if (lotm_ok)
1.36 christos 657: ab = saveabbr(&loab, &loabsize, &lotm);
658: else
659: ab = NULL;
1.17 mlelstv 660: for ( ; ; ) {
1.29 christos 661: time_t diff = hit - lot;
1.17 mlelstv 662: if (diff < 2)
663: break;
664: t = lot;
665: t += diff / 2;
1.1 jtc 666: if (t <= lot)
667: ++t;
668: else if (t >= hit)
669: --t;
1.44 christos 670: tm_ok = my_localtime_rz(tz, &t, &tm) != NULL;
671: if (lotm_ok & tm_ok
672: ? (delta(&tm, &lotm) == t - lot
673: && tm.tm_isdst == lotm.tm_isdst
674: && strcmp(abbr(&tm), ab) == 0)
675: : lotm_ok == tm_ok) {
676: lot = t;
677: if (tm_ok)
678: lotm = tm;
1.1 jtc 679: } else hit = t;
680: }
681: return hit;
682: }
683:
684: /*
1.47 christos 685: ** Thanks to Paul Eggert for logic used in delta_nonneg.
1.1 jtc 686: */
687:
1.29 christos 688: static intmax_t
1.47 christos 689: delta_nonneg(struct tm *newp, struct tm *oldp)
1.1 jtc 690: {
1.29 christos 691: intmax_t result;
692: int tmy;
1.1 jtc 693:
694: result = 0;
695: for (tmy = oldp->tm_year; tmy < newp->tm_year; ++tmy)
1.17 mlelstv 696: result += DAYSPERNYEAR + isleap_sum(tmy, TM_YEAR_BASE);
1.1 jtc 697: result += newp->tm_yday - oldp->tm_yday;
698: result *= HOURSPERDAY;
699: result += newp->tm_hour - oldp->tm_hour;
700: result *= MINSPERHOUR;
701: result += newp->tm_min - oldp->tm_min;
702: result *= SECSPERMIN;
703: result += newp->tm_sec - oldp->tm_sec;
704: return result;
705: }
706:
1.47 christos 707: static intmax_t
708: delta(struct tm *newp, struct tm *oldp)
709: {
710: return (newp->tm_year < oldp->tm_year
711: ? -delta_nonneg(oldp, newp)
712: : delta_nonneg(newp, oldp));
713: }
714:
1.36 christos 715: #ifndef TM_GMTOFF
716: /* Return A->tm_yday, adjusted to compare it fairly to B->tm_yday.
1.39 christos 717: Assume A and B differ by at most one year. */
1.36 christos 718: static int
719: adjusted_yday(struct tm const *a, struct tm const *b)
720: {
721: int yday = a->tm_yday;
722: if (b->tm_year < a->tm_year)
723: yday += 365 + isleap_sum(b->tm_year, TM_YEAR_BASE);
724: return yday;
725: }
726: #endif
727:
1.48 christos 728: /* If A is the broken-down local time and B the broken-down UT for
729: the same instant, return A's UT offset in seconds, where positive
1.44 christos 730: offsets are east of Greenwich. On failure, return LONG_MIN.
731:
1.46 christos 732: If T is nonnull, *T is the timestamp that corresponds to A; call
1.44 christos 733: my_gmtime_r and use its result instead of B. Otherwise, B is the
734: possibly nonnull result of an earlier call to my_gmtime_r. */
1.36 christos 735: static long
1.44 christos 736: gmtoff(struct tm const *a, time_t *t, struct tm const *b)
1.36 christos 737: {
738: #ifdef TM_GMTOFF
739: return a->TM_GMTOFF;
740: #else
1.44 christos 741: struct tm tm;
742: if (t)
743: b = my_gmtime_r(t, &tm);
1.36 christos 744: if (! b)
745: return LONG_MIN;
746: else {
747: int ayday = adjusted_yday(a, b);
748: int byday = adjusted_yday(b, a);
749: int days = ayday - byday;
750: long hours = a->tm_hour - b->tm_hour + 24 * days;
751: long minutes = a->tm_min - b->tm_min + 60 * hours;
752: long seconds = a->tm_sec - b->tm_sec + 60 * minutes;
753: return seconds;
754: }
755: #endif
756: }
757:
1.1 jtc 758: static void
1.36 christos 759: show(timezone_t tz, char *zone, time_t t, bool v)
1.1 jtc 760: {
1.26 christos 761: struct tm * tmp;
1.36 christos 762: struct tm * gmtmp;
763: struct tm tm, gmtm;
1.1 jtc 764:
1.5 jtc 765: (void) printf("%-*s ", (int) longest, zone);
1.1 jtc 766: if (v) {
1.36 christos 767: gmtmp = my_gmtime_r(&t, &gmtm);
768: if (gmtmp == NULL) {
769: printf(tformat(), t);
1.17 mlelstv 770: } else {
1.36 christos 771: dumptime(gmtmp);
1.31 christos 772: (void) printf(" UT");
1.17 mlelstv 773: }
774: (void) printf(" = ");
775: }
1.36 christos 776: tmp = my_localtime_rz(tz, &t, &tm);
1.17 mlelstv 777: dumptime(tmp);
778: if (tmp != NULL) {
779: if (*abbr(tmp) != '\0')
780: (void) printf(" %s", abbr(tmp));
781: if (v) {
1.44 christos 782: long off = gmtoff(tmp, NULL, gmtmp);
1.17 mlelstv 783: (void) printf(" isdst=%d", tmp->tm_isdst);
1.36 christos 784: if (off != LONG_MIN)
785: (void) printf(" gmtoff=%ld", off);
1.17 mlelstv 786: }
1.1 jtc 787: }
788: (void) printf("\n");
1.17 mlelstv 789: if (tmp != NULL && *abbr(tmp) != '\0')
790: abbrok(abbr(tmp), zone);
1.1 jtc 791: }
792:
1.48 christos 793: #if HAVE_SNPRINTF
794: # define my_snprintf snprintf
795: #else
1.47 christos 796: # include <stdarg.h>
797:
798: /* A substitute for snprintf that is good enough for zdump. */
1.48 christos 799: static int ATTRIBUTE_FORMAT((printf, 3, 4))
800: my_snprintf(char *s, size_t size, char const *format, ...)
1.47 christos 801: {
802: int n;
803: va_list args;
804: char const *arg;
805: size_t arglen, slen;
806: char buf[1024];
807: va_start(args, format);
808: if (strcmp(format, "%s") == 0) {
809: arg = va_arg(args, char const *);
810: arglen = strlen(arg);
811: } else {
812: n = vsprintf(buf, format, args);
1.51 christos 813: if (n < 0) {
814: va_end(args);
1.47 christos 815: return n;
1.51 christos 816: }
1.47 christos 817: arg = buf;
818: arglen = n;
819: }
820: slen = arglen < size ? arglen : size - 1;
821: memcpy(s, arg, slen);
822: s[slen] = '\0';
823: n = arglen <= INT_MAX ? arglen : -1;
824: va_end(args);
825: return n;
826: }
827: #endif
828:
1.44 christos 829: /* Store into BUF, of size SIZE, a formatted local time taken from *TM.
830: Use ISO 8601 format +HH:MM:SS. Omit :SS if SS is zero, and omit
831: :MM too if MM is also zero.
832:
833: Return the length of the resulting string. If the string does not
834: fit, return the length that the string would have been if it had
835: fit; do not overrun the output buffer. */
836: static int
837: format_local_time(char *buf, size_t size, struct tm const *tm)
838: {
839: int ss = tm->tm_sec, mm = tm->tm_min, hh = tm->tm_hour;
840: return (ss
1.48 christos 841: ? my_snprintf(buf, size, "%02d:%02d:%02d", hh, mm, ss)
1.44 christos 842: : mm
1.48 christos 843: ? my_snprintf(buf, size, "%02d:%02d", hh, mm)
844: : my_snprintf(buf, size, "%02d", hh));
1.44 christos 845: }
846:
1.48 christos 847: /* Store into BUF, of size SIZE, a formatted UT offset for the
1.44 christos 848: localtime *TM corresponding to time T. Use ISO 8601 format
1.46 christos 849: +HHMMSS, or -HHMMSS for timestamps west of Greenwich; use the
1.48 christos 850: format -00 for unknown UT offsets. If the hour needs more than
1.46 christos 851: two digits to represent, extend the length of HH as needed.
852: Otherwise, omit SS if SS is zero, and omit MM too if MM is also
853: zero.
1.44 christos 854:
855: Return the length of the resulting string, or -1 if the result is
856: not representable as a string. If the string does not fit, return
857: the length that the string would have been if it had fit; do not
858: overrun the output buffer. */
859: static int
860: format_utc_offset(char *buf, size_t size, struct tm const *tm, time_t t)
861: {
862: long off = gmtoff(tm, &t, NULL);
863: char sign = ((off < 0
864: || (off == 0
865: && (*abbr(tm) == '-' || strcmp(abbr(tm), "zzz") == 0)))
866: ? '-' : '+');
867: long hh;
868: int mm, ss;
869: if (off < 0)
870: {
871: if (off == LONG_MIN)
872: return -1;
873: off = -off;
874: }
875: ss = off % 60;
876: mm = off / 60 % 60;
877: hh = off / 60 / 60;
1.46 christos 878: return (ss || 100 <= hh
1.48 christos 879: ? my_snprintf(buf, size, "%c%02ld%02d%02d", sign, hh, mm, ss)
1.44 christos 880: : mm
1.48 christos 881: ? my_snprintf(buf, size, "%c%02ld%02d", sign, hh, mm)
882: : my_snprintf(buf, size, "%c%02ld", sign, hh));
1.44 christos 883: }
884:
885: /* Store into BUF (of size SIZE) a quoted string representation of P.
886: If the representation's length is less than SIZE, return the
887: length; the representation is not null terminated. Otherwise
888: return SIZE, to indicate that BUF is too small. */
889: static size_t
890: format_quoted_string(char *buf, size_t size, char const *p)
891: {
892: char *b = buf;
893: size_t s = size;
894: if (!s)
895: return size;
896: *b++ = '"', s--;
897: for (;;) {
898: char c = *p++;
899: if (s <= 1)
900: return size;
901: switch (c) {
902: default: *b++ = c, s--; continue;
903: case '\0': *b++ = '"', s--; return size - s;
904: case '"': case '\\': break;
905: case ' ': c = 's'; break;
906: case '\f': c = 'f'; break;
907: case '\n': c = 'n'; break;
908: case '\r': c = 'r'; break;
909: case '\t': c = 't'; break;
910: case '\v': c = 'v'; break;
911: }
912: *b++ = '\\', *b++ = c, s -= 2;
913: }
914: }
915:
1.46 christos 916: /* Store into BUF (of size SIZE) a timestamp formatted by TIME_FMT.
1.44 christos 917: TM is the broken-down time, T the seconds count, AB the time zone
918: abbreviation, and ZONE_NAME the zone name. Return true if
919: successful, false if the output would require more than SIZE bytes.
920: TIME_FMT uses the same format that strftime uses, with these
921: additions:
922:
923: %f zone name
924: %L local time as per format_local_time
1.48 christos 925: %Q like "U\t%Z\tD" where U is the UT offset as for format_utc_offset
1.44 christos 926: and D is the isdst flag; except omit D if it is zero, omit %Z if
927: it equals U, quote and escape %Z if it contains nonalphabetics,
928: and omit any trailing tabs. */
929:
930: static bool
931: istrftime(char *buf, size_t size, char const *time_fmt,
932: struct tm const *tm, time_t t, char const *ab, char const *zone_name)
933: {
934: char *b = buf;
935: size_t s = size;
936: char const *f = time_fmt, *p;
937:
938: for (p = f; ; p++)
939: if (*p == '%' && p[1] == '%')
940: p++;
941: else if (!*p
942: || (*p == '%'
943: && (p[1] == 'f' || p[1] == 'L' || p[1] == 'Q'))) {
944: size_t formatted_len;
945: size_t f_prefix_len = p - f;
946: size_t f_prefix_copy_size = p - f + 2;
947: char fbuf[100];
948: bool oversized = sizeof fbuf <= f_prefix_copy_size;
949: char *f_prefix_copy = oversized ? xmalloc(f_prefix_copy_size) : fbuf;
950: memcpy(f_prefix_copy, f, f_prefix_len);
951: strcpy(f_prefix_copy + f_prefix_len, "X");
952: formatted_len = strftime(b, s, f_prefix_copy, tm);
953: if (oversized)
954: free(f_prefix_copy);
955: if (formatted_len == 0)
956: return false;
957: formatted_len--;
958: b += formatted_len, s -= formatted_len;
959: if (!*p++)
960: break;
961: switch (*p) {
962: case 'f':
963: formatted_len = format_quoted_string(b, s, zone_name);
964: break;
965: case 'L':
966: formatted_len = format_local_time(b, s, tm);
967: break;
968: case 'Q':
969: {
970: bool show_abbr;
971: int offlen = format_utc_offset(b, s, tm, t);
972: if (! (0 <= offlen && (size_t)offlen < s))
973: return false;
974: show_abbr = strcmp(b, ab) != 0;
975: b += offlen, s -= offlen;
976: if (show_abbr) {
977: char const *abp;
978: size_t len;
979: if (s <= 1)
980: return false;
981: *b++ = '\t', s--;
982: for (abp = ab; is_alpha(*abp); abp++)
983: continue;
984: len = (!*abp && *ab
1.48 christos 985: ? (size_t)my_snprintf(b, s, "%s", ab)
1.44 christos 986: : format_quoted_string(b, s, ab));
987: if (s <= len)
988: return false;
989: b += len, s -= len;
990: }
1.48 christos 991: formatted_len
992: = (tm->tm_isdst
993: ? my_snprintf(b, s, &"\t\t%d"[show_abbr], tm->tm_isdst)
994: : 0);
1.44 christos 995: }
996: break;
997: }
1.46 christos 998: if (s <= formatted_len)
1.44 christos 999: return false;
1000: b += formatted_len, s -= formatted_len;
1001: f = p + 1;
1002: }
1003: *b = '\0';
1004: return true;
1005: }
1006:
1007: /* Show a time transition. */
1008: static void
1009: showtrans(char const *time_fmt, struct tm const *tm, time_t t, char const *ab,
1010: char const *zone_name)
1011: {
1012: if (!tm) {
1013: printf(tformat(), t);
1014: putchar('\n');
1015: } else {
1016: char stackbuf[1000];
1017: size_t size = sizeof stackbuf;
1018: char *buf = stackbuf;
1019: char *bufalloc = NULL;
1020: while (! istrftime(buf, size, time_fmt, tm, t, ab, zone_name)) {
1021: size = sumsize(size, size);
1022: free(bufalloc);
1023: buf = bufalloc = xmalloc(size);
1024: }
1025: puts(buf);
1026: free(bufalloc);
1027: }
1028: }
1029:
1.9 mycroft 1030: static const char *
1.36 christos 1031: abbr(struct tm const *tmp)
1.1 jtc 1032: {
1.36 christos 1033: #ifdef TM_ZONE
1034: return tmp->TM_ZONE;
1035: #else
1.47 christos 1036: # if HAVE_TZNAME
1037: if (0 <= tmp->tm_isdst && tzname[0 < tmp->tm_isdst])
1038: return tzname[0 < tmp->tm_isdst];
1039: # endif
1040: return "";
1.36 christos 1041: #endif
1.1 jtc 1042: }
1.17 mlelstv 1043:
1044: /*
1045: ** The code below can fail on certain theoretical systems;
1046: ** it works on all known real-world systems as of 2004-12-30.
1047: */
1048:
1049: static const char *
1050: tformat(void)
1051: {
1052: if (0 > (time_t) -1) { /* signed */
1.29 christos 1053: if (sizeof (time_t) == sizeof (intmax_t))
1054: return "%"PRIdMAX;
1.17 mlelstv 1055: if (sizeof (time_t) > sizeof (long))
1056: return "%lld";
1057: if (sizeof (time_t) > sizeof (int))
1058: return "%ld";
1059: return "%d";
1060: }
1.29 christos 1061: #ifdef PRIuMAX
1062: if (sizeof (time_t) == sizeof (uintmax_t))
1063: return "%"PRIuMAX;
1064: #endif
1.17 mlelstv 1065: if (sizeof (time_t) > sizeof (unsigned long))
1066: return "%llu";
1067: if (sizeof (time_t) > sizeof (unsigned int))
1068: return "%lu";
1069: return "%u";
1070: }
1071:
1072: static void
1.26 christos 1073: dumptime(const struct tm *timeptr)
1.17 mlelstv 1074: {
1.47 christos 1075: static const char wday_name[][4] = {
1.17 mlelstv 1076: "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
1077: };
1.47 christos 1078: static const char mon_name[][4] = {
1.17 mlelstv 1079: "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1080: "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
1081: };
1.26 christos 1082: const char * wn;
1083: const char * mn;
1084: int lead;
1085: int trail;
1.17 mlelstv 1086:
1087: if (timeptr == NULL) {
1.36 christos 1088: printf("NULL");
1.17 mlelstv 1089: return;
1090: }
1091: /*
1.36 christos 1092: ** The packaged localtime_rz and gmtime_r never put out-of-range
1.17 mlelstv 1093: ** values in tm_wday or tm_mon, but since this code might be compiled
1094: ** with other (perhaps experimental) versions, paranoia is in order.
1095: */
1096: if (timeptr->tm_wday < 0 || timeptr->tm_wday >=
1097: (int) (sizeof wday_name / sizeof wday_name[0]))
1098: wn = "???";
1099: else wn = wday_name[timeptr->tm_wday];
1100: if (timeptr->tm_mon < 0 || timeptr->tm_mon >=
1101: (int) (sizeof mon_name / sizeof mon_name[0]))
1102: mn = "???";
1103: else mn = mon_name[timeptr->tm_mon];
1.47 christos 1104: printf("%s %s%3d %.2d:%.2d:%.2d ",
1.17 mlelstv 1105: wn, mn,
1106: timeptr->tm_mday, timeptr->tm_hour,
1107: timeptr->tm_min, timeptr->tm_sec);
1108: #define DIVISOR 10
1109: trail = timeptr->tm_year % DIVISOR + TM_YEAR_BASE % DIVISOR;
1110: lead = timeptr->tm_year / DIVISOR + TM_YEAR_BASE / DIVISOR +
1111: trail / DIVISOR;
1112: trail %= DIVISOR;
1113: if (trail < 0 && lead > 0) {
1114: trail += DIVISOR;
1115: --lead;
1116: } else if (lead < 0 && trail > 0) {
1117: trail -= DIVISOR;
1118: ++lead;
1119: }
1120: if (lead == 0)
1.36 christos 1121: printf("%d", trail);
1122: else printf("%d%d", lead, ((trail < 0) ? -trail : trail));
1.17 mlelstv 1123: }
CVSweb <webmaster@jp.NetBSD.org>