1/*
2** This file is in the public domain, so clarified as of
3** 2009-05-17 by Arthur David Olson.
4*/
5
6#include "version.h"
7
8/*
9** This code has been made independent of the rest of the time
10** conversion package to increase confidence in the verification it provides.
11** You can use this code to help in verifying other implementations.
12** To do this, compile with -DUSE_LTZ=0 and link without the tz library.
13*/
14
15#ifndef NETBSD_INSPIRED
16# define NETBSD_INSPIRED 1
17#endif
18#ifndef USE_LTZ
19# define USE_LTZ 1
20#endif
21
22#if USE_LTZ
23# include "private.h"
24#endif
25
26/* Enable tm_gmtoff and tm_zone on GNUish systems. */
27#define _GNU_SOURCE 1
28/* Enable strtoimax on Solaris 10. */
29#define __EXTENSIONS__ 1
30
31#include "stdio.h" /* for stdout, stderr, perror */
32#include "string.h" /* for strcpy */
33#include "sys/types.h" /* for time_t */
34#include "time.h" /* for struct tm */
35#include "stdlib.h" /* for exit, malloc, atoi */
36#include "limits.h" /* for CHAR_BIT, LLONG_MAX */
37#include <errno.h>
38
39/*
40** Substitutes for pre-C99 compilers.
41** Much of this section of code is stolen from private.h.
42*/
43
44#ifndef HAVE_STDINT_H
45# define HAVE_STDINT_H \
46 (199901 <= __STDC_VERSION__ \
47 || 2 < __GLIBC__ + (1 <= __GLIBC_MINOR__) \
48 || __CYGWIN__)
49#endif
50#if HAVE_STDINT_H
51# include "stdint.h"
52#endif
53#ifndef HAVE_INTTYPES_H
54# define HAVE_INTTYPES_H HAVE_STDINT_H
55#endif
56#if HAVE_INTTYPES_H
57# include <inttypes.h>
58#endif
59
60#ifndef INT_FAST32_MAX
61# if INT_MAX >> 31 == 0
62typedef long int_fast32_t;
63# else
64typedef int int_fast32_t;
65# endif
66#endif
67
68/* Pre-C99 GCC compilers define __LONG_LONG_MAX__ instead of LLONG_MAX. */
69#if !defined LLONG_MAX && defined __LONG_LONG_MAX__
70# define LLONG_MAX __LONG_LONG_MAX__
71#endif
72
73#ifndef INTMAX_MAX
74# ifdef LLONG_MAX
75typedef long long intmax_t;
76# define strtoimax strtoll
77# define INTMAX_MAX LLONG_MAX
78# else
79typedef long intmax_t;
80# define strtoimax strtol
81# define INTMAX_MAX LONG_MAX
82# endif
83#endif
84
85#ifndef PRIdMAX
86# if INTMAX_MAX == LLONG_MAX
87# define PRIdMAX "lld"
88# else
89# define PRIdMAX "ld"
90# endif
91#endif
92
93/* Infer TM_ZONE on systems where this information is known, but suppress
94 guessing if NO_TM_ZONE is defined. Similarly for TM_GMTOFF. */
95#if (defined __GLIBC__ \
96 || defined __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ \
97 || (defined __APPLE__ && defined __MACH__))
98# if !defined TM_GMTOFF && !defined NO_TM_GMTOFF
99# define TM_GMTOFF tm_gmtoff
100# endif
101# if !defined TM_ZONE && !defined NO_TM_ZONE
102# define TM_ZONE tm_zone
103# endif
104#endif
105
106#ifndef HAVE_LOCALTIME_R
107# define HAVE_LOCALTIME_R 1
108#endif
109
110#ifndef HAVE_LOCALTIME_RZ
111# ifdef TM_ZONE
112# define HAVE_LOCALTIME_RZ (NETBSD_INSPIRED && USE_LTZ)
113# else
114# define HAVE_LOCALTIME_RZ 0
115# endif
116#endif
117
118#ifndef HAVE_TZSET
119# define HAVE_TZSET 1
120#endif
121
122#ifndef ZDUMP_LO_YEAR
123#define ZDUMP_LO_YEAR (-500)
124#endif /* !defined ZDUMP_LO_YEAR */
125
126#ifndef ZDUMP_HI_YEAR
127#define ZDUMP_HI_YEAR 2500
128#endif /* !defined ZDUMP_HI_YEAR */
129
130#ifndef MAX_STRING_LENGTH
131#define MAX_STRING_LENGTH 1024
132#endif /* !defined MAX_STRING_LENGTH */
133
134#if __STDC_VERSION__ < 199901
135# define true 1
136# define false 0
137# define bool int
138#else
139# include <stdbool.h>
140#endif
141
142#ifndef EXIT_SUCCESS
143#define EXIT_SUCCESS 0
144#endif /* !defined EXIT_SUCCESS */
145
146#ifndef EXIT_FAILURE
147#define EXIT_FAILURE 1
148#endif /* !defined EXIT_FAILURE */
149
150#ifndef SECSPERMIN
151#define SECSPERMIN 60
152#endif /* !defined SECSPERMIN */
153
154#ifndef MINSPERHOUR
155#define MINSPERHOUR 60
156#endif /* !defined MINSPERHOUR */
157
158#ifndef SECSPERHOUR
159#define SECSPERHOUR (SECSPERMIN * MINSPERHOUR)
160#endif /* !defined SECSPERHOUR */
161
162#ifndef HOURSPERDAY
163#define HOURSPERDAY 24
164#endif /* !defined HOURSPERDAY */
165
166#ifndef EPOCH_YEAR
167#define EPOCH_YEAR 1970
168#endif /* !defined EPOCH_YEAR */
169
170#ifndef TM_YEAR_BASE
171#define TM_YEAR_BASE 1900
172#endif /* !defined TM_YEAR_BASE */
173
174#ifndef DAYSPERNYEAR
175#define DAYSPERNYEAR 365
176#endif /* !defined DAYSPERNYEAR */
177
178#ifndef isleap
179#define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0))
180#endif /* !defined isleap */
181
182#ifndef isleap_sum
183/*
184** See tzfile.h for details on isleap_sum.
185*/
186#define isleap_sum(a, b) isleap((a) % 400 + (b) % 400)
187#endif /* !defined isleap_sum */
188
189#define SECSPERDAY ((int_fast32_t) SECSPERHOUR * HOURSPERDAY)
190#define SECSPERNYEAR (SECSPERDAY * DAYSPERNYEAR)
191#define SECSPERLYEAR (SECSPERNYEAR + SECSPERDAY)
192#define SECSPER400YEARS (SECSPERNYEAR * (intmax_t) (300 + 3) \
193 + SECSPERLYEAR * (intmax_t) (100 - 3))
194
195/*
196** True if SECSPER400YEARS is known to be representable as an
197** intmax_t. It's OK that SECSPER400YEARS_FITS can in theory be false
198** even if SECSPER400YEARS is representable, because when that happens
199** the code merely runs a bit more slowly, and this slowness doesn't
200** occur on any practical platform.
201*/
202enum { SECSPER400YEARS_FITS = SECSPERLYEAR <= INTMAX_MAX / 400 };
203
204#ifndef HAVE_GETTEXT
205#define HAVE_GETTEXT 0
206#endif
207#if HAVE_GETTEXT
208#include "locale.h" /* for setlocale */
209#include "libintl.h"
210#endif /* HAVE_GETTEXT */
211
212#if 2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__)
213# define ATTRIBUTE_PURE __attribute__ ((__pure__))
214#else
215# define ATTRIBUTE_PURE /* empty */
216#endif
217
218/*
219** For the benefit of GNU folk...
220** '_(MSGID)' uses the current locale's message library string for MSGID.
221** The default is to use gettext if available, and use MSGID otherwise.
222*/
223
224#ifndef _
225#if HAVE_GETTEXT
226#define _(msgid) gettext(msgid)
227#else /* !HAVE_GETTEXT */
228#define _(msgid) msgid
229#endif /* !HAVE_GETTEXT */
230#endif /* !defined _ */
231
232#if !defined TZ_DOMAIN && defined HAVE_GETTEXT
233# define TZ_DOMAIN "tz"
234#endif
235
236#if ! HAVE_LOCALTIME_RZ
237# undef timezone_t
238# define timezone_t char **
239#endif
240
241extern char ** environ;
242extern int getopt(int argc, char * const argv[],
243 const char * options);
244extern char * optarg;
245extern int optind;
246extern char * tzname[2];
247
248/* The minimum and maximum finite time values. */
249enum { atime_shift = CHAR_BIT * sizeof (time_t) - 2 };
250static time_t const absolute_min_time =
251 ((time_t) -1 < 0
252 ? (- ((time_t) ~ (time_t) 0 < 0)
253 - (((time_t) 1 << atime_shift) - 1 + ((time_t) 1 << atime_shift)))
254 : 0);
255static time_t const absolute_max_time =
256 ((time_t) -1 < 0
257 ? (((time_t) 1 << atime_shift) - 1 + ((time_t) 1 << atime_shift))
258 : -1);
259static int longest;
260static char * progname;
261static bool warned;
262static bool errout;
263
264static char const *abbr(struct tm const *);
265static intmax_t delta(struct tm *, struct tm *) ATTRIBUTE_PURE;
266static void dumptime(struct tm const *);
267static time_t hunt(timezone_t, char *, time_t, time_t);
268static void show(timezone_t, char *, time_t, bool);
269static const char *tformat(void);
270static time_t yeartot(intmax_t) ATTRIBUTE_PURE;
271
272/* Unlike <ctype.h>'s isdigit, this also works if c < 0 | c > UCHAR_MAX. */
273#define is_digit(c) ((unsigned)(c) - '0' <= 9)
274
275/* Is A an alphabetic character in the C locale? */
276static bool
277is_alpha(char a)
278{
279 switch (a) {
280 default:
281 return false;
282 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': case 'G':
283 case 'H': case 'I': case 'J': case 'K': case 'L': case 'M': case 'N':
284 case 'O': case 'P': case 'Q': case 'R': case 'S': case 'T': case 'U':
285 case 'V': case 'W': case 'X': case 'Y': case 'Z':
286 case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': case 'g':
287 case 'h': case 'i': case 'j': case 'k': case 'l': case 'm': case 'n':
288 case 'o': case 'p': case 'q': case 'r': case 's': case 't': case 'u':
289 case 'v': case 'w': case 'x': case 'y': case 'z':
290 return true;
291 }
292}
293
294/* Return A + B, exiting if the result would overflow. */
295static size_t
296sumsize(size_t a, size_t b)
297{
298 size_t sum = a + b;
299 if (sum < a) {
300 fprintf(stderr, "%s: size overflow\n", progname);
301 exit(EXIT_FAILURE);
302 }
303 return sum;
304}
305
306#if ! HAVE_TZSET
307# undef tzset
308# define tzset zdump_tzset
309static void tzset(void) { }
310#endif
311
312/* Assume gmtime_r works if localtime_r does.
313 A replacement localtime_r is defined below if needed. */
314#if ! HAVE_LOCALTIME_R
315
316# undef gmtime_r
317# define gmtime_r zdump_gmtime_r
318
319static struct tm *
320gmtime_r(time_t *tp, struct tm *tmp)
321{
322 struct tm *r = gmtime(tp);
323 if (r) {
324 *tmp = *r;
325 r = tmp;
326 }
327 return r;
328}
329
330#endif
331
332/* Platforms with TM_ZONE don't need tzname, so they can use the
333 faster localtime_rz or localtime_r if available. */
334
335#if defined TM_ZONE && HAVE_LOCALTIME_RZ
336# define USE_LOCALTIME_RZ true
337#else
338# define USE_LOCALTIME_RZ false
339#endif
340
341#if ! USE_LOCALTIME_RZ
342
343# if !defined TM_ZONE || ! HAVE_LOCALTIME_R || ! HAVE_TZSET
344# undef localtime_r
345# define localtime_r zdump_localtime_r
346static struct tm *
347localtime_r(time_t *tp, struct tm *tmp)
348{
349 struct tm *r = localtime(tp);
350 if (r) {
351 *tmp = *r;
352 r = tmp;
353 }
354 return r;
355}
356# endif
357
358# undef localtime_rz
359# define localtime_rz zdump_localtime_rz
360static struct tm *
361localtime_rz(timezone_t rz, time_t *tp, struct tm *tmp)
362{
363 return localtime_r(tp, tmp);
364}
365
366# ifdef TYPECHECK
367# undef mktime_z
368# define mktime_z zdump_mktime_z
369static time_t
370mktime_z(timezone_t tz, struct tm *tmp)
371{
372 return mktime(tmp);
373}
374# endif
375
376# undef tzalloc
377# undef tzfree
378# define tzalloc zdump_tzalloc
379# define tzfree zdump_tzfree
380
381static timezone_t
382tzalloc(char const *val)
383{
384 static char **fakeenv;
385 char **env = fakeenv;
386 char *env0;
387 if (! env) {
388 char **e = environ;
389 int to;
390
391 while (*e++)
392 continue;
393 env = malloc(sumsize(sizeof *environ,
394 (e - environ) * sizeof *environ));
395 if (! env) {
396 perror(progname);
397 exit(EXIT_FAILURE);
398 }
399 to = 1;
400 for (e = environ; (env[to] = *e); e++)
401 to += strncmp(*e, "TZ=", 3) != 0;
402 }
403 env0 = malloc(sumsize(sizeof "TZ=", strlen(val)));
404 if (! env0) {
405 perror(progname);
406 exit(EXIT_FAILURE);
407 }
408 env[0] = strcat(strcpy(env0, "TZ="), val);
409 environ = fakeenv = env;
410 tzset();
411 return env;
412}
413
414static void
415tzfree(timezone_t env)
416{
417 environ = env + 1;
418 free(env[0]);
419}
420#endif /* ! USE_LOCALTIME_RZ */
421
422/* A UTC time zone, and its initializer. */
423static timezone_t gmtz;
424static void
425gmtzinit(void)
426{
427 if (USE_LOCALTIME_RZ) {
428 static char const utc[] = "UTC0";
429 gmtz = tzalloc(utc);
430 if (!gmtz) {
431 perror(utc);
432 exit(EXIT_FAILURE);
433 }
434 }
435}
436
437/* Convert *TP to UTC, storing the broken-down time into *TMP.
438 Return TMP if successful, NULL otherwise. This is like gmtime_r(TP, TMP),
439 except typically faster if USE_LOCALTIME_RZ. */
440static struct tm *
441my_gmtime_r(time_t *tp, struct tm *tmp)
442{
443 return USE_LOCALTIME_RZ ? localtime_rz(gmtz, tp, tmp) : gmtime_r(tp, tmp);
444}
445
446#ifndef TYPECHECK
447# define my_localtime_rz localtime_rz
448#else /* !defined TYPECHECK */
449
450static struct tm *
451my_localtime_rz(timezone_t tz, time_t *tp, struct tm *tmp)
452{
453 tmp = localtime_rz(tz, tp, tmp);
454 if (tmp) {
455 struct tm tm;
456 register time_t t;
457
458 tm = *tmp;
459 t = mktime_z(tz, &tm);
460 if (t != *tp) {
461 fflush(stdout);
462 fprintf(stderr, "\n%s: ", progname);
463 fprintf(stderr, tformat(), *tp);
464 fprintf(stderr, " ->");
465 fprintf(stderr, " year=%d", tmp->tm_year);
466 fprintf(stderr, " mon=%d", tmp->tm_mon);
467 fprintf(stderr, " mday=%d", tmp->tm_mday);
468 fprintf(stderr, " hour=%d", tmp->tm_hour);
469 fprintf(stderr, " min=%d", tmp->tm_min);
470 fprintf(stderr, " sec=%d", tmp->tm_sec);
471 fprintf(stderr, " isdst=%d", tmp->tm_isdst);
472 fprintf(stderr, " -> ");
473 fprintf(stderr, tformat(), t);
474 fprintf(stderr, "\n");
475 errout = true;
476 }
477 }
478 return tmp;
479}
480#endif /* !defined TYPECHECK */
481
482static void
483abbrok(const char *const abbrp, const char *const zone)
484{
485 register const char * cp;
486 register const char * wp;
487
488 if (warned)
489 return;
490 cp = abbrp;
491 while (is_alpha(*cp) || is_digit(*cp) || *cp == '-' || *cp == '+')
492 ++cp;
493 if (cp - abbrp < 3)
494 wp = _("has fewer than 3 characters");
495 else if (cp - abbrp > 6)
496 wp = _("has more than 6 characters");
497 else if (*cp)
498 wp = _("has characters other than ASCII alphanumerics, '-' or '+'");
499 else
500 return;
501 fflush(stdout);
502 fprintf(stderr,
503 _("%s: warning: zone \"%s\" abbreviation \"%s\" %s\n"),
504 progname, zone, abbrp, wp);
505 warned = errout = true;
506}
507
508/* Return a time zone abbreviation. If the abbreviation needs to be
509 saved, use *BUF (of size *BUFALLOC) to save it, and return the
510 abbreviation in the possibly-reallocated *BUF. Otherwise, just
511 return the abbreviation. Get the abbreviation from TMP.
512 Exit on memory allocation failure. */
513static char const *
514saveabbr(char **buf, size_t *bufalloc, struct tm const *tmp)
515{
516 char const *ab = abbr(tmp);
517 if (HAVE_LOCALTIME_RZ)
518 return ab;
519 else {
520 size_t ablen = strlen(ab);
521 if (*bufalloc <= ablen) {
522 free(*buf);
523
524 /* Make the new buffer at least twice as long as the old,
525 to avoid O(N**2) behavior on repeated calls. */
526 *bufalloc = sumsize(*bufalloc, ablen + 1);
527
528 *buf = malloc(*bufalloc);
529 if (! *buf) {
530 perror(progname);
531 exit(EXIT_FAILURE);
532 }
533 }
534 return strcpy(*buf, ab);
535 }
536}
537
538static void
539close_file(FILE *stream)
540{
541 char const *e = (ferror(stream) ? _("I/O error")
542 : fclose(stream) != 0 ? strerror(errno) : NULL);
543 if (e) {
544 fprintf(stderr, "%s: %s\n", progname, e);
545 exit(EXIT_FAILURE);
546 }
547}
548
549static void
550usage(FILE * const stream, const int status)
551{
552 fprintf(stream,
553_("%s: usage: %s [--version] [--help] [-{vV}] [-{ct} [lo,]hi] zonename ...\n"
554 "\n"
555 "Report bugs to %s.\n"),
556 progname, progname, REPORT_BUGS_TO);
557 if (status == EXIT_SUCCESS)
558 close_file(stream);
559 exit(status);
560}
561
562int
563main(int argc, char *argv[])
564{
565 /* These are static so that they're initially zero. */
566 static char * abbrev;
567 static size_t abbrevsize;
568 static struct tm newtm;
569
570 register int i;
571 register bool vflag;
572 register bool Vflag;
573 register char * cutarg;
574 register char * cuttimes;
575 register time_t cutlotime;
576 register time_t cuthitime;
577 time_t now;
578 time_t t;
579 time_t newt;
580 struct tm tm;
581 register struct tm * tmp;
582 register struct tm * newtmp;
583
584 cutlotime = absolute_min_time;
585 cuthitime = absolute_max_time;
586#if HAVE_GETTEXT
587 setlocale(LC_ALL, "");
588#ifdef TZ_DOMAINDIR
589 bindtextdomain(TZ_DOMAIN, TZ_DOMAINDIR);
590#endif /* defined TEXTDOMAINDIR */
591 textdomain(TZ_DOMAIN);
592#endif /* HAVE_GETTEXT */
593 progname = argv[0];
594 for (i = 1; i < argc; ++i)
595 if (strcmp(argv[i], "--version") == 0) {
596 printf("zdump %s%s\n", PKGVERSION, TZVERSION);
597 return EXIT_SUCCESS;
598 } else if (strcmp(argv[i], "--help") == 0) {
599 usage(stdout, EXIT_SUCCESS);
600 }
601 vflag = Vflag = false;
602 cutarg = cuttimes = NULL;
603 for (;;)
604 switch (getopt(argc, argv, "c:t:vV")) {
605 case 'c': cutarg = optarg; break;
606 case 't': cuttimes = optarg; break;
607 case 'v': vflag = true; break;
608 case 'V': Vflag = true; break;
609 case -1:
610 if (! (optind == argc - 1 && strcmp(argv[optind], "=") == 0))
611 goto arg_processing_done;
612 /* Fall through. */
613 default:
614 usage(stderr, EXIT_FAILURE);
615 }
616 arg_processing_done:;
617
618 if (vflag | Vflag) {
619 intmax_t lo;
620 intmax_t hi;
621 char *loend, *hiend;
622 register intmax_t cutloyear = ZDUMP_LO_YEAR;
623 register intmax_t cuthiyear = ZDUMP_HI_YEAR;
624 if (cutarg != NULL) {
625 lo = strtoimax(cutarg, &loend, 10);
626 if (cutarg != loend && !*loend) {
627 hi = lo;
628 cuthiyear = hi;
629 } else if (cutarg != loend && *loend == ','
630 && (hi = strtoimax(loend + 1, &hiend, 10),
631 loend + 1 != hiend && !*hiend)) {
632 cutloyear = lo;
633 cuthiyear = hi;
634 } else {
635 fprintf(stderr, _("%s: wild -c argument %s\n"),
636 progname, cutarg);
637 return EXIT_FAILURE;
638 }
639 }
640 if (cutarg != NULL || cuttimes == NULL) {
641 cutlotime = yeartot(cutloyear);
642 cuthitime = yeartot(cuthiyear);
643 }
644 if (cuttimes != NULL) {
645 lo = strtoimax(cuttimes, &loend, 10);
646 if (cuttimes != loend && !*loend) {
647 hi = lo;
648 if (hi < cuthitime) {
649 if (hi < absolute_min_time)
650 hi = absolute_min_time;
651 cuthitime = hi;
652 }
653 } else if (cuttimes != loend && *loend == ','
654 && (hi = strtoimax(loend + 1, &hiend, 10),
655 loend + 1 != hiend && !*hiend)) {
656 if (cutlotime < lo) {
657 if (absolute_max_time < lo)
658 lo = absolute_max_time;
659 cutlotime = lo;
660 }
661 if (hi < cuthitime) {
662 if (hi < absolute_min_time)
663 hi = absolute_min_time;
664 cuthitime = hi;
665 }
666 } else {
667 fprintf(stderr,
668 _("%s: wild -t argument %s\n"),
669 progname, cuttimes);
670 return EXIT_FAILURE;
671 }
672 }
673 }
674 gmtzinit();
675 now = time(NULL);
676 longest = 0;
677 for (i = optind; i < argc; i++) {
678 size_t arglen = strlen(argv[i]);
679 if (longest < arglen)
680 longest = arglen < INT_MAX ? arglen : INT_MAX;
681 }
682
683 for (i = optind; i < argc; ++i) {
684 timezone_t tz = tzalloc(argv[i]);
685 char const *ab;
686 if (!tz) {
687 perror(argv[i]);
688 return EXIT_FAILURE;
689 }
690 if (! (vflag | Vflag)) {
691 show(tz, argv[i], now, false);
692 tzfree(tz);
693 continue;
694 }
695 warned = false;
696 t = absolute_min_time;
697 if (!Vflag) {
698 show(tz, argv[i], t, true);
699 t += SECSPERDAY;
700 show(tz, argv[i], t, true);
701 }
702 if (t < cutlotime)
703 t = cutlotime;
704 tmp = my_localtime_rz(tz, &t, &tm);
705 if (tmp)
706 ab = saveabbr(&abbrev, &abbrevsize, &tm);
707 while (t < cuthitime) {
708 newt = ((t < absolute_max_time - SECSPERDAY / 2
709 && t + SECSPERDAY / 2 < cuthitime)
710 ? t + SECSPERDAY / 2
711 : cuthitime);
712 newtmp = localtime_rz(tz, &newt, &newtm);
713 if ((tmp == NULL || newtmp == NULL) ? (tmp != newtmp) :
714 (delta(&newtm, &tm) != (newt - t) ||
715 newtm.tm_isdst != tm.tm_isdst ||
716 strcmp(abbr(&newtm), ab) != 0)) {
717 newt = hunt(tz, argv[i], t, newt);
718 newtmp = localtime_rz(tz, &newt, &newtm);
719 if (newtmp)
720 ab = saveabbr(&abbrev, &abbrevsize,
721 &newtm);
722 }
723 t = newt;
724 tm = newtm;
725 tmp = newtmp;
726 }
727 if (!Vflag) {
728 t = absolute_max_time;
729 t -= SECSPERDAY;
730 show(tz, argv[i], t, true);
731 t += SECSPERDAY;
732 show(tz, argv[i], t, true);
733 }
734 tzfree(tz);
735 }
736 close_file(stdout);
737 if (errout && (ferror(stderr) || fclose(stderr) != 0))
738 return EXIT_FAILURE;
739 return EXIT_SUCCESS;
740}
741
742static time_t
743yeartot(intmax_t y)
744{
745 register intmax_t myy, seconds, years;
746 register time_t t;
747
748 myy = EPOCH_YEAR;
749 t = 0;
750 while (myy < y) {
751 if (SECSPER400YEARS_FITS && 400 <= y - myy) {
752 intmax_t diff400 = (y - myy) / 400;
753 if (INTMAX_MAX / SECSPER400YEARS < diff400)
754 return absolute_max_time;
755 seconds = diff400 * SECSPER400YEARS;
756 years = diff400 * 400;
757 } else {
758 seconds = isleap(myy) ? SECSPERLYEAR : SECSPERNYEAR;
759 years = 1;
760 }
761 myy += years;
762 if (t > absolute_max_time - seconds)
763 return absolute_max_time;
764 t += seconds;
765 }
766 while (y < myy) {
767 if (SECSPER400YEARS_FITS && y + 400 <= myy && myy < 0) {
768 intmax_t diff400 = (myy - y) / 400;
769 if (INTMAX_MAX / SECSPER400YEARS < diff400)
770 return absolute_min_time;
771 seconds = diff400 * SECSPER400YEARS;
772 years = diff400 * 400;
773 } else {
774 seconds = isleap(myy - 1) ? SECSPERLYEAR : SECSPERNYEAR;
775 years = 1;
776 }
777 myy -= years;
778 if (t < absolute_min_time + seconds)
779 return absolute_min_time;
780 t -= seconds;
781 }
782 return t;
783}
784
785static time_t
786hunt(timezone_t tz, char *name, time_t lot, time_t hit)
787{
788 static char * loab;
789 static size_t loabsize;
790 char const * ab;
791 time_t t;
792 struct tm lotm;
793 register struct tm * lotmp;
794 struct tm tm;
795 register struct tm * tmp;
796
797 lotmp = my_localtime_rz(tz, &lot, &lotm);
798 if (lotmp)
799 ab = saveabbr(&loab, &loabsize, &lotm);
800 for ( ; ; ) {
801 time_t diff = hit - lot;
802 if (diff < 2)
803 break;
804 t = lot;
805 t += diff / 2;
806 if (t <= lot)
807 ++t;
808 else if (t >= hit)
809 --t;
810 tmp = my_localtime_rz(tz, &t, &tm);
811 if ((lotmp == NULL || tmp == NULL) ? (lotmp == tmp) :
812 (delta(&tm, &lotm) == (t - lot) &&
813 tm.tm_isdst == lotm.tm_isdst &&
814 strcmp(abbr(&tm), ab) == 0)) {
815 lot = t;
816 lotm = tm;
817 lotmp = tmp;
818 } else hit = t;
819 }
820 show(tz, name, lot, true);
821 show(tz, name, hit, true);
822 return hit;
823}
824
825/*
826** Thanks to Paul Eggert for logic used in delta.
827*/
828
829static intmax_t
830delta(struct tm * newp, struct tm *oldp)
831{
832 register intmax_t result;
833 register int tmy;
834
835 if (newp->tm_year < oldp->tm_year)
836 return -delta(oldp, newp);
837 result = 0;
838 for (tmy = oldp->tm_year; tmy < newp->tm_year; ++tmy)
839 result += DAYSPERNYEAR + isleap_sum(tmy, TM_YEAR_BASE);
840 result += newp->tm_yday - oldp->tm_yday;
841 result *= HOURSPERDAY;
842 result += newp->tm_hour - oldp->tm_hour;
843 result *= MINSPERHOUR;
844 result += newp->tm_min - oldp->tm_min;
845 result *= SECSPERMIN;
846 result += newp->tm_sec - oldp->tm_sec;
847 return result;
848}
849
850#ifndef TM_GMTOFF
851/* Return A->tm_yday, adjusted to compare it fairly to B->tm_yday.
852 Assume A and B differ by at most one year. */
853static int
854adjusted_yday(struct tm const *a, struct tm const *b)
855{
856 int yday = a->tm_yday;
857 if (b->tm_year < a->tm_year)
858 yday += 365 + isleap_sum(b->tm_year, TM_YEAR_BASE);
859 return yday;
860}
861#endif
862
863/* If A is the broken-down local time and B the broken-down UTC for
864 the same instant, return A's UTC offset in seconds, where positive
865 offsets are east of Greenwich. On failure, return LONG_MIN. */
866static long
867gmtoff(struct tm const *a, struct tm const *b)
868{
869#ifdef TM_GMTOFF
870 return a->TM_GMTOFF;
871#else
872 if (! b)
873 return LONG_MIN;
874 else {
875 int ayday = adjusted_yday(a, b);
876 int byday = adjusted_yday(b, a);
877 int days = ayday - byday;
878 long hours = a->tm_hour - b->tm_hour + 24 * days;
879 long minutes = a->tm_min - b->tm_min + 60 * hours;
880 long seconds = a->tm_sec - b->tm_sec + 60 * minutes;
881 return seconds;
882 }
883#endif
884}
885
886static void
887show(timezone_t tz, char *zone, time_t t, bool v)
888{
889 register struct tm * tmp;
890 register struct tm * gmtmp;
891 struct tm tm, gmtm;
892
893 printf("%-*s ", longest, zone);
894 if (v) {
895 gmtmp = my_gmtime_r(&t, &gmtm);
896 if (gmtmp == NULL) {
897 printf(tformat(), t);
898 } else {
899 dumptime(gmtmp);
900 printf(" UT");
901 }
902 printf(" = ");
903 }
904 tmp = my_localtime_rz(tz, &t, &tm);
905 dumptime(tmp);
906 if (tmp != NULL) {
907 if (*abbr(tmp) != '\0')
908 printf(" %s", abbr(tmp));
909 if (v) {
910 long off = gmtoff(tmp, gmtmp);
911 printf(" isdst=%d", tmp->tm_isdst);
912 if (off != LONG_MIN)
913 printf(" gmtoff=%ld", off);
914 }
915 }
916 printf("\n");
917 if (tmp != NULL && *abbr(tmp) != '\0')
918 abbrok(abbr(tmp), zone);
919}
920
921static char const *
922abbr(struct tm const *tmp)
923{
924#ifdef TM_ZONE
925 return tmp->TM_ZONE;
926#else
927 return (0 <= tmp->tm_isdst && tzname[0 < tmp->tm_isdst]
928 ? tzname[0 < tmp->tm_isdst]
929 : "");
930#endif
931}
932
933/*
934** The code below can fail on certain theoretical systems;
935** it works on all known real-world systems as of 2004-12-30.
936*/
937
938static const char *
939tformat(void)
940{
941 if (0 > (time_t) -1) { /* signed */
942 if (sizeof (time_t) == sizeof (intmax_t))
943 return "%"PRIdMAX;
944 if (sizeof (time_t) > sizeof (long))
945 return "%lld";
946 if (sizeof (time_t) > sizeof (int))
947 return "%ld";
948 return "%d";
949 }
950#ifdef PRIuMAX
951 if (sizeof (time_t) == sizeof (uintmax_t))
952 return "%"PRIuMAX;
953#endif
954 if (sizeof (time_t) > sizeof (unsigned long))
955 return "%llu";
956 if (sizeof (time_t) > sizeof (unsigned int))
957 return "%lu";
958 return "%u";
959}
960
961static void
962dumptime(register const struct tm *timeptr)
963{
964 static const char wday_name[][3] = {
965 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
966 };
967 static const char mon_name[][3] = {
968 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
969 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
970 };
971 register const char * wn;
972 register const char * mn;
973 register int lead;
974 register int trail;
975
976 if (timeptr == NULL) {
977 printf("NULL");
978 return;
979 }
980 /*
981 ** The packaged localtime_rz and gmtime_r never put out-of-range
982 ** values in tm_wday or tm_mon, but since this code might be compiled
983 ** with other (perhaps experimental) versions, paranoia is in order.
984 */
985 if (timeptr->tm_wday < 0 || timeptr->tm_wday >=
986 (int) (sizeof wday_name / sizeof wday_name[0]))
987 wn = "???";
988 else wn = wday_name[timeptr->tm_wday];
989 if (timeptr->tm_mon < 0 || timeptr->tm_mon >=
990 (int) (sizeof mon_name / sizeof mon_name[0]))
991 mn = "???";
992 else mn = mon_name[timeptr->tm_mon];
993 printf("%.3s %.3s%3d %.2d:%.2d:%.2d ",
994 wn, mn,
995 timeptr->tm_mday, timeptr->tm_hour,
996 timeptr->tm_min, timeptr->tm_sec);
997#define DIVISOR 10
998 trail = timeptr->tm_year % DIVISOR + TM_YEAR_BASE % DIVISOR;
999 lead = timeptr->tm_year / DIVISOR + TM_YEAR_BASE / DIVISOR +
1000 trail / DIVISOR;
1001 trail %= DIVISOR;
1002 if (trail < 0 && lead > 0) {
1003 trail += DIVISOR;
1004 --lead;
1005 } else if (lead < 0 && trail > 0) {
1006 trail -= DIVISOR;
1007 ++lead;
1008 }
1009 if (lead == 0)
1010 printf("%d", trail);
1011 else printf("%d%d", lead, ((trail < 0) ? -trail : trail));
1012}
1013