localtime.c revision 1.89 1 /* $NetBSD: localtime.c,v 1.89 2014/10/15 15:13:45 christos Exp $ */
2
3 /*
4 ** This file is in the public domain, so clarified as of
5 ** 1996-06-05 by Arthur David Olson.
6 */
7
8 #include <sys/cdefs.h>
9 #if defined(LIBC_SCCS) && !defined(lint)
10 #if 0
11 static char elsieid[] = "@(#)localtime.c 8.17";
12 #else
13 __RCSID("$NetBSD: localtime.c,v 1.89 2014/10/15 15:13:45 christos Exp $");
14 #endif
15 #endif /* LIBC_SCCS and not lint */
16
17 /*
18 ** Leap second handling from Bradley White.
19 ** POSIX-style TZ environment variable handling from Guy Harris.
20 */
21
22 /*LINTLIBRARY*/
23
24 #include "namespace.h"
25 #include <assert.h>
26 #define LOCALTIME_IMPLEMENTATION
27 #include "private.h"
28
29 #include "tzfile.h"
30 #include "fcntl.h"
31 #include "reentrant.h"
32
33 #if NETBSD_INSPIRED
34 # define NETBSD_INSPIRED_EXTERN
35 #else
36 # define NETBSD_INSPIRED_EXTERN static
37 #endif
38
39 #if defined(__weak_alias)
40 __weak_alias(daylight,_daylight)
41 __weak_alias(tzname,_tzname)
42 #endif
43
44 #ifndef TZ_ABBR_MAX_LEN
45 #define TZ_ABBR_MAX_LEN 16
46 #endif /* !defined TZ_ABBR_MAX_LEN */
47
48 #ifndef TZ_ABBR_CHAR_SET
49 #define TZ_ABBR_CHAR_SET \
50 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"
51 #endif /* !defined TZ_ABBR_CHAR_SET */
52
53 #ifndef TZ_ABBR_ERR_CHAR
54 #define TZ_ABBR_ERR_CHAR '_'
55 #endif /* !defined TZ_ABBR_ERR_CHAR */
56
57 /*
58 ** SunOS 4.1.1 headers lack O_BINARY.
59 */
60
61 #ifdef O_BINARY
62 #define OPEN_MODE (O_RDONLY | O_BINARY | O_CLOEXEC)
63 #endif /* defined O_BINARY */
64 #ifndef O_BINARY
65 #define OPEN_MODE (O_RDONLY | O_CLOEXEC)
66 #endif /* !defined O_BINARY */
67
68 #ifndef WILDABBR
69 /*
70 ** Someone might make incorrect use of a time zone abbreviation:
71 ** 1. They might reference tzname[0] before calling tzset (explicitly
72 ** or implicitly).
73 ** 2. They might reference tzname[1] before calling tzset (explicitly
74 ** or implicitly).
75 ** 3. They might reference tzname[1] after setting to a time zone
76 ** in which Daylight Saving Time is never observed.
77 ** 4. They might reference tzname[0] after setting to a time zone
78 ** in which Standard Time is never observed.
79 ** 5. They might reference tm.TM_ZONE after calling offtime.
80 ** What's best to do in the above cases is open to debate;
81 ** for now, we just set things up so that in any of the five cases
82 ** WILDABBR is used. Another possibility: initialize tzname[0] to the
83 ** string "tzname[0] used before set", and similarly for the other cases.
84 ** And another: initialize tzname[0] to "ERA", with an explanation in the
85 ** manual page of what this "time zone abbreviation" means (doing this so
86 ** that tzname[0] has the "normal" length of three characters).
87 */
88 #define WILDABBR " "
89 #endif /* !defined WILDABBR */
90
91 static const char wildabbr[] = WILDABBR;
92
93 static const char gmt[] = "GMT";
94
95 /*
96 ** The DST rules to use if TZ has no rules and we can't load TZDEFRULES.
97 ** We default to US rules as of 1999-08-17.
98 ** POSIX 1003.1 section 8.1.1 says that the default DST rules are
99 ** implementation dependent; for historical reasons, US rules are a
100 ** common default.
101 */
102 #ifndef TZDEFRULESTRING
103 #define TZDEFRULESTRING ",M4.1.0,M10.5.0"
104 #endif /* !defined TZDEFDST */
105
106 struct ttinfo { /* time type information */
107 int_fast32_t tt_gmtoff; /* UT offset in seconds */
108 bool tt_isdst; /* used to set tm_isdst */
109 int tt_abbrind; /* abbreviation list index */
110 bool tt_ttisstd; /* transition is std time */
111 bool tt_ttisgmt; /* transition is UT */
112 };
113
114 struct lsinfo { /* leap second information */
115 time_t ls_trans; /* transition time */
116 int_fast64_t ls_corr; /* correction to apply */
117 };
118
119 #define SMALLEST(a, b) (((a) < (b)) ? (a) : (b))
120 #define BIGGEST(a, b) (((a) > (b)) ? (a) : (b))
121
122 #ifdef TZNAME_MAX
123 #define MY_TZNAME_MAX TZNAME_MAX
124 #endif /* defined TZNAME_MAX */
125 #ifndef TZNAME_MAX
126 #define MY_TZNAME_MAX 255
127 #endif /* !defined TZNAME_MAX */
128
129 #define state __state
130 struct state {
131 int leapcnt;
132 int timecnt;
133 int typecnt;
134 int charcnt;
135 bool goback;
136 bool goahead;
137 time_t ats[TZ_MAX_TIMES];
138 unsigned char types[TZ_MAX_TIMES];
139 struct ttinfo ttis[TZ_MAX_TYPES];
140 char chars[/*CONSTCOND*/BIGGEST(BIGGEST(TZ_MAX_CHARS + 1,
141 sizeof gmt), (2 * (MY_TZNAME_MAX + 1)))];
142 struct lsinfo lsis[TZ_MAX_LEAPS];
143 int defaulttype; /* for early times or if no transitions */
144 };
145
146 struct rule {
147 int r_type; /* type of rule; see below */
148 int r_day; /* day number of rule */
149 int r_week; /* week number of rule */
150 int r_mon; /* month number of rule */
151 int_fast32_t r_time; /* transition time of rule */
152 };
153
154 #define JULIAN_DAY 0 /* Jn = Julian day */
155 #define DAY_OF_YEAR 1 /* n = day of year */
156 #define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d = month, week, day of week */
157
158 static struct tm *gmtsub(struct state const *, time_t const *, int_fast32_t,
159 struct tm *);
160 static bool increment_overflow(int *, int);
161 static bool increment_overflow_time(time_t *, int_fast32_t);
162 static bool normalize_overflow32(int_fast32_t *, int *, int);
163 static struct tm *timesub(time_t const *, int_fast32_t, struct state const *,
164 struct tm *);
165 static bool typesequiv(struct state const *, int, int);
166 static bool tzparse(char const *, struct state *, bool);
167
168 static timezone_t lclptr;
169 static timezone_t gmtptr;
170
171 #ifndef TZ_STRLEN_MAX
172 #define TZ_STRLEN_MAX 255
173 #endif /* !defined TZ_STRLEN_MAX */
174
175 static char lcl_TZname[TZ_STRLEN_MAX + 1];
176 static int lcl_is_set;
177
178 #if !defined(__LIBC12_SOURCE__)
179
180 __aconst char * tzname[2] = {
181 (__aconst char *)__UNCONST(wildabbr),
182 (__aconst char *)__UNCONST(wildabbr)
183 };
184
185 #else
186
187 extern __aconst char * tzname[2];
188
189 #endif
190
191 #ifdef _REENTRANT
192 static rwlock_t lcl_lock = RWLOCK_INITIALIZER;
193 #endif
194
195 /*
196 ** Section 4.12.3 of X3.159-1989 requires that
197 ** Except for the strftime function, these functions [asctime,
198 ** ctime, gmtime, localtime] return values in one of two static
199 ** objects: a broken-down time structure and an array of char.
200 ** Thanks to Paul Eggert for noting this.
201 */
202
203 static struct tm tm;
204
205 #ifdef USG_COMPAT
206 #if !defined(__LIBC12_SOURCE__)
207 long timezone = 0;
208 int daylight = 0;
209 #else
210 extern int daylight;
211 extern long timezone __RENAME(__timezone13);
212 #endif
213 #endif /* defined USG_COMPAT */
214
215 #ifdef ALTZONE
216 long altzone = 0;
217 #endif /* defined ALTZONE */
218
219 static int_fast32_t
220 detzcode(const char *const codep)
221 {
222 int_fast32_t result;
223 int i;
224
225 result = (codep[0] & 0x80) ? -1 : 0;
226 for (i = 0; i < 4; ++i)
227 result = (result << 8) | (codep[i] & 0xff);
228 return result;
229 }
230
231 static int_fast64_t
232 detzcode64(const char *const codep)
233 {
234 int_fast64_t result;
235 int i;
236
237 result = (codep[0] & 0x80) ? -1 : 0;
238 for (i = 0; i < 8; ++i)
239 result = (result << 8) | (codep[i] & 0xff);
240 return result;
241 }
242
243 const char *
244 tzgetname(const timezone_t sp, int isdst)
245 {
246 int i;
247 for (i = 0; i < sp->timecnt; ++i) {
248 const struct ttinfo *const ttisp = &sp->ttis[sp->types[i]];
249
250 if (ttisp->tt_isdst == isdst)
251 return &sp->chars[ttisp->tt_abbrind];
252 }
253 errno = ESRCH;
254 return NULL;
255 }
256
257 static void
258 settzname_z(timezone_t sp)
259 {
260 int i;
261
262 /*
263 ** Scrub the abbreviations.
264 ** First, replace bogus characters.
265 */
266 for (i = 0; i < sp->charcnt; ++i)
267 if (strchr(TZ_ABBR_CHAR_SET, sp->chars[i]) == NULL)
268 sp->chars[i] = TZ_ABBR_ERR_CHAR;
269 /*
270 ** Second, truncate long abbreviations.
271 */
272 for (i = 0; i < sp->typecnt; ++i) {
273 const struct ttinfo * const ttisp = &sp->ttis[i];
274 char * cp = &sp->chars[ttisp->tt_abbrind];
275
276 if (strlen(cp) > TZ_ABBR_MAX_LEN &&
277 strcmp(cp, GRANDPARENTED) != 0)
278 *(cp + TZ_ABBR_MAX_LEN) = '\0';
279 }
280 }
281
282 static void
283 settzname(void)
284 {
285 timezone_t const sp = lclptr;
286 int i;
287
288 tzname[0] = (__aconst char *)__UNCONST(wildabbr);
289 tzname[1] = (__aconst char *)__UNCONST(wildabbr);
290 #ifdef USG_COMPAT
291 daylight = 0;
292 timezone = 0;
293 #endif /* defined USG_COMPAT */
294 #ifdef ALTZONE
295 altzone = 0;
296 #endif /* defined ALTZONE */
297 if (sp == NULL) {
298 tzname[0] = tzname[1] = (__aconst char *)__UNCONST(gmt);
299 return;
300 }
301 /*
302 ** And to get the latest zone names into tzname. . .
303 */
304 for (i = 0; i < sp->typecnt; ++i) {
305 const struct ttinfo * const ttisp = &sp->ttis[i];
306
307 tzname[ttisp->tt_isdst] = &sp->chars[ttisp->tt_abbrind];
308 #ifdef USG_COMPAT
309 if (ttisp->tt_isdst)
310 daylight = 1;
311 if (!ttisp->tt_isdst)
312 timezone = -(ttisp->tt_gmtoff);
313 #endif /* defined USG_COMPAT */
314 #ifdef ALTZONE
315 if (ttisp->tt_isdst)
316 altzone = -(ttisp->tt_gmtoff);
317 #endif /* defined ALTZONE */
318 }
319 settzname_z(sp);
320 }
321
322 static bool
323 differ_by_repeat(const time_t t1, const time_t t0)
324 {
325 if (TYPE_BIT(time_t) - TYPE_SIGNED(time_t) < SECSPERREPEAT_BITS)
326 return 0;
327 return (int_fast64_t)t1 - (int_fast64_t)t0 == SECSPERREPEAT;
328 }
329
330 static bool
331 tzload(const char *name, timezone_t sp, bool doextend)
332 {
333 const char * p;
334 int i;
335 int fid;
336 int stored;
337 ssize_t nread;
338 typedef union {
339 struct tzhead tzhead;
340 char buf[2 * sizeof(struct tzhead) +
341 2 * sizeof *sp +
342 4 * TZ_MAX_TIMES];
343 } u_t;
344 union local_storage {
345 /*
346 ** Section 4.9.1 of the C standard says that
347 ** "FILENAME_MAX expands to an integral constant expression
348 ** that is the size needed for an array of char large enough
349 ** to hold the longest file name string that the implementation
350 ** guarantees can be opened."
351 */
352 char fullname[FILENAME_MAX + 1];
353
354 /* The main part of the storage for this function. */
355 struct {
356 u_t u;
357 struct state st;
358 } u;
359 };
360 char *fullname;
361 u_t *up;
362 bool doaccess;
363 union local_storage *lsp;
364 lsp = malloc(sizeof *lsp);
365 if (!lsp)
366 return false;
367 fullname = lsp->fullname;
368 up = &lsp->u.u;
369
370 sp->goback = sp->goahead = false;
371
372 if (! name) {
373 name = TZDEFAULT;
374 if (! name)
375 goto oops;
376 }
377
378 if (name[0] == ':')
379 ++name;
380 doaccess = name[0] == '/';
381 if (!doaccess) {
382 p = TZDIR;
383 if (! p || sizeof lsp->fullname - 1 <= strlen(p) + strlen(name))
384 goto oops;
385 strcpy(fullname, p);
386 strcat(fullname, "/");
387 strcat(fullname, name);
388 /* Set doaccess if '.' (as in "../") shows up in name. */
389 if (strchr(name, '.'))
390 doaccess = true;
391 name = fullname;
392 }
393 if (doaccess && access(name, R_OK) != 0)
394 goto oops;
395
396 fid = open(name, OPEN_MODE);
397 if (fid < 0)
398 goto oops;
399 nread = read(fid, up->buf, sizeof up->buf);
400 if (close(fid) < 0 || nread <= 0)
401 goto oops;
402 for (stored = 4; stored <= 8; stored *= 2) {
403 int_fast32_t ttisstdcnt = detzcode(up->tzhead.tzh_ttisstdcnt);
404 int_fast32_t ttisgmtcnt = detzcode(up->tzhead.tzh_ttisgmtcnt);
405 int_fast32_t leapcnt = detzcode(up->tzhead.tzh_leapcnt);
406 int_fast32_t timecnt = detzcode(up->tzhead.tzh_timecnt);
407 int_fast32_t typecnt = detzcode(up->tzhead.tzh_typecnt);
408 int_fast32_t charcnt = detzcode(up->tzhead.tzh_charcnt);
409 p = up->tzhead.tzh_charcnt + sizeof up->tzhead.tzh_charcnt;
410 if (! (0 <= leapcnt && leapcnt < TZ_MAX_LEAPS
411 && 0 < typecnt && typecnt < TZ_MAX_TYPES
412 && 0 <= timecnt && timecnt < TZ_MAX_TIMES
413 && 0 <= charcnt && charcnt < TZ_MAX_CHARS
414 && (ttisstdcnt == typecnt || ttisstdcnt == 0)
415 && (ttisgmtcnt == typecnt || ttisgmtcnt == 0)))
416 goto oops;
417 if (nread - (p - up->buf)
418 < (timecnt * stored /* ats */
419 + timecnt /* types */
420 + typecnt * 6 /* ttinfos */
421 + charcnt /* chars */
422 + leapcnt * (stored + 4) /* lsinfos */
423 + ttisstdcnt /* ttisstds */
424 + ttisgmtcnt)) /* ttisgmts */
425 goto oops;
426 sp->leapcnt = leapcnt;
427 sp->timecnt = timecnt;
428 sp->typecnt = typecnt;
429 sp->charcnt = charcnt;
430
431 /* Read transitions, discarding those out of time_t range.
432 But pretend the last transition before time_t_min
433 occurred at time_t_min. */
434 timecnt = 0;
435 for (i = 0; i < sp->timecnt; ++i) {
436 int_fast64_t at
437 = stored == 4 ? detzcode(p) : detzcode64(p);
438 sp->types[i] = at <= time_t_max;
439 if (sp->types[i]) {
440 time_t attime
441 = ((TYPE_SIGNED(time_t) ?
442 at < time_t_min : at < 0)
443 ? time_t_min : (time_t)at);
444 if (timecnt && attime <= sp->ats[timecnt - 1]) {
445 if (attime < sp->ats[timecnt - 1])
446 goto oops;
447 sp->types[i - 1] = 0;
448 timecnt--;
449 }
450 sp->ats[timecnt++] = attime;
451 }
452 p += stored;
453 }
454
455 timecnt = 0;
456 for (i = 0; i < sp->timecnt; ++i) {
457 unsigned char typ = *p++;
458 if (sp->typecnt <= typ)
459 goto oops;
460 if (sp->types[i])
461 sp->types[timecnt++] = typ;
462 }
463 sp->timecnt = timecnt;
464 for (i = 0; i < sp->typecnt; ++i) {
465 struct ttinfo * ttisp;
466 unsigned char isdst, abbrind;
467
468 ttisp = &sp->ttis[i];
469 ttisp->tt_gmtoff = detzcode(p);
470 p += 4;
471 isdst = *p++;
472 if (! (isdst < 2))
473 goto oops;
474 ttisp->tt_isdst = isdst;
475 abbrind = *p++;
476 if (! (abbrind < sp->charcnt))
477 goto oops;
478 ttisp->tt_abbrind = abbrind;
479 }
480 for (i = 0; i < sp->charcnt; ++i)
481 sp->chars[i] = *p++;
482 sp->chars[i] = '\0'; /* ensure '\0' at end */
483
484 /* Read leap seconds, discarding those out of time_t range. */
485 leapcnt = 0;
486 for (i = 0; i < sp->leapcnt; ++i) {
487 int_fast64_t tr = stored == 4 ? detzcode(p) :
488 detzcode64(p);
489 int_fast32_t corr = detzcode(p + stored);
490 p += stored + 4;
491 if (tr <= time_t_max) {
492 time_t trans = ((TYPE_SIGNED(time_t) ?
493 tr < time_t_min : tr < 0)
494 ? time_t_min : (time_t)tr);
495 if (leapcnt && trans <=
496 sp->lsis[leapcnt - 1].ls_trans) {
497 if (trans <
498 sp->lsis[leapcnt - 1].ls_trans)
499 goto oops;
500 leapcnt--;
501 }
502 sp->lsis[leapcnt].ls_trans = trans;
503 sp->lsis[leapcnt].ls_corr = corr;
504 leapcnt++;
505 }
506 }
507 sp->leapcnt = leapcnt;
508
509 for (i = 0; i < sp->typecnt; ++i) {
510 struct ttinfo * ttisp;
511
512 ttisp = &sp->ttis[i];
513 if (ttisstdcnt == 0)
514 ttisp->tt_ttisstd = false;
515 else {
516 if (*p != true && *p != false)
517 goto oops;
518 ttisp->tt_ttisstd = *p++;
519 }
520 }
521 for (i = 0; i < sp->typecnt; ++i) {
522 struct ttinfo * ttisp;
523
524 ttisp = &sp->ttis[i];
525 if (ttisgmtcnt == 0)
526 ttisp->tt_ttisgmt = false;
527 else {
528 if (*p != true && *p != false)
529 goto oops;
530 ttisp->tt_ttisgmt = *p++;
531 }
532 }
533 /*
534 ** If this is an old file, we're done.
535 */
536 if (up->tzhead.tzh_version[0] == '\0')
537 break;
538 nread -= p - up->buf;
539 for (i = 0; i < nread; ++i)
540 up->buf[i] = p[i];
541 /*
542 ** If this is a signed narrow time_t system, we're done.
543 */
544 if (TYPE_SIGNED(time_t) && stored >= (int) sizeof(time_t))
545 break;
546 }
547 if (doextend && nread > 2 &&
548 up->buf[0] == '\n' && up->buf[nread - 1] == '\n' &&
549 sp->typecnt + 2 <= TZ_MAX_TYPES) {
550 struct state *ts = &lsp->u.st;
551
552 up->buf[nread - 1] = '\0';
553 if (tzparse(&up->buf[1], ts, false)
554 && ts->typecnt == 2
555 && sp->charcnt + ts->charcnt <= TZ_MAX_CHARS) {
556 for (i = 0; i < 2; ++i)
557 ts->ttis[i].tt_abbrind +=
558 sp->charcnt;
559 for (i = 0; i < ts->charcnt; ++i)
560 sp->chars[sp->charcnt++] =
561 ts->chars[i];
562 i = 0;
563 while (i < ts->timecnt &&
564 ts->ats[i] <=
565 sp->ats[sp->timecnt - 1])
566 ++i;
567 while (i < ts->timecnt &&
568 sp->timecnt < TZ_MAX_TIMES) {
569 sp->ats[sp->timecnt] =
570 ts->ats[i];
571 sp->types[sp->timecnt] =
572 sp->typecnt +
573 ts->types[i];
574 ++sp->timecnt;
575 ++i;
576 }
577 sp->ttis[sp->typecnt++] = ts->ttis[0];
578 sp->ttis[sp->typecnt++] = ts->ttis[1];
579 }
580 }
581 if (sp->timecnt > 1) {
582 for (i = 1; i < sp->timecnt; ++i)
583 if (typesequiv(sp, sp->types[i], sp->types[0]) &&
584 differ_by_repeat(sp->ats[i], sp->ats[0])) {
585 sp->goback = true;
586 break;
587 }
588 for (i = sp->timecnt - 2; i >= 0; --i)
589 if (typesequiv(sp, sp->types[sp->timecnt - 1],
590 sp->types[i]) &&
591 differ_by_repeat(sp->ats[sp->timecnt - 1],
592 sp->ats[i])) {
593 sp->goahead = true;
594 break;
595 }
596 }
597 /*
598 ** If type 0 is is unused in transitions,
599 ** it's the type to use for early times.
600 */
601 for (i = 0; i < sp->timecnt; ++i)
602 if (sp->types[i] == 0)
603 break;
604 i = i < sp->timecnt ? -1 : 0;
605 /*
606 ** Absent the above,
607 ** if there are transition times
608 ** and the first transition is to a daylight time
609 ** find the standard type less than and closest to
610 ** the type of the first transition.
611 */
612 if (i < 0 && sp->timecnt > 0 && sp->ttis[sp->types[0]].tt_isdst) {
613 i = sp->types[0];
614 while (--i >= 0)
615 if (!sp->ttis[i].tt_isdst)
616 break;
617 }
618 /*
619 ** If no result yet, find the first standard type.
620 ** If there is none, punt to type zero.
621 */
622 if (i < 0) {
623 i = 0;
624 while (sp->ttis[i].tt_isdst)
625 if (++i >= sp->typecnt) {
626 i = 0;
627 break;
628 }
629 }
630 sp->defaulttype = i;
631 free(up);
632 return true;
633 oops:
634 free(up);
635 return false;
636 }
637
638 static bool
639 typesequiv(struct state const *sp, int a, int b)
640 {
641 bool result;
642
643 if (sp == NULL ||
644 a < 0 || a >= sp->typecnt ||
645 b < 0 || b >= sp->typecnt)
646 result = false;
647 else {
648 const struct ttinfo * ap = &sp->ttis[a];
649 const struct ttinfo * bp = &sp->ttis[b];
650 result = ap->tt_gmtoff == bp->tt_gmtoff &&
651 ap->tt_isdst == bp->tt_isdst &&
652 ap->tt_ttisstd == bp->tt_ttisstd &&
653 ap->tt_ttisgmt == bp->tt_ttisgmt &&
654 strcmp(&sp->chars[ap->tt_abbrind],
655 &sp->chars[bp->tt_abbrind]) == 0;
656 }
657 return result;
658 }
659
660 static const int mon_lengths[2][MONSPERYEAR] = {
661 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
662 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
663 };
664
665 static const int year_lengths[2] = {
666 DAYSPERNYEAR, DAYSPERLYEAR
667 };
668
669 /*
670 ** Given a pointer into a time zone string, scan until a character that is not
671 ** a valid character in a zone name is found. Return a pointer to that
672 ** character.
673 */
674
675 static const char * ATTRIBUTE_PURE
676 getzname(const char *strp)
677 {
678 char c;
679
680 while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' &&
681 c != '+')
682 ++strp;
683 return strp;
684 }
685
686 /*
687 ** Given a pointer into an extended time zone string, scan until the ending
688 ** delimiter of the zone name is located. Return a pointer to the delimiter.
689 **
690 ** As with getzname above, the legal character set is actually quite
691 ** restricted, with other characters producing undefined results.
692 ** We don't do any checking here; checking is done later in common-case code.
693 */
694
695 static const char * ATTRIBUTE_PURE
696 getqzname(const char *strp, const int delim)
697 {
698 int c;
699
700 while ((c = *strp) != '\0' && c != delim)
701 ++strp;
702 return strp;
703 }
704
705 /*
706 ** Given a pointer into a time zone string, extract a number from that string.
707 ** Check that the number is within a specified range; if it is not, return
708 ** NULL.
709 ** Otherwise, return a pointer to the first character not part of the number.
710 */
711
712 static const char *
713 getnum(const char *strp, int *const nump, const int min, const int max)
714 {
715 char c;
716 int num;
717
718 if (strp == NULL || !is_digit(c = *strp)) {
719 errno = EINVAL;
720 return NULL;
721 }
722 num = 0;
723 do {
724 num = num * 10 + (c - '0');
725 if (num > max) {
726 errno = EOVERFLOW;
727 return NULL; /* illegal value */
728 }
729 c = *++strp;
730 } while (is_digit(c));
731 if (num < min) {
732 errno = EINVAL;
733 return NULL; /* illegal value */
734 }
735 *nump = num;
736 return strp;
737 }
738
739 /*
740 ** Given a pointer into a time zone string, extract a number of seconds,
741 ** in hh[:mm[:ss]] form, from the string.
742 ** If any error occurs, return NULL.
743 ** Otherwise, return a pointer to the first character not part of the number
744 ** of seconds.
745 */
746
747 static const char *
748 getsecs(const char *strp, int_fast32_t *const secsp)
749 {
750 int num;
751
752 /*
753 ** 'HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like
754 ** "M10.4.6/26", which does not conform to Posix,
755 ** but which specifies the equivalent of
756 ** "02:00 on the first Sunday on or after 23 Oct".
757 */
758 strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);
759 if (strp == NULL)
760 return NULL;
761 *secsp = num * (int_fast32_t) SECSPERHOUR;
762 if (*strp == ':') {
763 ++strp;
764 strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
765 if (strp == NULL)
766 return NULL;
767 *secsp += num * SECSPERMIN;
768 if (*strp == ':') {
769 ++strp;
770 /* 'SECSPERMIN' allows for leap seconds. */
771 strp = getnum(strp, &num, 0, SECSPERMIN);
772 if (strp == NULL)
773 return NULL;
774 *secsp += num;
775 }
776 }
777 return strp;
778 }
779
780 /*
781 ** Given a pointer into a time zone string, extract an offset, in
782 ** [+-]hh[:mm[:ss]] form, from the string.
783 ** If any error occurs, return NULL.
784 ** Otherwise, return a pointer to the first character not part of the time.
785 */
786
787 static const char *
788 getoffset(const char *strp, int_fast32_t *const offsetp)
789 {
790 bool neg = false;
791
792 if (*strp == '-') {
793 neg = true;
794 ++strp;
795 } else if (*strp == '+')
796 ++strp;
797 strp = getsecs(strp, offsetp);
798 if (strp == NULL)
799 return NULL; /* illegal time */
800 if (neg)
801 *offsetp = -*offsetp;
802 return strp;
803 }
804
805 /*
806 ** Given a pointer into a time zone string, extract a rule in the form
807 ** date[/time]. See POSIX section 8 for the format of "date" and "time".
808 ** If a valid rule is not found, return NULL.
809 ** Otherwise, return a pointer to the first character not part of the rule.
810 */
811
812 static const char *
813 getrule(const char *strp, struct rule *const rulep)
814 {
815 if (*strp == 'J') {
816 /*
817 ** Julian day.
818 */
819 rulep->r_type = JULIAN_DAY;
820 ++strp;
821 strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
822 } else if (*strp == 'M') {
823 /*
824 ** Month, week, day.
825 */
826 rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
827 ++strp;
828 strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
829 if (strp == NULL)
830 return NULL;
831 if (*strp++ != '.')
832 return NULL;
833 strp = getnum(strp, &rulep->r_week, 1, 5);
834 if (strp == NULL)
835 return NULL;
836 if (*strp++ != '.')
837 return NULL;
838 strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
839 } else if (is_digit(*strp)) {
840 /*
841 ** Day of year.
842 */
843 rulep->r_type = DAY_OF_YEAR;
844 strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
845 } else return NULL; /* invalid format */
846 if (strp == NULL)
847 return NULL;
848 if (*strp == '/') {
849 /*
850 ** Time specified.
851 */
852 ++strp;
853 strp = getoffset(strp, &rulep->r_time);
854 } else rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */
855 return strp;
856 }
857
858 /*
859 ** Given a year, a rule, and the offset from UT at the time that rule takes
860 ** effect, calculate the year-relative time that rule takes effect.
861 */
862
863 static int_fast32_t ATTRIBUTE_PURE
864 transtime(const int year, const struct rule *const rulep,
865 const int_fast32_t offset)
866 {
867 bool leapyear;
868 int_fast32_t value;
869 int i;
870 int d, m1, yy0, yy1, yy2, dow;
871
872 INITIALIZE(value);
873 leapyear = isleap(year);
874 switch (rulep->r_type) {
875
876 case JULIAN_DAY:
877 /*
878 ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
879 ** years.
880 ** In non-leap years, or if the day number is 59 or less, just
881 ** add SECSPERDAY times the day number-1 to the time of
882 ** January 1, midnight, to get the day.
883 */
884 value = (rulep->r_day - 1) * SECSPERDAY;
885 if (leapyear && rulep->r_day >= 60)
886 value += SECSPERDAY;
887 break;
888
889 case DAY_OF_YEAR:
890 /*
891 ** n - day of year.
892 ** Just add SECSPERDAY times the day number to the time of
893 ** January 1, midnight, to get the day.
894 */
895 value = rulep->r_day * SECSPERDAY;
896 break;
897
898 case MONTH_NTH_DAY_OF_WEEK:
899 /*
900 ** Mm.n.d - nth "dth day" of month m.
901 */
902
903 /*
904 ** Use Zeller's Congruence to get day-of-week of first day of
905 ** month.
906 */
907 m1 = (rulep->r_mon + 9) % 12 + 1;
908 yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
909 yy1 = yy0 / 100;
910 yy2 = yy0 % 100;
911 dow = ((26 * m1 - 2) / 10 +
912 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
913 if (dow < 0)
914 dow += DAYSPERWEEK;
915
916 /*
917 ** "dow" is the day-of-week of the first day of the month. Get
918 ** the day-of-month (zero-origin) of the first "dow" day of the
919 ** month.
920 */
921 d = rulep->r_day - dow;
922 if (d < 0)
923 d += DAYSPERWEEK;
924 for (i = 1; i < rulep->r_week; ++i) {
925 if (d + DAYSPERWEEK >=
926 mon_lengths[leapyear][rulep->r_mon - 1])
927 break;
928 d += DAYSPERWEEK;
929 }
930
931 /*
932 ** "d" is the day-of-month (zero-origin) of the day we want.
933 */
934 value = d * SECSPERDAY;
935 for (i = 0; i < rulep->r_mon - 1; ++i)
936 value += mon_lengths[leapyear][i] * SECSPERDAY;
937 break;
938 }
939
940 /*
941 ** "value" is the year-relative time of 00:00:00 UT on the day in
942 ** question. To get the year-relative time of the specified local
943 ** time on that day, add the transition time and the current offset
944 ** from UT.
945 */
946 return value + rulep->r_time + offset;
947 }
948
949 /*
950 ** Given a POSIX section 8-style TZ string, fill in the rule tables as
951 ** appropriate.
952 */
953
954 static bool
955 tzparse(const char *name, timezone_t sp,
956 bool lastditch)
957 {
958 const char * stdname;
959 const char * dstname;
960 size_t stdlen;
961 size_t dstlen;
962 int_fast32_t stdoffset;
963 int_fast32_t dstoffset;
964 char * cp;
965 bool load_ok;
966
967 dstname = NULL; /* XXX gcc */
968 stdname = name;
969 if (lastditch) {
970 stdlen = strlen(name); /* length of standard zone name */
971 name += stdlen;
972 if (stdlen >= sizeof sp->chars)
973 stdlen = (sizeof sp->chars) - 1;
974 stdoffset = 0;
975 } else {
976 if (*name == '<') {
977 name++;
978 stdname = name;
979 name = getqzname(name, '>');
980 if (*name != '>')
981 return false;
982 stdlen = name - stdname;
983 name++;
984 } else {
985 name = getzname(name);
986 stdlen = name - stdname;
987 }
988 if (*name == '\0')
989 return false;
990 name = getoffset(name, &stdoffset);
991 if (name == NULL)
992 return false;
993 }
994 load_ok = tzload(TZDEFRULES, sp, false);
995 if (!load_ok)
996 sp->leapcnt = 0; /* so, we're off a little */
997 if (*name != '\0') {
998 if (*name == '<') {
999 dstname = ++name;
1000 name = getqzname(name, '>');
1001 if (*name != '>')
1002 return false;
1003 dstlen = name - dstname;
1004 name++;
1005 } else {
1006 dstname = name;
1007 name = getzname(name);
1008 dstlen = name - dstname; /* length of DST zone name */
1009 }
1010 if (*name != '\0' && *name != ',' && *name != ';') {
1011 name = getoffset(name, &dstoffset);
1012 if (name == NULL)
1013 return false;
1014 } else dstoffset = stdoffset - SECSPERHOUR;
1015 if (*name == '\0' && !load_ok)
1016 name = TZDEFRULESTRING;
1017 if (*name == ',' || *name == ';') {
1018 struct rule start;
1019 struct rule end;
1020 int year;
1021 int yearlim;
1022 int timecnt;
1023 time_t janfirst;
1024
1025 ++name;
1026 if ((name = getrule(name, &start)) == NULL)
1027 return false;
1028 if (*name++ != ',')
1029 return false;
1030 if ((name = getrule(name, &end)) == NULL)
1031 return false;
1032 if (*name != '\0')
1033 return false;
1034 sp->typecnt = 2; /* standard time and DST */
1035 /*
1036 ** Two transitions per year, from EPOCH_YEAR forward.
1037 */
1038 memset(sp->ttis, 0, sizeof(sp->ttis));
1039 sp->ttis[0].tt_gmtoff = -dstoffset;
1040 sp->ttis[0].tt_isdst = true;
1041 sp->ttis[0].tt_abbrind = (int)(stdlen + 1);
1042 sp->ttis[1].tt_gmtoff = -stdoffset;
1043 sp->ttis[1].tt_isdst = false;
1044 sp->ttis[1].tt_abbrind = 0;
1045 sp->defaulttype = 0;
1046 timecnt = 0;
1047 janfirst = 0;
1048 yearlim = EPOCH_YEAR + YEARSPERREPEAT;
1049 for (year = EPOCH_YEAR; year < yearlim; year++) {
1050 int_fast32_t
1051 starttime = transtime(year, &start, stdoffset),
1052 endtime = transtime(year, &end, dstoffset);
1053 int_fast32_t
1054 yearsecs = (year_lengths[isleap(year)]
1055 * SECSPERDAY);
1056 bool reversed = endtime < starttime;
1057 if (reversed) {
1058 int_fast32_t swap = starttime;
1059 starttime = endtime;
1060 endtime = swap;
1061 }
1062 if (reversed
1063 || (starttime < endtime
1064 && (endtime - starttime
1065 < (yearsecs
1066 + (stdoffset - dstoffset))))) {
1067 if (TZ_MAX_TIMES - 2 < timecnt)
1068 break;
1069 yearlim = year + YEARSPERREPEAT + 1;
1070 sp->ats[timecnt] = janfirst;
1071 if (increment_overflow_time
1072 (&sp->ats[timecnt], starttime))
1073 break;
1074 sp->types[timecnt++] = reversed;
1075 sp->ats[timecnt] = janfirst;
1076 if (increment_overflow_time
1077 (&sp->ats[timecnt], endtime))
1078 break;
1079 sp->types[timecnt++] = !reversed;
1080 }
1081 if (increment_overflow_time(&janfirst, yearsecs))
1082 break;
1083 }
1084 sp->timecnt = timecnt;
1085 if (!timecnt)
1086 sp->typecnt = 1; /* Perpetual DST. */
1087 } else {
1088 int_fast32_t theirstdoffset;
1089 int_fast32_t theirdstoffset;
1090 int_fast32_t theiroffset;
1091 bool isdst;
1092 int i;
1093 int j;
1094
1095 if (*name != '\0')
1096 return false;
1097 /*
1098 ** Initial values of theirstdoffset and theirdstoffset.
1099 */
1100 theirstdoffset = 0;
1101 for (i = 0; i < sp->timecnt; ++i) {
1102 j = sp->types[i];
1103 if (!sp->ttis[j].tt_isdst) {
1104 theirstdoffset =
1105 -sp->ttis[j].tt_gmtoff;
1106 break;
1107 }
1108 }
1109 theirdstoffset = 0;
1110 for (i = 0; i < sp->timecnt; ++i) {
1111 j = sp->types[i];
1112 if (sp->ttis[j].tt_isdst) {
1113 theirdstoffset =
1114 -sp->ttis[j].tt_gmtoff;
1115 break;
1116 }
1117 }
1118 /*
1119 ** Initially we're assumed to be in standard time.
1120 */
1121 isdst = false;
1122 theiroffset = theirstdoffset;
1123 /*
1124 ** Now juggle transition times and types
1125 ** tracking offsets as you do.
1126 */
1127 for (i = 0; i < sp->timecnt; ++i) {
1128 j = sp->types[i];
1129 sp->types[i] = sp->ttis[j].tt_isdst;
1130 if (sp->ttis[j].tt_ttisgmt) {
1131 /* No adjustment to transition time */
1132 } else {
1133 /*
1134 ** If summer time is in effect, and the
1135 ** transition time was not specified as
1136 ** standard time, add the summer time
1137 ** offset to the transition time;
1138 ** otherwise, add the standard time
1139 ** offset to the transition time.
1140 */
1141 /*
1142 ** Transitions from DST to DDST
1143 ** will effectively disappear since
1144 ** POSIX provides for only one DST
1145 ** offset.
1146 */
1147 if (isdst && !sp->ttis[j].tt_ttisstd) {
1148 sp->ats[i] += (time_t)
1149 (dstoffset - theirdstoffset);
1150 } else {
1151 sp->ats[i] += (time_t)
1152 (stdoffset - theirstdoffset);
1153 }
1154 }
1155 theiroffset = -sp->ttis[j].tt_gmtoff;
1156 if (sp->ttis[j].tt_isdst)
1157 theirstdoffset = theiroffset;
1158 else theirdstoffset = theiroffset;
1159 }
1160 /*
1161 ** Finally, fill in ttis.
1162 */
1163 memset(sp->ttis, 0, sizeof(sp->ttis));
1164 sp->ttis[0].tt_gmtoff = -stdoffset;
1165 sp->ttis[0].tt_isdst = false;
1166 sp->ttis[0].tt_abbrind = 0;
1167 sp->ttis[1].tt_gmtoff = -dstoffset;
1168 sp->ttis[1].tt_isdst = true;
1169 sp->ttis[1].tt_abbrind = (int)(stdlen + 1);
1170 sp->typecnt = 2;
1171 sp->defaulttype = 0;
1172 }
1173 } else {
1174 dstlen = 0;
1175 sp->typecnt = 1; /* only standard time */
1176 sp->timecnt = 0;
1177 memset(sp->ttis, 0, sizeof(sp->ttis));
1178 sp->ttis[0].tt_gmtoff = -stdoffset;
1179 sp->ttis[0].tt_isdst = false;
1180 sp->ttis[0].tt_abbrind = 0;
1181 sp->defaulttype = 0;
1182 }
1183 sp->charcnt = (int)(stdlen + 1);
1184 if (dstlen != 0)
1185 sp->charcnt += (int)(dstlen + 1);
1186 if ((size_t) sp->charcnt > sizeof sp->chars)
1187 return false;
1188 cp = sp->chars;
1189 (void) memcpy(cp, stdname, stdlen);
1190 cp += stdlen;
1191 *cp++ = '\0';
1192 if (dstlen != 0) {
1193 (void) memcpy(cp, dstname, dstlen);
1194 *(cp + dstlen) = '\0';
1195 }
1196 return true;
1197 }
1198
1199 static void
1200 gmtload(struct state *const sp)
1201 {
1202 if (! tzload(gmt, sp, true))
1203 (void) tzparse(gmt, sp, true);
1204 }
1205
1206 static struct state *
1207 zoneinit(struct state *sp, char const *name)
1208 {
1209 if (!sp)
1210 return NULL;
1211 if (name && ! name[0]) {
1212 /*
1213 ** User wants it fast rather than right.
1214 */
1215 sp->leapcnt = 0; /* so, we're off a little */
1216 sp->timecnt = 0;
1217 sp->typecnt = 0;
1218 sp->ttis[0].tt_isdst = 0;
1219 sp->ttis[0].tt_gmtoff = 0;
1220 sp->ttis[0].tt_abbrind = 0;
1221 strcpy(sp->chars, gmt);
1222 return sp;
1223 }
1224 if (! (tzload(name, sp, true)
1225 || (name && name[0] != ':' && tzparse(name, sp, false))))
1226 return NULL;
1227 return sp;
1228 }
1229
1230 static void
1231 tzsetlcl(char const *name)
1232 {
1233 int lcl = name ? strlen(name) < sizeof lcl_TZname : -1;
1234 if (lcl < 0 ? lcl_is_set < 0
1235 : 0 < lcl_is_set && strcmp(lcl_TZname, name) == 0)
1236 return;
1237 if (0 < lcl)
1238 (void)strcpy(lcl_TZname, name);
1239
1240 if (! lclptr) {
1241 struct state *sp = malloc(sizeof *lclptr);
1242 if (!zoneinit(sp, name)) {
1243 free(sp);
1244 return;
1245 }
1246 lclptr = sp;
1247 }
1248 settzname();
1249 lcl_is_set = lcl;
1250 }
1251
1252 #ifdef STD_INSPIRED
1253 void
1254 tzsetwall(void)
1255 {
1256 rwlock_wrlock(&lcl_lock);
1257 tzsetlcl(NULL);
1258 rwlock_unlock(&lcl_lock);
1259 }
1260 #endif
1261
1262 static void
1263 tzset_unlocked(void)
1264 {
1265 tzsetlcl(getenv("TZ"));
1266 }
1267
1268 void
1269 tzset(void)
1270 {
1271 rwlock_wrlock(&lcl_lock);
1272 tzset_unlocked();
1273 rwlock_unlock(&lcl_lock);
1274 }
1275
1276 static void
1277 gmtcheck(void)
1278 {
1279 static bool gmt_is_set;
1280 rwlock_wrlock(&lcl_lock);
1281 if (! gmt_is_set) {
1282 gmtptr = malloc(sizeof *gmtptr);
1283 if (gmtptr)
1284 gmtload(gmtptr);
1285 gmt_is_set = true;
1286 }
1287 rwlock_unlock(&lcl_lock);
1288 }
1289
1290 #if NETBSD_INSPIRED
1291
1292 timezone_t
1293 tzalloc(const char *name)
1294 {
1295 timezone_t sp = malloc(sizeof *sp);
1296 timezone_t tp = sp ? zoneinit(sp, name) : sp;
1297 if (!tp)
1298 free(sp);
1299 return tp;
1300 }
1301
1302 void
1303 tzfree(timezone_t sp)
1304 {
1305 free(sp);
1306 }
1307
1308 /*
1309 ** NetBSD 6.1.4 has ctime_rz, but omit it because POSIX says ctime and
1310 ** ctime_r are obsolescent and have potential security problems that
1311 ** ctime_rz would share. Callers can instead use localtime_rz + strftime.
1312 **
1313 ** NetBSD 6.1.4 has tzgetname, but omit it because it doesn't work
1314 ** in zones with three or more time zone abbreviations.
1315 ** Callers can instead use localtime_rz + strftime.
1316 */
1317
1318 #endif
1319
1320 /*
1321 ** The easy way to behave "as if no library function calls" localtime
1322 ** is to not call it, so we drop its guts into "localsub", which can be
1323 ** freely called. (And no, the PANS doesn't require the above behavior,
1324 ** but it *is* desirable.)
1325 **
1326 ** If OFFSET is nonzero, set tzname if successful.
1327 ** OFFSET's type is intfast32_t for compatibility with gmtsub.
1328 */
1329
1330 /*ARGSUSED*/
1331 static struct tm *
1332 localsub(struct state const *sp, time_t const *timep, int_fast32_t offset,
1333 struct tm *const tmp)
1334 {
1335 const struct ttinfo * ttisp;
1336 int i;
1337 struct tm * result;
1338 const time_t t = *timep;
1339
1340 if (sp == NULL) {
1341 result = gmtsub(gmtptr, timep, 0, tmp);
1342 if (result && offset)
1343 tzname[0] = gmtptr ? gmtptr->chars : __UNCONST(gmt);
1344 return result;
1345 }
1346 if ((sp->goback && t < sp->ats[0]) ||
1347 (sp->goahead && t > sp->ats[sp->timecnt - 1])) {
1348 time_t newt = t;
1349 time_t seconds;
1350 time_t years;
1351
1352 if (t < sp->ats[0])
1353 seconds = sp->ats[0] - t;
1354 else seconds = t - sp->ats[sp->timecnt - 1];
1355 --seconds;
1356 years = (time_t)((seconds / SECSPERREPEAT + 1) * YEARSPERREPEAT);
1357 seconds = (time_t)(years * AVGSECSPERYEAR);
1358 if (t < sp->ats[0])
1359 newt += seconds;
1360 else newt -= seconds;
1361 if (newt < sp->ats[0] ||
1362 newt > sp->ats[sp->timecnt - 1]) {
1363 errno = EINVAL;
1364 return NULL; /* "cannot happen" */
1365 }
1366 result = localsub(sp, &newt, offset, tmp);
1367 if (result) {
1368 int_fast64_t newy;
1369
1370 newy = result->tm_year;
1371 if (t < sp->ats[0])
1372 newy -= years;
1373 else newy += years;
1374 if (! (INT_MIN <= newy && newy <= INT_MAX)) {
1375 errno = EOVERFLOW;
1376 return NULL;
1377 }
1378 result->tm_year = (int)newy;
1379 }
1380 return result;
1381 }
1382 if (sp->timecnt == 0 || t < sp->ats[0]) {
1383 i = sp->defaulttype;
1384 } else {
1385 int lo = 1;
1386 int hi = sp->timecnt;
1387
1388 while (lo < hi) {
1389 int mid = (lo + hi) / 2;
1390
1391 if (t < sp->ats[mid])
1392 hi = mid;
1393 else lo = mid + 1;
1394 }
1395 i = (int) sp->types[lo - 1];
1396 }
1397 ttisp = &sp->ttis[i];
1398 /*
1399 ** To get (wrong) behavior that's compatible with System V Release 2.0
1400 ** you'd replace the statement below with
1401 ** t += ttisp->tt_gmtoff;
1402 ** timesub(&t, 0L, sp, tmp);
1403 */
1404 result = timesub(&t, ttisp->tt_gmtoff, sp, tmp);
1405 if (result) {
1406 result->tm_isdst = ttisp->tt_isdst;
1407 if (offset)
1408 tzname[result->tm_isdst] =
1409 __UNCONST(&sp->chars[ttisp->tt_abbrind]);
1410 #ifdef TM_ZONE
1411 result->TM_ZONE = __UNCONST(&sp->chars[ttisp->tt_abbrind]);
1412 #endif /* defined TM_ZONE */
1413 }
1414 return result;
1415 }
1416
1417 #if NETBSD_INSPIRED
1418
1419 struct tm *
1420 localtime_rz(timezone_t sp, time_t const *timep, struct tm *tmp)
1421 {
1422 return localsub(sp, timep, 0, tmp);
1423 }
1424
1425 #endif
1426
1427 static struct tm *
1428 localtime_tzset(time_t const *timep, struct tm *tmp, bool setname)
1429 {
1430 rwlock_wrlock(&lcl_lock);
1431 if (setname || !lcl_is_set)
1432 tzset_unlocked();
1433 tmp = localsub(lclptr, timep, setname, tmp);
1434 rwlock_unlock(&lcl_lock);
1435 if (tmp == NULL)
1436 errno = EOVERFLOW;
1437 return tmp;
1438 }
1439
1440 struct tm *
1441 localtime(const time_t *const timep)
1442 {
1443 return localtime_tzset(timep, &tm, true);
1444 }
1445
1446 struct tm *
1447 localtime_r(const time_t * __restrict timep, struct tm *tmp)
1448 {
1449 return localtime_tzset(timep, tmp, false);
1450 }
1451
1452 /*
1453 ** gmtsub is to gmtime as localsub is to localtime.
1454 */
1455
1456 static struct tm *
1457 gmtsub(struct state const *sp, const time_t *timep, int_fast32_t offset,
1458 struct tm *tmp)
1459 {
1460 struct tm * result;
1461
1462 result = timesub(timep, offset, gmtptr, tmp);
1463 #ifdef TM_ZONE
1464 /*
1465 ** Could get fancy here and deliver something such as
1466 ** "UT+xxxx" or "UT-xxxx" if offset is non-zero,
1467 ** but this is no time for a treasure hunt.
1468 */
1469 if (result)
1470 result->TM_ZONE = offset ? __UNCONST(wildabbr) : gmtptr ?
1471 gmtptr->chars : __UNCONST(gmt);
1472 #endif /* defined TM_ZONE */
1473 return result;
1474 }
1475
1476 struct tm *
1477 gmtime(const time_t *const timep)
1478 {
1479 return gmtime_r(timep, &tm);
1480 }
1481
1482 /*
1483 ** Re-entrant version of gmtime.
1484 */
1485
1486 struct tm *
1487 gmtime_r(const time_t * const timep, struct tm *tmp)
1488 {
1489 gmtcheck();
1490 tmp = gmtsub(NULL, timep, 0, tmp);
1491
1492 if (tmp == NULL)
1493 errno = EOVERFLOW;
1494
1495 return tmp;
1496 }
1497
1498 #ifdef STD_INSPIRED
1499
1500 struct tm *
1501 offtime(const time_t *const timep, long offset)
1502 {
1503 struct tm *tmp;
1504
1505 gmtcheck();
1506 tmp = gmtsub(gmtptr, timep, (int_fast32_t)offset, &tm);
1507
1508 if (tmp == NULL)
1509 errno = EOVERFLOW;
1510
1511 return tmp;
1512 }
1513
1514 struct tm *
1515 offtime_r(const time_t *timep, long offset, struct tm *tmp)
1516 {
1517 gmtcheck();
1518 tmp = gmtsub(NULL, timep, (int_fast32_t)offset, tmp);
1519
1520 if (tmp == NULL)
1521 errno = EOVERFLOW;
1522
1523 return tmp;
1524 }
1525
1526 #endif /* defined STD_INSPIRED */
1527
1528 /*
1529 ** Return the number of leap years through the end of the given year
1530 ** where, to make the math easy, the answer for year zero is defined as zero.
1531 */
1532
1533 static int ATTRIBUTE_PURE
1534 leaps_thru_end_of(const int y)
1535 {
1536 return (y >= 0) ? (y / 4 - y / 100 + y / 400) :
1537 -(leaps_thru_end_of(-(y + 1)) + 1);
1538 }
1539
1540 static struct tm *
1541 timesub(time_t const *timep, int_fast32_t offset, struct state const *sp,
1542 struct tm *tmp)
1543 {
1544 const struct lsinfo * lp;
1545 time_t tdays;
1546 int idays; /* unsigned would be so 2003 */
1547 int_fast64_t rem;
1548 int y;
1549 const int * ip;
1550 int_fast64_t corr;
1551 bool hit;
1552 int i;
1553
1554 corr = 0;
1555 hit = false;
1556 i = (sp == NULL) ? 0 : sp->leapcnt;
1557 while (--i >= 0) {
1558 lp = &sp->lsis[i];
1559 if (*timep >= lp->ls_trans) {
1560 if (*timep == lp->ls_trans) {
1561 hit = ((i == 0 && lp->ls_corr > 0) ||
1562 lp->ls_corr > sp->lsis[i - 1].ls_corr);
1563 if (hit)
1564 while (i > 0 &&
1565 sp->lsis[i].ls_trans ==
1566 sp->lsis[i - 1].ls_trans + 1 &&
1567 sp->lsis[i].ls_corr ==
1568 sp->lsis[i - 1].ls_corr + 1) {
1569 ++hit;
1570 --i;
1571 }
1572 }
1573 corr = lp->ls_corr;
1574 break;
1575 }
1576 }
1577 y = EPOCH_YEAR;
1578 tdays = (time_t)(*timep / SECSPERDAY);
1579 rem = (int_fast64_t) (*timep - tdays * SECSPERDAY);
1580 while (tdays < 0 || tdays >= year_lengths[isleap(y)]) {
1581 int newy;
1582 time_t tdelta;
1583 int idelta;
1584 int leapdays;
1585
1586 tdelta = tdays / DAYSPERLYEAR;
1587 if (! ((! TYPE_SIGNED(time_t) || INT_MIN <= tdelta)
1588 && tdelta <= INT_MAX))
1589 goto overflow;
1590 _DIAGASSERT(__type_fit(int, tdelta));
1591 idelta = (int)tdelta;
1592 if (idelta == 0)
1593 idelta = (tdays < 0) ? -1 : 1;
1594 newy = y;
1595 if (increment_overflow(&newy, idelta))
1596 goto overflow;
1597 leapdays = leaps_thru_end_of(newy - 1) -
1598 leaps_thru_end_of(y - 1);
1599 tdays -= ((time_t) newy - y) * DAYSPERNYEAR;
1600 tdays -= leapdays;
1601 y = newy;
1602 }
1603 {
1604 int_fast32_t seconds;
1605
1606 seconds = (int_fast32_t)(tdays * SECSPERDAY);
1607 tdays = (time_t)(seconds / SECSPERDAY);
1608 rem += (int_fast64_t)(seconds - tdays * SECSPERDAY);
1609 }
1610 /*
1611 ** Given the range, we can now fearlessly cast...
1612 */
1613 idays = (int) tdays;
1614 rem += offset - corr;
1615 while (rem < 0) {
1616 rem += SECSPERDAY;
1617 --idays;
1618 }
1619 while (rem >= SECSPERDAY) {
1620 rem -= SECSPERDAY;
1621 ++idays;
1622 }
1623 while (idays < 0) {
1624 if (increment_overflow(&y, -1))
1625 goto overflow;
1626 idays += year_lengths[isleap(y)];
1627 }
1628 while (idays >= year_lengths[isleap(y)]) {
1629 idays -= year_lengths[isleap(y)];
1630 if (increment_overflow(&y, 1))
1631 goto overflow;
1632 }
1633 tmp->tm_year = y;
1634 if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE))
1635 return NULL;
1636 tmp->tm_yday = idays;
1637 /*
1638 ** The "extra" mods below avoid overflow problems.
1639 */
1640 tmp->tm_wday = EPOCH_WDAY +
1641 ((y - EPOCH_YEAR) % DAYSPERWEEK) *
1642 (DAYSPERNYEAR % DAYSPERWEEK) +
1643 leaps_thru_end_of(y - 1) -
1644 leaps_thru_end_of(EPOCH_YEAR - 1) +
1645 idays;
1646 tmp->tm_wday %= DAYSPERWEEK;
1647 if (tmp->tm_wday < 0)
1648 tmp->tm_wday += DAYSPERWEEK;
1649 tmp->tm_hour = (int) (rem / SECSPERHOUR);
1650 rem %= SECSPERHOUR;
1651 tmp->tm_min = (int) (rem / SECSPERMIN);
1652 /*
1653 ** A positive leap second requires a special
1654 ** representation. This uses "... ??:59:60" et seq.
1655 */
1656 tmp->tm_sec = (int) (rem % SECSPERMIN) + hit;
1657 ip = mon_lengths[isleap(y)];
1658 for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon))
1659 idays -= ip[tmp->tm_mon];
1660 tmp->tm_mday = (int) (idays + 1);
1661 tmp->tm_isdst = 0;
1662 #ifdef TM_GMTOFF
1663 tmp->TM_GMTOFF = offset;
1664 #endif /* defined TM_GMTOFF */
1665 return tmp;
1666 overflow:
1667 errno = EOVERFLOW;
1668 return NULL;
1669 }
1670
1671 char *
1672 ctime(const time_t *const timep)
1673 {
1674 /*
1675 ** Section 4.12.3.2 of X3.159-1989 requires that
1676 ** The ctime function converts the calendar time pointed to by timer
1677 ** to local time in the form of a string. It is equivalent to
1678 ** asctime(localtime(timer))
1679 */
1680 struct tm *rtm = localtime(timep);
1681 if (rtm == NULL)
1682 return NULL;
1683 return asctime(rtm);
1684 }
1685
1686 char *
1687 ctime_r(const time_t *const timep, char *buf)
1688 {
1689 struct tm mytm, *rtm;
1690
1691 rtm = localtime_r(timep, &mytm);
1692 if (rtm == NULL)
1693 return NULL;
1694 return asctime_r(rtm, buf);
1695 }
1696
1697 char *
1698 ctime_rz(const timezone_t sp, const time_t * timep, char *buf)
1699 {
1700 struct tm mytm, *rtm;
1701
1702 rtm = localtime_rz(sp, timep, &mytm);
1703 if (rtm == NULL)
1704 return NULL;
1705 return asctime_r(rtm, buf);
1706 }
1707
1708 /*
1709 ** Adapted from code provided by Robert Elz, who writes:
1710 ** The "best" way to do mktime I think is based on an idea of Bob
1711 ** Kridle's (so its said...) from a long time ago.
1712 ** It does a binary search of the time_t space. Since time_t's are
1713 ** just 32 bits, its a max of 32 iterations (even at 64 bits it
1714 ** would still be very reasonable).
1715 */
1716
1717 #ifndef WRONG
1718 #define WRONG ((time_t)-1)
1719 #endif /* !defined WRONG */
1720
1721 /*
1722 ** Normalize logic courtesy Paul Eggert.
1723 */
1724
1725 static bool
1726 increment_overflow(int *const ip, int j)
1727 {
1728 int const i = *ip;
1729
1730 /*
1731 ** If i >= 0 there can only be overflow if i + j > INT_MAX
1732 ** or if j > INT_MAX - i; given i >= 0, INT_MAX - i cannot overflow.
1733 ** If i < 0 there can only be overflow if i + j < INT_MIN
1734 ** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow.
1735 */
1736 if ((i >= 0) ? (j > INT_MAX - i) : (j < INT_MIN - i))
1737 return true;
1738 *ip += j;
1739 return false;
1740 }
1741
1742 static bool
1743 increment_overflow32(int_fast32_t *const lp, int const m)
1744 {
1745 int_fast32_t const l = *lp;
1746
1747 if ((l >= 0) ? (m > INT_FAST32_MAX - l) : (m < INT_FAST32_MIN - l))
1748 return true;
1749 *lp += m;
1750 return false;
1751 }
1752
1753 static bool
1754 increment_overflow_time(time_t *tp, int_fast32_t j)
1755 {
1756 /*
1757 ** This is like
1758 ** 'if (! (time_t_min <= *tp + j && *tp + j <= time_t_max)) ...',
1759 ** except that it does the right thing even if *tp + j would overflow.
1760 */
1761 if (! (j < 0
1762 ? (TYPE_SIGNED(time_t) ? time_t_min - j <= *tp : -1 - j < *tp)
1763 : *tp <= time_t_max - j))
1764 return true;
1765 *tp += j;
1766 return false;
1767 }
1768
1769 static bool
1770 normalize_overflow(int *const tensptr, int *const unitsptr, const int base)
1771 {
1772 int tensdelta;
1773
1774 tensdelta = (*unitsptr >= 0) ?
1775 (*unitsptr / base) :
1776 (-1 - (-1 - *unitsptr) / base);
1777 *unitsptr -= tensdelta * base;
1778 return increment_overflow(tensptr, tensdelta);
1779 }
1780
1781 static bool
1782 normalize_overflow32(int_fast32_t *const tensptr, int *const unitsptr,
1783 const int base)
1784 {
1785 int tensdelta;
1786
1787 tensdelta = (*unitsptr >= 0) ?
1788 (*unitsptr / base) :
1789 (-1 - (-1 - *unitsptr) / base);
1790 *unitsptr -= tensdelta * base;
1791 return increment_overflow32(tensptr, tensdelta);
1792 }
1793
1794 static int
1795 tmcomp(const struct tm *const atmp,
1796 const struct tm *const btmp)
1797 {
1798 int result;
1799
1800 if (atmp->tm_year != btmp->tm_year)
1801 return atmp->tm_year < btmp->tm_year ? -1 : 1;
1802 if ((result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
1803 (result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
1804 (result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
1805 (result = (atmp->tm_min - btmp->tm_min)) == 0)
1806 result = atmp->tm_sec - btmp->tm_sec;
1807 return result;
1808 }
1809
1810 static time_t
1811 time2sub(struct tm *const tmp,
1812 struct tm *(*funcp)(struct state const *, time_t const *,
1813 int_fast32_t, struct tm *),
1814 struct state const *sp,
1815 const int_fast32_t offset,
1816 bool *okayp,
1817 bool do_norm_secs)
1818 {
1819 int dir;
1820 int i, j;
1821 int saved_seconds;
1822 int_fast32_t li;
1823 time_t lo;
1824 time_t hi;
1825 #ifdef NO_ERROR_IN_DST_GAP
1826 time_t ilo;
1827 #endif
1828 int_fast32_t y;
1829 time_t newt;
1830 time_t t;
1831 struct tm yourtm, mytm;
1832
1833 *okayp = false;
1834 yourtm = *tmp;
1835 #ifdef NO_ERROR_IN_DST_GAP
1836 again:
1837 #endif
1838 if (do_norm_secs) {
1839 if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec,
1840 SECSPERMIN))
1841 goto overflow;
1842 }
1843 if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR))
1844 goto overflow;
1845 if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY))
1846 goto overflow;
1847 y = yourtm.tm_year;
1848 if (normalize_overflow32(&y, &yourtm.tm_mon, MONSPERYEAR))
1849 goto overflow;
1850 /*
1851 ** Turn y into an actual year number for now.
1852 ** It is converted back to an offset from TM_YEAR_BASE later.
1853 */
1854 if (increment_overflow32(&y, TM_YEAR_BASE))
1855 goto overflow;
1856 while (yourtm.tm_mday <= 0) {
1857 if (increment_overflow32(&y, -1))
1858 goto overflow;
1859 li = y + (1 < yourtm.tm_mon);
1860 yourtm.tm_mday += year_lengths[isleap(li)];
1861 }
1862 while (yourtm.tm_mday > DAYSPERLYEAR) {
1863 li = y + (1 < yourtm.tm_mon);
1864 yourtm.tm_mday -= year_lengths[isleap(li)];
1865 if (increment_overflow32(&y, 1))
1866 goto overflow;
1867 }
1868 for ( ; ; ) {
1869 i = mon_lengths[isleap(y)][yourtm.tm_mon];
1870 if (yourtm.tm_mday <= i)
1871 break;
1872 yourtm.tm_mday -= i;
1873 if (++yourtm.tm_mon >= MONSPERYEAR) {
1874 yourtm.tm_mon = 0;
1875 if (increment_overflow32(&y, 1))
1876 goto overflow;
1877 }
1878 }
1879 if (increment_overflow32(&y, -TM_YEAR_BASE))
1880 goto overflow;
1881 if (! (INT_MIN <= y && y <= INT_MAX))
1882 goto overflow;
1883 yourtm.tm_year = (int)y;
1884 if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN)
1885 saved_seconds = 0;
1886 else if (y + TM_YEAR_BASE < EPOCH_YEAR) {
1887 /*
1888 ** We can't set tm_sec to 0, because that might push the
1889 ** time below the minimum representable time.
1890 ** Set tm_sec to 59 instead.
1891 ** This assumes that the minimum representable time is
1892 ** not in the same minute that a leap second was deleted from,
1893 ** which is a safer assumption than using 58 would be.
1894 */
1895 if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN))
1896 goto overflow;
1897 saved_seconds = yourtm.tm_sec;
1898 yourtm.tm_sec = SECSPERMIN - 1;
1899 } else {
1900 saved_seconds = yourtm.tm_sec;
1901 yourtm.tm_sec = 0;
1902 }
1903 /*
1904 ** Do a binary search (this works whatever time_t's type is).
1905 */
1906 /* LINTED const not */
1907 if (!TYPE_SIGNED(time_t)) {
1908 lo = 0;
1909 hi = lo - 1;
1910 } else {
1911 lo = 1;
1912 for (i = 0; i < (int) TYPE_BIT(time_t) - 1; ++i)
1913 lo *= 2;
1914 hi = -(lo + 1);
1915 }
1916 #ifdef NO_ERROR_IN_DST_GAP
1917 ilo = lo;
1918 #endif
1919 for ( ; ; ) {
1920 t = lo / 2 + hi / 2;
1921 if (t < lo)
1922 t = lo;
1923 else if (t > hi)
1924 t = hi;
1925 if (! funcp(sp, &t, offset, &mytm)) {
1926 /*
1927 ** Assume that t is too extreme to be represented in
1928 ** a struct tm; arrange things so that it is less
1929 ** extreme on the next pass.
1930 */
1931 dir = (t > 0) ? 1 : -1;
1932 } else dir = tmcomp(&mytm, &yourtm);
1933 if (dir != 0) {
1934 if (t == lo) {
1935 if (t == time_t_max)
1936 goto overflow;
1937 ++t;
1938 ++lo;
1939 } else if (t == hi) {
1940 if (t == time_t_min)
1941 goto overflow;
1942 --t;
1943 --hi;
1944 }
1945 #ifdef NO_ERROR_IN_DST_GAP
1946 if (ilo != lo && lo - 1 == hi && yourtm.tm_isdst < 0 &&
1947 do_norm_secs) {
1948 for (i = sp->typecnt - 1; i >= 0; --i) {
1949 for (j = sp->typecnt - 1; j >= 0; --j) {
1950 time_t off;
1951 if (sp->ttis[j].tt_isdst ==
1952 sp->ttis[i].tt_isdst)
1953 continue;
1954 off = sp->ttis[j].tt_gmtoff -
1955 sp->ttis[i].tt_gmtoff;
1956 yourtm.tm_sec += off < 0 ?
1957 -off : off;
1958 goto again;
1959 }
1960 }
1961 }
1962 #endif
1963 if (lo > hi)
1964 goto invalid;
1965 if (dir > 0)
1966 hi = t;
1967 else lo = t;
1968 continue;
1969 }
1970 #if defined TM_GMTOFF && ! UNINIT_TRAP
1971 if (mytm.TM_GMTOFF != yourtm.TM_GMTOFF
1972 && (yourtm.TM_GMTOFF < 0
1973 ? (-SECSPERDAY <= yourtm.TM_GMTOFF
1974 && (mytm.TM_GMTOFF <=
1975 (/*CONSTCOND*/SMALLEST (INT_FAST32_MAX, LONG_MAX)
1976 + yourtm.TM_GMTOFF)))
1977 : (yourtm.TM_GMTOFF <= SECSPERDAY
1978 && ((/*CONSTCOND*/BIGGEST (INT_FAST32_MIN, LONG_MIN)
1979 + yourtm.TM_GMTOFF)
1980 <= mytm.TM_GMTOFF)))) {
1981 /* MYTM matches YOURTM except with the wrong UTC offset.
1982 YOURTM.TM_GMTOFF is plausible, so try it instead.
1983 It's OK if YOURTM.TM_GMTOFF contains uninitialized data,
1984 since the guess gets checked. */
1985 time_t altt = t;
1986 int_fast32_t diff = (int_fast32_t)
1987 (mytm.TM_GMTOFF - yourtm.TM_GMTOFF);
1988 if (!increment_overflow_time(&altt, diff)) {
1989 struct tm alttm;
1990 if (! funcp(sp, &altt, offset, &alttm)
1991 && alttm.tm_isdst == mytm.tm_isdst
1992 && alttm.TM_GMTOFF == yourtm.TM_GMTOFF
1993 && tmcomp(&alttm, &yourtm)) {
1994 t = altt;
1995 mytm = alttm;
1996 }
1997 }
1998 }
1999 #endif
2000 if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
2001 break;
2002 /*
2003 ** Right time, wrong type.
2004 ** Hunt for right time, right type.
2005 ** It's okay to guess wrong since the guess
2006 ** gets checked.
2007 */
2008 if (sp == NULL)
2009 goto invalid;
2010 for (i = sp->typecnt - 1; i >= 0; --i) {
2011 if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
2012 continue;
2013 for (j = sp->typecnt - 1; j >= 0; --j) {
2014 if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
2015 continue;
2016 newt = (time_t)(t + sp->ttis[j].tt_gmtoff -
2017 sp->ttis[i].tt_gmtoff);
2018 if (! funcp(sp, &newt, offset, &mytm))
2019 continue;
2020 if (tmcomp(&mytm, &yourtm) != 0)
2021 continue;
2022 if (mytm.tm_isdst != yourtm.tm_isdst)
2023 continue;
2024 /*
2025 ** We have a match.
2026 */
2027 t = newt;
2028 goto label;
2029 }
2030 }
2031 goto invalid;
2032 }
2033 label:
2034 newt = t + saved_seconds;
2035 if ((newt < t) != (saved_seconds < 0))
2036 goto overflow;
2037 t = newt;
2038 if (funcp(sp, &t, offset, tmp)) {
2039 *okayp = true;
2040 return t;
2041 }
2042 overflow:
2043 errno = EOVERFLOW;
2044 return WRONG;
2045 invalid:
2046 errno = EINVAL;
2047 return WRONG;
2048 }
2049
2050 static time_t
2051 time2(struct tm * const tmp,
2052 struct tm *(*funcp)(struct state const *, time_t const *,
2053 int_fast32_t, struct tm *),
2054 struct state const *sp,
2055 const int_fast32_t offset,
2056 bool *okayp)
2057 {
2058 time_t t;
2059
2060 /*
2061 ** First try without normalization of seconds
2062 ** (in case tm_sec contains a value associated with a leap second).
2063 ** If that fails, try with normalization of seconds.
2064 */
2065 t = time2sub(tmp, funcp, sp, offset, okayp, false);
2066 return *okayp ? t : time2sub(tmp, funcp, sp, offset, okayp, true);
2067 }
2068
2069 static time_t
2070 time1(struct tm *const tmp,
2071 struct tm *(*funcp) (struct state const *, time_t const *,
2072 int_fast32_t, struct tm *),
2073 struct state const *sp,
2074 const int_fast32_t offset)
2075 {
2076 time_t t;
2077 int samei, otheri;
2078 int sameind, otherind;
2079 int i;
2080 int nseen;
2081 char seen[TZ_MAX_TYPES];
2082 unsigned char types[TZ_MAX_TYPES];
2083 bool okay;
2084
2085 if (tmp == NULL) {
2086 errno = EINVAL;
2087 return WRONG;
2088 }
2089 if (tmp->tm_isdst > 1)
2090 tmp->tm_isdst = 1;
2091 t = time2(tmp, funcp, sp, offset, &okay);
2092 if (okay)
2093 return t;
2094 if (tmp->tm_isdst < 0)
2095 #ifdef PCTS
2096 /*
2097 ** POSIX Conformance Test Suite code courtesy Grant Sullivan.
2098 */
2099 tmp->tm_isdst = 0; /* reset to std and try again */
2100 #else
2101 return t;
2102 #endif /* !defined PCTS */
2103 /*
2104 ** We're supposed to assume that somebody took a time of one type
2105 ** and did some math on it that yielded a "struct tm" that's bad.
2106 ** We try to divine the type they started from and adjust to the
2107 ** type they need.
2108 */
2109 if (sp == NULL) {
2110 errno = EINVAL;
2111 return WRONG;
2112 }
2113 for (i = 0; i < sp->typecnt; ++i)
2114 seen[i] = false;
2115 nseen = 0;
2116 for (i = sp->timecnt - 1; i >= 0; --i)
2117 if (!seen[sp->types[i]]) {
2118 seen[sp->types[i]] = true;
2119 types[nseen++] = sp->types[i];
2120 }
2121 for (sameind = 0; sameind < nseen; ++sameind) {
2122 samei = types[sameind];
2123 if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
2124 continue;
2125 for (otherind = 0; otherind < nseen; ++otherind) {
2126 otheri = types[otherind];
2127 if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
2128 continue;
2129 tmp->tm_sec += (int)(sp->ttis[otheri].tt_gmtoff -
2130 sp->ttis[samei].tt_gmtoff);
2131 tmp->tm_isdst = !tmp->tm_isdst;
2132 t = time2(tmp, funcp, sp, offset, &okay);
2133 if (okay)
2134 return t;
2135 tmp->tm_sec -= (int)(sp->ttis[otheri].tt_gmtoff -
2136 sp->ttis[samei].tt_gmtoff);
2137 tmp->tm_isdst = !tmp->tm_isdst;
2138 }
2139 }
2140 errno = EOVERFLOW;
2141 return WRONG;
2142 }
2143
2144 static time_t
2145 mktime_tzname(timezone_t sp, struct tm *tmp, bool setname)
2146 {
2147 if (sp)
2148 return time1(tmp, localsub, sp, setname);
2149 else {
2150 gmtcheck();
2151 return time1(tmp, gmtsub, gmtptr, 0);
2152 }
2153 }
2154
2155 #if NETBSD_INSPIRED
2156
2157 time_t
2158 mktime_z(timezone_t sp, struct tm *const tmp)
2159 {
2160 return mktime_tzname(sp, tmp, false);
2161 }
2162
2163 #endif
2164
2165 time_t
2166 mktime(struct tm *const tmp)
2167 {
2168 time_t t;
2169
2170 rwlock_wrlock(&lcl_lock);
2171 tzset_unlocked();
2172 t = mktime_tzname(lclptr, tmp, true);
2173 rwlock_unlock(&lcl_lock);
2174 return t;
2175 }
2176
2177 #ifdef STD_INSPIRED
2178
2179 time_t
2180 timelocal_z(const timezone_t sp, struct tm *const tmp)
2181 {
2182 if (tmp != NULL)
2183 tmp->tm_isdst = -1; /* in case it wasn't initialized */
2184 return mktime_z(sp, tmp);
2185 }
2186
2187 time_t
2188 timelocal(struct tm *const tmp)
2189 {
2190 if (tmp != NULL)
2191 tmp->tm_isdst = -1; /* in case it wasn't initialized */
2192 return mktime(tmp);
2193 }
2194
2195 time_t
2196 timegm(struct tm *const tmp)
2197 {
2198
2199 return timeoff(tmp, 0);
2200 }
2201
2202 time_t
2203 timeoff(struct tm *const tmp, long offset)
2204 {
2205 if (tmp)
2206 tmp->tm_isdst = 0;
2207 gmtcheck();
2208 return time1(tmp, gmtsub, gmtptr, (int_fast32_t)offset);
2209 }
2210
2211 #endif /* defined STD_INSPIRED */
2212
2213 /*
2214 ** XXX--is the below the right way to conditionalize??
2215 */
2216
2217 #ifdef STD_INSPIRED
2218
2219 /*
2220 ** IEEE Std 1003.1-1988 (POSIX) legislates that 536457599
2221 ** shall correspond to "Wed Dec 31 23:59:59 UTC 1986", which
2222 ** is not the case if we are accounting for leap seconds.
2223 ** So, we provide the following conversion routines for use
2224 ** when exchanging timestamps with POSIX conforming systems.
2225 */
2226
2227 static int_fast64_t
2228 leapcorr(const timezone_t sp, time_t t)
2229 {
2230 struct lsinfo const * lp;
2231 int i;
2232
2233 i = sp->leapcnt;
2234 while (--i >= 0) {
2235 lp = &sp->lsis[i];
2236 if (t >= lp->ls_trans)
2237 return lp->ls_corr;
2238 }
2239 return 0;
2240 }
2241
2242 NETBSD_INSPIRED_EXTERN time_t ATTRIBUTE_PURE
2243 time2posix_z(timezone_t sp, time_t t)
2244 {
2245 return (time_t)(t - leapcorr(sp, t));
2246 }
2247
2248 time_t
2249 time2posix(time_t t)
2250 {
2251 rwlock_wrlock(&lcl_lock);
2252 if (!lcl_is_set)
2253 tzset_unlocked();
2254 if (lclptr)
2255 t = (time_t)(t - leapcorr(lclptr, t));
2256 rwlock_unlock(&lcl_lock);
2257 return t;
2258 }
2259
2260 NETBSD_INSPIRED_EXTERN time_t ATTRIBUTE_PURE
2261 posix2time_z(timezone_t sp, time_t t)
2262 {
2263 time_t x;
2264 time_t y;
2265
2266 /*
2267 ** For a positive leap second hit, the result
2268 ** is not unique. For a negative leap second
2269 ** hit, the corresponding time doesn't exist,
2270 ** so we return an adjacent second.
2271 */
2272 x = (time_t)(t + leapcorr(sp, t));
2273 y = (time_t)(x - leapcorr(sp, x));
2274 if (y < t) {
2275 do {
2276 x++;
2277 y = (time_t)(x - leapcorr(sp, x));
2278 } while (y < t);
2279 x -= y != t;
2280 } else if (y > t) {
2281 do {
2282 --x;
2283 y = (time_t)(x - leapcorr(sp, x));
2284 } while (y > t);
2285 x += y != t;
2286 }
2287 return x;
2288 }
2289
2290 time_t
2291 posix2time(time_t t)
2292 {
2293 rwlock_wrlock(&lcl_lock);
2294 if (!lcl_is_set)
2295 tzset_unlocked();
2296 if (lclptr)
2297 t = posix2time_z(lclptr, t);
2298 rwlock_unlock(&lcl_lock);
2299 return t;
2300 }
2301
2302 #endif /* defined STD_INSPIRED */
2303