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 |
62 | typedef long int_fast32_t; |
63 | # else |
64 | typedef 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 |
75 | typedef long long intmax_t; |
76 | # define strtoimax strtoll |
77 | # define INTMAX_MAX LLONG_MAX |
78 | # else |
79 | typedef 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 | */ |
202 | enum { 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 | |
241 | extern char ** environ; |
242 | extern int getopt(int argc, char * const argv[], |
243 | const char * options); |
244 | extern char * optarg; |
245 | extern int optind; |
246 | extern char * tzname[2]; |
247 | |
248 | /* The minimum and maximum finite time values. */ |
249 | enum { atime_shift = CHAR_BIT * sizeof (time_t) - 2 }; |
250 | static 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); |
255 | static 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); |
259 | static int longest; |
260 | static char * progname; |
261 | static bool warned; |
262 | static bool errout; |
263 | |
264 | static char const *abbr(struct tm const *); |
265 | static intmax_t delta(struct tm *, struct tm *) ATTRIBUTE_PURE; |
266 | static void dumptime(struct tm const *); |
267 | static time_t hunt(timezone_t, char *, time_t, time_t); |
268 | static void show(timezone_t, char *, time_t, bool); |
269 | static const char *tformat(void); |
270 | static 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? */ |
276 | static bool |
277 | is_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. */ |
295 | static size_t |
296 | sumsize(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 |
309 | static 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 | |
319 | static struct tm * |
320 | gmtime_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 |
346 | static struct tm * |
347 | localtime_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 |
360 | static struct tm * |
361 | localtime_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 |
369 | static time_t |
370 | mktime_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 | |
381 | static timezone_t |
382 | tzalloc(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 | |
414 | static void |
415 | tzfree(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. */ |
423 | static timezone_t gmtz; |
424 | static void |
425 | gmtzinit(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. */ |
440 | static struct tm * |
441 | my_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 | |
450 | static struct tm * |
451 | my_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 | |
482 | static void |
483 | abbrok(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. */ |
513 | static char const * |
514 | saveabbr(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 | |
538 | static void |
539 | close_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 | |
549 | static void |
550 | usage(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 | |
562 | int |
563 | main(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 | |
742 | static time_t |
743 | yeartot(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 | |
785 | static time_t |
786 | hunt(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 | |
829 | static intmax_t |
830 | delta(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. */ |
853 | static int |
854 | adjusted_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. */ |
866 | static long |
867 | gmtoff(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 | |
886 | static void |
887 | show(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 | |
921 | static char const * |
922 | abbr(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 | |
938 | static const char * |
939 | tformat(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 | |
961 | static void |
962 | dumptime(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 | |