1 /* Convert timestamp from time_t to struct tm. */ 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 /* 9 ** Leap second handling from Bradley White. 10 ** POSIX-style TZ environment variable handling from Guy Harris. 11 */ 12 13 /*LINTLIBRARY*/ 14 15 #define LOCALTIME_IMPLEMENTATION 16 #include "namespace.h" 17 #ifdef DETECT_TZ_CHANGES 18 #ifndef DETECT_TZ_CHANGES_INTERVAL 19 #define DETECT_TZ_CHANGES_INTERVAL 61 20 #endif 21 #include <sys/stat.h> 22 #endif 23 #include <fcntl.h> 24 #if THREAD_SAFE 25 #include <pthread.h> 26 #endif 27 #include "private.h" 28 #include "un-namespace.h" 29 30 #include "tzfile.h" 31 32 #include "libc_private.h" 33 34 #if defined THREAD_SAFE && THREAD_SAFE 35 static pthread_mutex_t locallock = PTHREAD_MUTEX_INITIALIZER; 36 static int lock(void) { 37 if (__isthreaded) 38 return _pthread_mutex_lock(&locallock); 39 return 0; 40 } 41 static void unlock(void) { 42 if (__isthreaded) 43 _pthread_mutex_unlock(&locallock); 44 } 45 #else 46 static int lock(void) { return 0; } 47 static void unlock(void) { } 48 #endif 49 50 #ifndef TZ_ABBR_MAX_LEN 51 # define TZ_ABBR_MAX_LEN 16 52 #endif /* !defined TZ_ABBR_MAX_LEN */ 53 54 #ifndef TZ_ABBR_CHAR_SET 55 # define TZ_ABBR_CHAR_SET \ 56 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._" 57 #endif /* !defined TZ_ABBR_CHAR_SET */ 58 59 #ifndef TZ_ABBR_ERR_CHAR 60 # define TZ_ABBR_ERR_CHAR '_' 61 #endif /* !defined TZ_ABBR_ERR_CHAR */ 62 63 /* 64 ** Support non-POSIX platforms that distinguish between text and binary files. 65 */ 66 67 #ifndef O_BINARY 68 # define O_BINARY 0 69 #endif 70 71 #ifndef WILDABBR 72 /* 73 ** Someone might make incorrect use of a time zone abbreviation: 74 ** 1. They might reference tzname[0] before calling tzset (explicitly 75 ** or implicitly). 76 ** 2. They might reference tzname[1] before calling tzset (explicitly 77 ** or implicitly). 78 ** 3. They might reference tzname[1] after setting to a time zone 79 ** in which Daylight Saving Time is never observed. 80 ** 4. They might reference tzname[0] after setting to a time zone 81 ** in which Standard Time is never observed. 82 ** 5. They might reference tm.TM_ZONE after calling offtime. 83 ** What's best to do in the above cases is open to debate; 84 ** for now, we just set things up so that in any of the five cases 85 ** WILDABBR is used. Another possibility: initialize tzname[0] to the 86 ** string "tzname[0] used before set", and similarly for the other cases. 87 ** And another: initialize tzname[0] to "ERA", with an explanation in the 88 ** manual page of what this "time zone abbreviation" means (doing this so 89 ** that tzname[0] has the "normal" length of three characters). 90 */ 91 # define WILDABBR " " 92 #endif /* !defined WILDABBR */ 93 94 static const char wildabbr[] = WILDABBR; 95 96 static char const etc_utc[] = "Etc/UTC"; 97 static char const *utc = etc_utc + sizeof "Etc/" - 1; 98 99 /* 100 ** The DST rules to use if TZ has no rules and we can't load TZDEFRULES. 101 ** Default to US rules as of 2017-05-07. 102 ** POSIX does not specify the default DST rules; 103 ** for historical reasons, US rules are a common default. 104 */ 105 #ifndef TZDEFRULESTRING 106 # define TZDEFRULESTRING ",M3.2.0,M11.1.0" 107 #endif 108 109 struct ttinfo { /* time type information */ 110 int_fast32_t tt_utoff; /* UT offset in seconds */ 111 bool tt_isdst; /* used to set tm_isdst */ 112 int tt_desigidx; /* abbreviation list index */ 113 bool tt_ttisstd; /* transition is std time */ 114 bool tt_ttisut; /* transition is UT */ 115 }; 116 117 struct lsinfo { /* leap second information */ 118 time_t ls_trans; /* transition time */ 119 int_fast32_t ls_corr; /* correction to apply */ 120 }; 121 122 /* This abbreviation means local time is unspecified. */ 123 static char const UNSPEC[] = "-00"; 124 125 /* How many extra bytes are needed at the end of struct state's chars array. 126 This needs to be at least 1 for null termination in case the input 127 data isn't properly terminated, and it also needs to be big enough 128 for ttunspecified to work without crashing. */ 129 enum { CHARS_EXTRA = max(sizeof UNSPEC, 2) - 1 }; 130 131 #ifdef TZNAME_MAX 132 # define MY_TZNAME_MAX TZNAME_MAX 133 #endif /* defined TZNAME_MAX */ 134 #ifndef TZNAME_MAX 135 # define MY_TZNAME_MAX 255 136 #endif /* !defined TZNAME_MAX */ 137 138 struct state { 139 int leapcnt; 140 int timecnt; 141 int typecnt; 142 int charcnt; 143 bool goback; 144 bool goahead; 145 time_t ats[TZ_MAX_TIMES]; 146 unsigned char types[TZ_MAX_TIMES]; 147 struct ttinfo ttis[TZ_MAX_TYPES]; 148 char chars[max(max(TZ_MAX_CHARS + CHARS_EXTRA, sizeof "UTC"), 149 2 * (MY_TZNAME_MAX + 1))]; 150 struct lsinfo lsis[TZ_MAX_LEAPS]; 151 152 /* The time type to use for early times or if no transitions. 153 It is always zero for recent tzdb releases. 154 It might be nonzero for data from tzdb 2018e or earlier. */ 155 int defaulttype; 156 }; 157 158 enum r_type { 159 JULIAN_DAY, /* Jn = Julian day */ 160 DAY_OF_YEAR, /* n = day of year */ 161 MONTH_NTH_DAY_OF_WEEK /* Mm.n.d = month, week, day of week */ 162 }; 163 164 struct rule { 165 enum r_type r_type; /* type of rule */ 166 int r_day; /* day number of rule */ 167 int r_week; /* week number of rule */ 168 int r_mon; /* month number of rule */ 169 int_fast32_t r_time; /* transition time of rule */ 170 }; 171 172 static struct tm *gmtsub(struct state const *, time_t const *, int_fast32_t, 173 struct tm *); 174 static bool increment_overflow(int *, int); 175 static bool increment_overflow_time(time_t *, int_fast32_t); 176 static int_fast32_t leapcorr(struct state const *, time_t); 177 static bool normalize_overflow32(int_fast32_t *, int *, int); 178 static struct tm *timesub(time_t const *, int_fast32_t, struct state const *, 179 struct tm *); 180 static bool typesequiv(struct state const *, int, int); 181 static bool tzparse(char const *, struct state *, struct state *); 182 183 #ifdef ALL_STATE 184 static struct state * lclptr; 185 static struct state * gmtptr; 186 #endif /* defined ALL_STATE */ 187 188 #ifndef ALL_STATE 189 static struct state lclmem; 190 static struct state gmtmem; 191 static struct state *const lclptr = &lclmem; 192 static struct state *const gmtptr = &gmtmem; 193 #endif /* State Farm */ 194 195 #ifndef TZ_STRLEN_MAX 196 # define TZ_STRLEN_MAX 255 197 #endif /* !defined TZ_STRLEN_MAX */ 198 199 static char lcl_TZname[TZ_STRLEN_MAX + 1]; 200 static int lcl_is_set; 201 202 static pthread_once_t gmt_once = PTHREAD_ONCE_INIT; 203 static pthread_once_t gmtime_once = PTHREAD_ONCE_INIT; 204 static pthread_key_t gmtime_key; 205 static int gmtime_key_error; 206 static pthread_once_t localtime_once = PTHREAD_ONCE_INIT; 207 static pthread_key_t localtime_key; 208 static int localtime_key_error; 209 210 /* 211 ** Section 4.12.3 of X3.159-1989 requires that 212 ** Except for the strftime function, these functions [asctime, 213 ** ctime, gmtime, localtime] return values in one of two static 214 ** objects: a broken-down time structure and an array of char. 215 ** Thanks to Paul Eggert for noting this. 216 */ 217 218 static struct tm tm; 219 220 #if 2 <= HAVE_TZNAME + TZ_TIME_T 221 char * tzname[2] = { 222 (char *) wildabbr, 223 (char *) wildabbr 224 }; 225 #endif 226 #if 2 <= USG_COMPAT + TZ_TIME_T 227 long timezone; 228 int daylight; 229 #endif 230 #if 2 <= ALTZONE + TZ_TIME_T 231 long altzone; 232 #endif 233 234 /* Initialize *S to a value based on UTOFF, ISDST, and DESIGIDX. */ 235 static void 236 init_ttinfo(struct ttinfo *s, int_fast32_t utoff, bool isdst, int desigidx) 237 { 238 s->tt_utoff = utoff; 239 s->tt_isdst = isdst; 240 s->tt_desigidx = desigidx; 241 s->tt_ttisstd = false; 242 s->tt_ttisut = false; 243 } 244 245 /* Return true if SP's time type I does not specify local time. */ 246 static bool 247 ttunspecified(struct state const *sp, int i) 248 { 249 char const *abbr = &sp->chars[sp->ttis[i].tt_desigidx]; 250 /* memcmp is likely faster than strcmp, and is safe due to CHARS_EXTRA. */ 251 return memcmp(abbr, UNSPEC, sizeof UNSPEC) == 0; 252 } 253 254 static int_fast32_t 255 detzcode(const char *const codep) 256 { 257 register int_fast32_t result; 258 register int i; 259 int_fast32_t one = 1; 260 int_fast32_t halfmaxval = one << (32 - 2); 261 int_fast32_t maxval = halfmaxval - 1 + halfmaxval; 262 int_fast32_t minval = -1 - maxval; 263 264 result = codep[0] & 0x7f; 265 for (i = 1; i < 4; ++i) 266 result = (result << 8) | (codep[i] & 0xff); 267 268 if (codep[0] & 0x80) { 269 /* Do two's-complement negation even on non-two's-complement machines. 270 If the result would be minval - 1, return minval. */ 271 result -= !TWOS_COMPLEMENT(int_fast32_t) && result != 0; 272 result += minval; 273 } 274 return result; 275 } 276 277 static int_fast64_t 278 detzcode64(const char *const codep) 279 { 280 register int_fast64_t result; 281 register int i; 282 int_fast64_t one = 1; 283 int_fast64_t halfmaxval = one << (64 - 2); 284 int_fast64_t maxval = halfmaxval - 1 + halfmaxval; 285 int_fast64_t minval = -TWOS_COMPLEMENT(int_fast64_t) - maxval; 286 287 result = codep[0] & 0x7f; 288 for (i = 1; i < 8; ++i) 289 result = (result << 8) | (codep[i] & 0xff); 290 291 if (codep[0] & 0x80) { 292 /* Do two's-complement negation even on non-two's-complement machines. 293 If the result would be minval - 1, return minval. */ 294 result -= !TWOS_COMPLEMENT(int_fast64_t) && result != 0; 295 result += minval; 296 } 297 return result; 298 } 299 300 static void 301 update_tzname_etc(struct state const *sp, struct ttinfo const *ttisp) 302 { 303 #if HAVE_TZNAME 304 tzname[ttisp->tt_isdst] = (char *) &sp->chars[ttisp->tt_desigidx]; 305 #endif 306 #if USG_COMPAT 307 if (!ttisp->tt_isdst) 308 timezone = - ttisp->tt_utoff; 309 #endif 310 #if ALTZONE 311 if (ttisp->tt_isdst) 312 altzone = - ttisp->tt_utoff; 313 #endif 314 } 315 316 /* If STDDST_MASK indicates that SP's TYPE provides useful info, 317 update tzname, timezone, and/or altzone and return STDDST_MASK, 318 diminished by the provided info if it is a specified local time. 319 Otherwise, return STDDST_MASK. See settzname for STDDST_MASK. */ 320 static int 321 may_update_tzname_etc(int stddst_mask, struct state *sp, int type) 322 { 323 struct ttinfo *ttisp = &sp->ttis[type]; 324 int this_bit = 1 << ttisp->tt_isdst; 325 if (stddst_mask & this_bit) { 326 update_tzname_etc(sp, ttisp); 327 if (!ttunspecified(sp, type)) 328 return stddst_mask & ~this_bit; 329 } 330 return stddst_mask; 331 } 332 333 static void 334 settzname(void) 335 { 336 register struct state * const sp = lclptr; 337 register int i; 338 339 /* If STDDST_MASK & 1 we need info about a standard time. 340 If STDDST_MASK & 2 we need info about a daylight saving time. 341 When STDDST_MASK becomes zero we can stop looking. */ 342 int stddst_mask = 0; 343 344 #if HAVE_TZNAME 345 tzname[0] = tzname[1] = (char *) (sp ? wildabbr : utc); 346 stddst_mask = 3; 347 #endif 348 #if USG_COMPAT 349 timezone = 0; 350 stddst_mask = 3; 351 #endif 352 #if ALTZONE 353 altzone = 0; 354 stddst_mask |= 2; 355 #endif 356 /* 357 ** And to get the latest time zone abbreviations into tzname. . . 358 */ 359 if (sp) { 360 for (i = sp->timecnt - 1; stddst_mask && 0 <= i; i--) 361 stddst_mask = may_update_tzname_etc(stddst_mask, sp, sp->types[i]); 362 for (i = sp->typecnt - 1; stddst_mask && 0 <= i; i--) 363 stddst_mask = may_update_tzname_etc(stddst_mask, sp, i); 364 } 365 #if USG_COMPAT 366 daylight = stddst_mask >> 1 ^ 1; 367 #endif 368 } 369 370 static void 371 scrub_abbrs(struct state *sp) 372 { 373 int i; 374 /* 375 ** First, replace bogus characters. 376 */ 377 for (i = 0; i < sp->charcnt; ++i) 378 if (strchr(TZ_ABBR_CHAR_SET, sp->chars[i]) == NULL) 379 sp->chars[i] = TZ_ABBR_ERR_CHAR; 380 /* 381 ** Second, truncate long abbreviations. 382 */ 383 for (i = 0; i < sp->typecnt; ++i) { 384 register const struct ttinfo * const ttisp = &sp->ttis[i]; 385 char *cp = &sp->chars[ttisp->tt_desigidx]; 386 387 if (strlen(cp) > TZ_ABBR_MAX_LEN && 388 strcmp(cp, GRANDPARENTED) != 0) 389 *(cp + TZ_ABBR_MAX_LEN) = '\0'; 390 } 391 } 392 393 #ifdef DETECT_TZ_CHANGES 394 /* 395 * Determine if there's a change in the timezone since the last time we checked. 396 * Returns: -1 on error 397 * 0 if the timezone has not changed 398 * 1 if the timezone has changed 399 */ 400 static int 401 change_in_tz(const char *name) 402 { 403 static char old_name[PATH_MAX]; 404 static struct stat old_sb; 405 struct stat sb; 406 int error; 407 408 error = stat(name, &sb); 409 if (error != 0) 410 return -1; 411 412 if (strcmp(name, old_name) != 0) { 413 strlcpy(old_name, name, sizeof(old_name)); 414 old_sb = sb; 415 return 1; 416 } 417 418 if (sb.st_dev != old_sb.st_dev || 419 sb.st_ino != old_sb.st_ino || 420 sb.st_ctime != old_sb.st_ctime || 421 sb.st_mtime != old_sb.st_mtime) { 422 old_sb = sb; 423 return 1; 424 } 425 426 return 0; 427 } 428 #else /* !DETECT_TZ_CHANGES */ 429 #define change_in_tz(X) 1 430 #endif /* !DETECT_TZ_CHANGES */ 431 432 /* Input buffer for data read from a compiled tz file. */ 433 union input_buffer { 434 /* The first part of the buffer, interpreted as a header. */ 435 struct tzhead tzhead; 436 437 /* The entire buffer. */ 438 char buf[2 * sizeof(struct tzhead) + 2 * sizeof(struct state) 439 + 4 * TZ_MAX_TIMES]; 440 }; 441 442 /* TZDIR with a trailing '/' rather than a trailing '\0'. */ 443 static char const tzdirslash[sizeof TZDIR] = TZDIR "/"; 444 445 /* Local storage needed for 'tzloadbody'. */ 446 union local_storage { 447 /* The results of analyzing the file's contents after it is opened. */ 448 struct file_analysis { 449 /* The input buffer. */ 450 union input_buffer u; 451 452 /* A temporary state used for parsing a TZ string in the file. */ 453 struct state st; 454 } u; 455 456 /* The file name to be opened. */ 457 char fullname[max(sizeof(struct file_analysis), sizeof tzdirslash + 1024)]; 458 }; 459 460 /* Load tz data from the file named NAME into *SP. Read extended 461 format if DOEXTEND. Use *LSP for temporary storage. Return 0 on 462 success, an errno value on failure. */ 463 static int 464 tzloadbody(char const *name, struct state *sp, bool doextend, 465 union local_storage *lsp) 466 { 467 register int i; 468 register int fid; 469 register int stored; 470 register ssize_t nread; 471 register union input_buffer *up = &lsp->u.u; 472 register int tzheadsize = sizeof(struct tzhead); 473 474 sp->goback = sp->goahead = false; 475 476 if (! name) { 477 name = TZDEFAULT; 478 if (! name) 479 return EINVAL; 480 } 481 482 if (name[0] == ':') 483 ++name; 484 if (name[0] != '/') { 485 if (sizeof lsp->fullname - sizeof tzdirslash <= strlen(name)) 486 return ENAMETOOLONG; 487 488 /* Create a string "TZDIR/NAME". Using sprintf here 489 would pull in stdio (and would fail if the 490 resulting string length exceeded INT_MAX!). */ 491 memcpy(lsp->fullname, tzdirslash, sizeof tzdirslash); 492 strcpy(lsp->fullname + sizeof tzdirslash, name); 493 494 name = lsp->fullname; 495 } 496 if (doextend) { 497 /* 498 * Detect if the timezone file has changed. Check 499 * 'doextend' to ignore TZDEFRULES; the change_in_tz() 500 * function can only keep state for a single file. 501 */ 502 int ret = change_in_tz(name); 503 if (ret <= 0) { 504 /* 505 * Returns an errno value if there was an error, 506 * and 0 if the timezone had not changed. 507 */ 508 return errno; 509 } 510 } 511 fid = _open(name, O_RDONLY | O_BINARY); 512 if (fid < 0) 513 return errno; 514 515 nread = _read(fid, up->buf, sizeof up->buf); 516 if (nread < tzheadsize) { 517 int err = nread < 0 ? errno : EINVAL; 518 _close(fid); 519 return err; 520 } 521 if (_close(fid) < 0) 522 return errno; 523 for (stored = 4; stored <= 8; stored *= 2) { 524 char version = up->tzhead.tzh_version[0]; 525 bool skip_datablock = stored == 4 && version; 526 int_fast32_t datablock_size; 527 int_fast32_t ttisstdcnt = detzcode(up->tzhead.tzh_ttisstdcnt); 528 int_fast32_t ttisutcnt = detzcode(up->tzhead.tzh_ttisutcnt); 529 int_fast64_t prevtr = -1; 530 int_fast32_t prevcorr; 531 int_fast32_t leapcnt = detzcode(up->tzhead.tzh_leapcnt); 532 int_fast32_t timecnt = detzcode(up->tzhead.tzh_timecnt); 533 int_fast32_t typecnt = detzcode(up->tzhead.tzh_typecnt); 534 int_fast32_t charcnt = detzcode(up->tzhead.tzh_charcnt); 535 char const *p = up->buf + tzheadsize; 536 /* Although tzfile(5) currently requires typecnt to be nonzero, 537 support future formats that may allow zero typecnt 538 in files that have a TZ string and no transitions. */ 539 if (! (0 <= leapcnt && leapcnt < TZ_MAX_LEAPS 540 && 0 <= typecnt && typecnt < TZ_MAX_TYPES 541 && 0 <= timecnt && timecnt < TZ_MAX_TIMES 542 && 0 <= charcnt && charcnt < TZ_MAX_CHARS 543 && 0 <= ttisstdcnt && ttisstdcnt < TZ_MAX_TYPES 544 && 0 <= ttisutcnt && ttisutcnt < TZ_MAX_TYPES)) 545 return EINVAL; 546 datablock_size 547 = (timecnt * stored /* ats */ 548 + timecnt /* types */ 549 + typecnt * 6 /* ttinfos */ 550 + charcnt /* chars */ 551 + leapcnt * (stored + 4) /* lsinfos */ 552 + ttisstdcnt /* ttisstds */ 553 + ttisutcnt); /* ttisuts */ 554 if (nread < tzheadsize + datablock_size) 555 return EINVAL; 556 if (skip_datablock) 557 p += datablock_size; 558 else { 559 if (! ((ttisstdcnt == typecnt || ttisstdcnt == 0) 560 && (ttisutcnt == typecnt || ttisutcnt == 0))) 561 return EINVAL; 562 563 sp->leapcnt = leapcnt; 564 sp->timecnt = timecnt; 565 sp->typecnt = typecnt; 566 sp->charcnt = charcnt; 567 568 /* Read transitions, discarding those out of time_t range. 569 But pretend the last transition before TIME_T_MIN 570 occurred at TIME_T_MIN. */ 571 timecnt = 0; 572 for (i = 0; i < sp->timecnt; ++i) { 573 int_fast64_t at 574 = stored == 4 ? detzcode(p) : detzcode64(p); 575 sp->types[i] = at <= TIME_T_MAX; 576 if (sp->types[i]) { 577 time_t attime 578 = ((TYPE_SIGNED(time_t) ? at < TIME_T_MIN : at < 0) 579 ? TIME_T_MIN : at); 580 if (timecnt && attime <= sp->ats[timecnt - 1]) { 581 if (attime < sp->ats[timecnt - 1]) 582 return EINVAL; 583 sp->types[i - 1] = 0; 584 timecnt--; 585 } 586 sp->ats[timecnt++] = attime; 587 } 588 p += stored; 589 } 590 591 timecnt = 0; 592 for (i = 0; i < sp->timecnt; ++i) { 593 unsigned char typ = *p++; 594 if (sp->typecnt <= typ) 595 return EINVAL; 596 if (sp->types[i]) 597 sp->types[timecnt++] = typ; 598 } 599 sp->timecnt = timecnt; 600 for (i = 0; i < sp->typecnt; ++i) { 601 register struct ttinfo * ttisp; 602 unsigned char isdst, desigidx; 603 604 ttisp = &sp->ttis[i]; 605 ttisp->tt_utoff = detzcode(p); 606 p += 4; 607 isdst = *p++; 608 if (! (isdst < 2)) 609 return EINVAL; 610 ttisp->tt_isdst = isdst; 611 desigidx = *p++; 612 if (! (desigidx < sp->charcnt)) 613 return EINVAL; 614 ttisp->tt_desigidx = desigidx; 615 } 616 for (i = 0; i < sp->charcnt; ++i) 617 sp->chars[i] = *p++; 618 /* Ensure '\0'-terminated, and make it safe to call 619 ttunspecified later. */ 620 memset(&sp->chars[i], 0, CHARS_EXTRA); 621 622 /* Read leap seconds, discarding those out of time_t range. */ 623 leapcnt = 0; 624 for (i = 0; i < sp->leapcnt; ++i) { 625 int_fast64_t tr = stored == 4 ? detzcode(p) : detzcode64(p); 626 int_fast32_t corr = detzcode(p + stored); 627 p += stored + 4; 628 629 /* Leap seconds cannot occur before the Epoch, 630 or out of order. */ 631 if (tr <= prevtr) 632 return EINVAL; 633 634 /* To avoid other botches in this code, each leap second's 635 correction must differ from the previous one's by 1 636 second or less, except that the first correction can be 637 any value; these requirements are more generous than 638 RFC 8536, to allow future RFC extensions. */ 639 if (! (i == 0 640 || (prevcorr < corr 641 ? corr == prevcorr + 1 642 : (corr == prevcorr 643 || corr == prevcorr - 1)))) 644 return EINVAL; 645 prevtr = tr; 646 prevcorr = corr; 647 648 if (tr <= TIME_T_MAX) { 649 sp->lsis[leapcnt].ls_trans = tr; 650 sp->lsis[leapcnt].ls_corr = corr; 651 leapcnt++; 652 } 653 } 654 sp->leapcnt = leapcnt; 655 656 for (i = 0; i < sp->typecnt; ++i) { 657 register struct ttinfo * ttisp; 658 659 ttisp = &sp->ttis[i]; 660 if (ttisstdcnt == 0) 661 ttisp->tt_ttisstd = false; 662 else { 663 if (*p != true && *p != false) 664 return EINVAL; 665 ttisp->tt_ttisstd = *p++; 666 } 667 } 668 for (i = 0; i < sp->typecnt; ++i) { 669 register struct ttinfo * ttisp; 670 671 ttisp = &sp->ttis[i]; 672 if (ttisutcnt == 0) 673 ttisp->tt_ttisut = false; 674 else { 675 if (*p != true && *p != false) 676 return EINVAL; 677 ttisp->tt_ttisut = *p++; 678 } 679 } 680 } 681 682 nread -= p - up->buf; 683 memmove(up->buf, p, nread); 684 685 /* If this is an old file, we're done. */ 686 if (!version) 687 break; 688 } 689 if (doextend && nread > 2 && 690 up->buf[0] == '\n' && up->buf[nread - 1] == '\n' && 691 sp->typecnt + 2 <= TZ_MAX_TYPES) { 692 struct state *ts = &lsp->u.st; 693 694 up->buf[nread - 1] = '\0'; 695 if (tzparse(&up->buf[1], ts, sp)) { 696 697 /* Attempt to reuse existing abbreviations. 698 Without this, America/Anchorage would be right on 699 the edge after 2037 when TZ_MAX_CHARS is 50, as 700 sp->charcnt equals 40 (for LMT AST AWT APT AHST 701 AHDT YST AKDT AKST) and ts->charcnt equals 10 702 (for AKST AKDT). Reusing means sp->charcnt can 703 stay 40 in this example. */ 704 int gotabbr = 0; 705 int charcnt = sp->charcnt; 706 for (i = 0; i < ts->typecnt; i++) { 707 char *tsabbr = ts->chars + ts->ttis[i].tt_desigidx; 708 int j; 709 for (j = 0; j < charcnt; j++) 710 if (strcmp(sp->chars + j, tsabbr) == 0) { 711 ts->ttis[i].tt_desigidx = j; 712 gotabbr++; 713 break; 714 } 715 if (! (j < charcnt)) { 716 int tsabbrlen = strlen(tsabbr); 717 if (j + tsabbrlen < TZ_MAX_CHARS) { 718 strcpy(sp->chars + j, tsabbr); 719 charcnt = j + tsabbrlen + 1; 720 ts->ttis[i].tt_desigidx = j; 721 gotabbr++; 722 } 723 } 724 } 725 if (gotabbr == ts->typecnt) { 726 sp->charcnt = charcnt; 727 728 /* Ignore any trailing, no-op transitions generated 729 by zic as they don't help here and can run afoul 730 of bugs in zic 2016j or earlier. */ 731 while (1 < sp->timecnt 732 && (sp->types[sp->timecnt - 1] 733 == sp->types[sp->timecnt - 2])) 734 sp->timecnt--; 735 736 for (i = 0; 737 i < ts->timecnt && sp->timecnt < TZ_MAX_TIMES; 738 i++) { 739 time_t t = ts->ats[i]; 740 if (increment_overflow_time(&t, leapcorr(sp, t)) 741 || (0 < sp->timecnt 742 && t <= sp->ats[sp->timecnt - 1])) 743 continue; 744 sp->ats[sp->timecnt] = t; 745 sp->types[sp->timecnt] = (sp->typecnt 746 + ts->types[i]); 747 sp->timecnt++; 748 } 749 for (i = 0; i < ts->typecnt; i++) 750 sp->ttis[sp->typecnt++] = ts->ttis[i]; 751 } 752 } 753 } 754 if (sp->typecnt == 0) 755 return EINVAL; 756 if (sp->timecnt > 1) { 757 if (sp->ats[0] <= TIME_T_MAX - SECSPERREPEAT) { 758 time_t repeatat = sp->ats[0] + SECSPERREPEAT; 759 int repeattype = sp->types[0]; 760 for (i = 1; i < sp->timecnt; ++i) 761 if (sp->ats[i] == repeatat 762 && typesequiv(sp, sp->types[i], repeattype)) { 763 sp->goback = true; 764 break; 765 } 766 } 767 if (TIME_T_MIN + SECSPERREPEAT <= sp->ats[sp->timecnt - 1]) { 768 time_t repeatat = sp->ats[sp->timecnt - 1] - SECSPERREPEAT; 769 int repeattype = sp->types[sp->timecnt - 1]; 770 for (i = sp->timecnt - 2; i >= 0; --i) 771 if (sp->ats[i] == repeatat 772 && typesequiv(sp, sp->types[i], repeattype)) { 773 sp->goahead = true; 774 break; 775 } 776 } 777 } 778 779 /* Infer sp->defaulttype from the data. Although this default 780 type is always zero for data from recent tzdb releases, 781 things are trickier for data from tzdb 2018e or earlier. 782 783 The first set of heuristics work around bugs in 32-bit data 784 generated by tzdb 2013c or earlier. The workaround is for 785 zones like Australia/Macquarie where timestamps before the 786 first transition have a time type that is not the earliest 787 standard-time type. See: 788 https://mm.icann.org/pipermail/tz/2013-May/019368.html */ 789 /* 790 ** If type 0 does not specify local time, or is unused in transitions, 791 ** it's the type to use for early times. 792 */ 793 for (i = 0; i < sp->timecnt; ++i) 794 if (sp->types[i] == 0) 795 break; 796 i = i < sp->timecnt && ! ttunspecified(sp, 0) ? -1 : 0; 797 /* 798 ** Absent the above, 799 ** if there are transition times 800 ** and the first transition is to a daylight time 801 ** find the standard type less than and closest to 802 ** the type of the first transition. 803 */ 804 if (i < 0 && sp->timecnt > 0 && sp->ttis[sp->types[0]].tt_isdst) { 805 i = sp->types[0]; 806 while (--i >= 0) 807 if (!sp->ttis[i].tt_isdst) 808 break; 809 } 810 /* The next heuristics are for data generated by tzdb 2018e or 811 earlier, for zones like EST5EDT where the first transition 812 is to DST. */ 813 /* 814 ** If no result yet, find the first standard type. 815 ** If there is none, punt to type zero. 816 */ 817 if (i < 0) { 818 i = 0; 819 while (sp->ttis[i].tt_isdst) 820 if (++i >= sp->typecnt) { 821 i = 0; 822 break; 823 } 824 } 825 /* A simple 'sp->defaulttype = 0;' would suffice here if we 826 didn't have to worry about 2018e-or-earlier data. Even 827 simpler would be to remove the defaulttype member and just 828 use 0 in its place. */ 829 sp->defaulttype = i; 830 831 return 0; 832 } 833 834 /* Load tz data from the file named NAME into *SP. Read extended 835 format if DOEXTEND. Return 0 on success, an errno value on failure. */ 836 static int 837 tzload(char const *name, struct state *sp, bool doextend) 838 { 839 #ifdef ALL_STATE 840 union local_storage *lsp = malloc(sizeof *lsp); 841 if (!lsp) { 842 return HAVE_MALLOC_ERRNO ? errno : ENOMEM; 843 } else { 844 int err = tzloadbody(name, sp, doextend, lsp); 845 free(lsp); 846 return err; 847 } 848 #else 849 union local_storage ls; 850 return tzloadbody(name, sp, doextend, &ls); 851 #endif 852 } 853 854 static bool 855 typesequiv(const struct state *sp, int a, int b) 856 { 857 register bool result; 858 859 if (sp == NULL || 860 a < 0 || a >= sp->typecnt || 861 b < 0 || b >= sp->typecnt) 862 result = false; 863 else { 864 /* Compare the relevant members of *AP and *BP. 865 Ignore tt_ttisstd and tt_ttisut, as they are 866 irrelevant now and counting them could cause 867 sp->goahead to mistakenly remain false. */ 868 register const struct ttinfo * ap = &sp->ttis[a]; 869 register const struct ttinfo * bp = &sp->ttis[b]; 870 result = (ap->tt_utoff == bp->tt_utoff 871 && ap->tt_isdst == bp->tt_isdst 872 && (strcmp(&sp->chars[ap->tt_desigidx], 873 &sp->chars[bp->tt_desigidx]) 874 == 0)); 875 } 876 return result; 877 } 878 879 static const int mon_lengths[2][MONSPERYEAR] = { 880 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, 881 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } 882 }; 883 884 static const int year_lengths[2] = { 885 DAYSPERNYEAR, DAYSPERLYEAR 886 }; 887 888 /* Is C an ASCII digit? */ 889 static bool 890 is_digit(char c) 891 { 892 return '0' <= c && c <= '9'; 893 } 894 895 /* 896 ** Given a pointer into a timezone string, scan until a character that is not 897 ** a valid character in a time zone abbreviation is found. 898 ** Return a pointer to that character. 899 */ 900 901 static ATTRIBUTE_REPRODUCIBLE const char * 902 getzname(register const char *strp) 903 { 904 register char c; 905 906 while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' && 907 c != '+') 908 ++strp; 909 return strp; 910 } 911 912 /* 913 ** Given a pointer into an extended timezone string, scan until the ending 914 ** delimiter of the time zone abbreviation is located. 915 ** Return a pointer to the delimiter. 916 ** 917 ** As with getzname above, the legal character set is actually quite 918 ** restricted, with other characters producing undefined results. 919 ** We don't do any checking here; checking is done later in common-case code. 920 */ 921 922 static ATTRIBUTE_REPRODUCIBLE const char * 923 getqzname(register const char *strp, const int delim) 924 { 925 register int c; 926 927 while ((c = *strp) != '\0' && c != delim) 928 ++strp; 929 return strp; 930 } 931 932 /* 933 ** Given a pointer into a timezone string, extract a number from that string. 934 ** Check that the number is within a specified range; if it is not, return 935 ** NULL. 936 ** Otherwise, return a pointer to the first character not part of the number. 937 */ 938 939 static const char * 940 getnum(register const char *strp, int *const nump, const int min, const int max) 941 { 942 register char c; 943 register int num; 944 945 if (strp == NULL || !is_digit(c = *strp)) 946 return NULL; 947 num = 0; 948 do { 949 num = num * 10 + (c - '0'); 950 if (num > max) 951 return NULL; /* illegal value */ 952 c = *++strp; 953 } while (is_digit(c)); 954 if (num < min) 955 return NULL; /* illegal value */ 956 *nump = num; 957 return strp; 958 } 959 960 /* 961 ** Given a pointer into a timezone string, extract a number of seconds, 962 ** in hh[:mm[:ss]] form, from the string. 963 ** If any error occurs, return NULL. 964 ** Otherwise, return a pointer to the first character not part of the number 965 ** of seconds. 966 */ 967 968 static const char * 969 getsecs(register const char *strp, int_fast32_t *const secsp) 970 { 971 int num; 972 int_fast32_t secsperhour = SECSPERHOUR; 973 974 /* 975 ** 'HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like 976 ** "M10.4.6/26", which does not conform to Posix, 977 ** but which specifies the equivalent of 978 ** "02:00 on the first Sunday on or after 23 Oct". 979 */ 980 strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1); 981 if (strp == NULL) 982 return NULL; 983 *secsp = num * secsperhour; 984 if (*strp == ':') { 985 ++strp; 986 strp = getnum(strp, &num, 0, MINSPERHOUR - 1); 987 if (strp == NULL) 988 return NULL; 989 *secsp += num * SECSPERMIN; 990 if (*strp == ':') { 991 ++strp; 992 /* 'SECSPERMIN' allows for leap seconds. */ 993 strp = getnum(strp, &num, 0, SECSPERMIN); 994 if (strp == NULL) 995 return NULL; 996 *secsp += num; 997 } 998 } 999 return strp; 1000 } 1001 1002 /* 1003 ** Given a pointer into a timezone string, extract an offset, in 1004 ** [+-]hh[:mm[:ss]] form, from the string. 1005 ** If any error occurs, return NULL. 1006 ** Otherwise, return a pointer to the first character not part of the time. 1007 */ 1008 1009 static const char * 1010 getoffset(register const char *strp, int_fast32_t *const offsetp) 1011 { 1012 register bool neg = false; 1013 1014 if (*strp == '-') { 1015 neg = true; 1016 ++strp; 1017 } else if (*strp == '+') 1018 ++strp; 1019 strp = getsecs(strp, offsetp); 1020 if (strp == NULL) 1021 return NULL; /* illegal time */ 1022 if (neg) 1023 *offsetp = -*offsetp; 1024 return strp; 1025 } 1026 1027 /* 1028 ** Given a pointer into a timezone string, extract a rule in the form 1029 ** date[/time]. See POSIX section 8 for the format of "date" and "time". 1030 ** If a valid rule is not found, return NULL. 1031 ** Otherwise, return a pointer to the first character not part of the rule. 1032 */ 1033 1034 static const char * 1035 getrule(const char *strp, register struct rule *const rulep) 1036 { 1037 if (*strp == 'J') { 1038 /* 1039 ** Julian day. 1040 */ 1041 rulep->r_type = JULIAN_DAY; 1042 ++strp; 1043 strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR); 1044 } else if (*strp == 'M') { 1045 /* 1046 ** Month, week, day. 1047 */ 1048 rulep->r_type = MONTH_NTH_DAY_OF_WEEK; 1049 ++strp; 1050 strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR); 1051 if (strp == NULL) 1052 return NULL; 1053 if (*strp++ != '.') 1054 return NULL; 1055 strp = getnum(strp, &rulep->r_week, 1, 5); 1056 if (strp == NULL) 1057 return NULL; 1058 if (*strp++ != '.') 1059 return NULL; 1060 strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1); 1061 } else if (is_digit(*strp)) { 1062 /* 1063 ** Day of year. 1064 */ 1065 rulep->r_type = DAY_OF_YEAR; 1066 strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1); 1067 } else return NULL; /* invalid format */ 1068 if (strp == NULL) 1069 return NULL; 1070 if (*strp == '/') { 1071 /* 1072 ** Time specified. 1073 */ 1074 ++strp; 1075 strp = getoffset(strp, &rulep->r_time); 1076 } else rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */ 1077 return strp; 1078 } 1079 1080 /* 1081 ** Given a year, a rule, and the offset from UT at the time that rule takes 1082 ** effect, calculate the year-relative time that rule takes effect. 1083 */ 1084 1085 static int_fast32_t 1086 transtime(const int year, register const struct rule *const rulep, 1087 const int_fast32_t offset) 1088 { 1089 register bool leapyear; 1090 register int_fast32_t value; 1091 register int i; 1092 int d, m1, yy0, yy1, yy2, dow; 1093 1094 leapyear = isleap(year); 1095 switch (rulep->r_type) { 1096 1097 case JULIAN_DAY: 1098 /* 1099 ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap 1100 ** years. 1101 ** In non-leap years, or if the day number is 59 or less, just 1102 ** add SECSPERDAY times the day number-1 to the time of 1103 ** January 1, midnight, to get the day. 1104 */ 1105 value = (rulep->r_day - 1) * SECSPERDAY; 1106 if (leapyear && rulep->r_day >= 60) 1107 value += SECSPERDAY; 1108 break; 1109 1110 case DAY_OF_YEAR: 1111 /* 1112 ** n - day of year. 1113 ** Just add SECSPERDAY times the day number to the time of 1114 ** January 1, midnight, to get the day. 1115 */ 1116 value = rulep->r_day * SECSPERDAY; 1117 break; 1118 1119 case MONTH_NTH_DAY_OF_WEEK: 1120 /* 1121 ** Mm.n.d - nth "dth day" of month m. 1122 */ 1123 1124 /* 1125 ** Use Zeller's Congruence to get day-of-week of first day of 1126 ** month. 1127 */ 1128 m1 = (rulep->r_mon + 9) % 12 + 1; 1129 yy0 = (rulep->r_mon <= 2) ? (year - 1) : year; 1130 yy1 = yy0 / 100; 1131 yy2 = yy0 % 100; 1132 dow = ((26 * m1 - 2) / 10 + 1133 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7; 1134 if (dow < 0) 1135 dow += DAYSPERWEEK; 1136 1137 /* 1138 ** "dow" is the day-of-week of the first day of the month. Get 1139 ** the day-of-month (zero-origin) of the first "dow" day of the 1140 ** month. 1141 */ 1142 d = rulep->r_day - dow; 1143 if (d < 0) 1144 d += DAYSPERWEEK; 1145 for (i = 1; i < rulep->r_week; ++i) { 1146 if (d + DAYSPERWEEK >= 1147 mon_lengths[leapyear][rulep->r_mon - 1]) 1148 break; 1149 d += DAYSPERWEEK; 1150 } 1151 1152 /* 1153 ** "d" is the day-of-month (zero-origin) of the day we want. 1154 */ 1155 value = d * SECSPERDAY; 1156 for (i = 0; i < rulep->r_mon - 1; ++i) 1157 value += mon_lengths[leapyear][i] * SECSPERDAY; 1158 break; 1159 1160 default: unreachable(); 1161 } 1162 1163 /* 1164 ** "value" is the year-relative time of 00:00:00 UT on the day in 1165 ** question. To get the year-relative time of the specified local 1166 ** time on that day, add the transition time and the current offset 1167 ** from UT. 1168 */ 1169 return value + rulep->r_time + offset; 1170 } 1171 1172 /* 1173 ** Given a POSIX section 8-style TZ string, fill in the rule tables as 1174 ** appropriate. 1175 */ 1176 1177 static bool 1178 tzparse(const char *name, struct state *sp, struct state *basep) 1179 { 1180 const char * stdname; 1181 const char * dstname; 1182 int_fast32_t stdoffset; 1183 int_fast32_t dstoffset; 1184 register char * cp; 1185 register bool load_ok; 1186 ptrdiff_t stdlen, dstlen, charcnt; 1187 time_t atlo = TIME_T_MIN, leaplo = TIME_T_MIN; 1188 1189 stdname = name; 1190 if (*name == '<') { 1191 name++; 1192 stdname = name; 1193 name = getqzname(name, '>'); 1194 if (*name != '>') 1195 return false; 1196 stdlen = name - stdname; 1197 name++; 1198 } else { 1199 name = getzname(name); 1200 stdlen = name - stdname; 1201 } 1202 if (!stdlen) 1203 return false; 1204 name = getoffset(name, &stdoffset); 1205 if (name == NULL) 1206 return false; 1207 charcnt = stdlen + 1; 1208 if (sizeof sp->chars < charcnt) 1209 return false; 1210 if (basep) { 1211 if (0 < basep->timecnt) 1212 atlo = basep->ats[basep->timecnt - 1]; 1213 load_ok = false; 1214 sp->leapcnt = basep->leapcnt; 1215 memcpy(sp->lsis, basep->lsis, sp->leapcnt * sizeof *sp->lsis); 1216 } else { 1217 load_ok = tzload(TZDEFRULES, sp, false) == 0; 1218 if (!load_ok) 1219 sp->leapcnt = 0; /* So, we're off a little. */ 1220 } 1221 if (0 < sp->leapcnt) 1222 leaplo = sp->lsis[sp->leapcnt - 1].ls_trans; 1223 if (*name != '\0') { 1224 if (*name == '<') { 1225 dstname = ++name; 1226 name = getqzname(name, '>'); 1227 if (*name != '>') 1228 return false; 1229 dstlen = name - dstname; 1230 name++; 1231 } else { 1232 dstname = name; 1233 name = getzname(name); 1234 dstlen = name - dstname; /* length of DST abbr. */ 1235 } 1236 if (!dstlen) 1237 return false; 1238 charcnt += dstlen + 1; 1239 if (sizeof sp->chars < charcnt) 1240 return false; 1241 if (*name != '\0' && *name != ',' && *name != ';') { 1242 name = getoffset(name, &dstoffset); 1243 if (name == NULL) 1244 return false; 1245 } else dstoffset = stdoffset - SECSPERHOUR; 1246 if (*name == '\0' && !load_ok) 1247 name = TZDEFRULESTRING; 1248 if (*name == ',' || *name == ';') { 1249 struct rule start; 1250 struct rule end; 1251 register int year; 1252 register int timecnt; 1253 time_t janfirst; 1254 int_fast32_t janoffset = 0; 1255 int yearbeg, yearlim; 1256 1257 ++name; 1258 if ((name = getrule(name, &start)) == NULL) 1259 return false; 1260 if (*name++ != ',') 1261 return false; 1262 if ((name = getrule(name, &end)) == NULL) 1263 return false; 1264 if (*name != '\0') 1265 return false; 1266 sp->typecnt = 2; /* standard time and DST */ 1267 /* 1268 ** Two transitions per year, from EPOCH_YEAR forward. 1269 */ 1270 init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); 1271 init_ttinfo(&sp->ttis[1], -dstoffset, true, stdlen + 1); 1272 sp->defaulttype = 0; 1273 timecnt = 0; 1274 janfirst = 0; 1275 yearbeg = EPOCH_YEAR; 1276 1277 do { 1278 int_fast32_t yearsecs 1279 = year_lengths[isleap(yearbeg - 1)] * SECSPERDAY; 1280 yearbeg--; 1281 if (increment_overflow_time(&janfirst, -yearsecs)) { 1282 janoffset = -yearsecs; 1283 break; 1284 } 1285 } while (atlo < janfirst 1286 && EPOCH_YEAR - YEARSPERREPEAT / 2 < yearbeg); 1287 1288 while (true) { 1289 int_fast32_t yearsecs 1290 = year_lengths[isleap(yearbeg)] * SECSPERDAY; 1291 int yearbeg1 = yearbeg; 1292 time_t janfirst1 = janfirst; 1293 if (increment_overflow_time(&janfirst1, yearsecs) 1294 || increment_overflow(&yearbeg1, 1) 1295 || atlo <= janfirst1) 1296 break; 1297 yearbeg = yearbeg1; 1298 janfirst = janfirst1; 1299 } 1300 1301 yearlim = yearbeg; 1302 if (increment_overflow(&yearlim, YEARSPERREPEAT + 1)) 1303 yearlim = INT_MAX; 1304 for (year = yearbeg; year < yearlim; year++) { 1305 int_fast32_t 1306 starttime = transtime(year, &start, stdoffset), 1307 endtime = transtime(year, &end, dstoffset); 1308 int_fast32_t 1309 yearsecs = (year_lengths[isleap(year)] 1310 * SECSPERDAY); 1311 bool reversed = endtime < starttime; 1312 if (reversed) { 1313 int_fast32_t swap = starttime; 1314 starttime = endtime; 1315 endtime = swap; 1316 } 1317 if (reversed 1318 || (starttime < endtime 1319 && endtime - starttime < yearsecs)) { 1320 if (TZ_MAX_TIMES - 2 < timecnt) 1321 break; 1322 sp->ats[timecnt] = janfirst; 1323 if (! increment_overflow_time 1324 (&sp->ats[timecnt], 1325 janoffset + starttime) 1326 && atlo <= sp->ats[timecnt]) 1327 sp->types[timecnt++] = !reversed; 1328 sp->ats[timecnt] = janfirst; 1329 if (! increment_overflow_time 1330 (&sp->ats[timecnt], 1331 janoffset + endtime) 1332 && atlo <= sp->ats[timecnt]) { 1333 sp->types[timecnt++] = reversed; 1334 } 1335 } 1336 if (endtime < leaplo) { 1337 yearlim = year; 1338 if (increment_overflow(&yearlim, 1339 YEARSPERREPEAT + 1)) 1340 yearlim = INT_MAX; 1341 } 1342 if (increment_overflow_time 1343 (&janfirst, janoffset + yearsecs)) 1344 break; 1345 janoffset = 0; 1346 } 1347 sp->timecnt = timecnt; 1348 if (! timecnt) { 1349 sp->ttis[0] = sp->ttis[1]; 1350 sp->typecnt = 1; /* Perpetual DST. */ 1351 } else if (YEARSPERREPEAT < year - yearbeg) 1352 sp->goback = sp->goahead = true; 1353 } else { 1354 register int_fast32_t theirstdoffset; 1355 register int_fast32_t theirdstoffset; 1356 register int_fast32_t theiroffset; 1357 register bool isdst; 1358 register int i; 1359 register int j; 1360 1361 if (*name != '\0') 1362 return false; 1363 /* 1364 ** Initial values of theirstdoffset and theirdstoffset. 1365 */ 1366 theirstdoffset = 0; 1367 for (i = 0; i < sp->timecnt; ++i) { 1368 j = sp->types[i]; 1369 if (!sp->ttis[j].tt_isdst) { 1370 theirstdoffset = 1371 - sp->ttis[j].tt_utoff; 1372 break; 1373 } 1374 } 1375 theirdstoffset = 0; 1376 for (i = 0; i < sp->timecnt; ++i) { 1377 j = sp->types[i]; 1378 if (sp->ttis[j].tt_isdst) { 1379 theirdstoffset = 1380 - sp->ttis[j].tt_utoff; 1381 break; 1382 } 1383 } 1384 /* 1385 ** Initially we're assumed to be in standard time. 1386 */ 1387 isdst = false; 1388 /* 1389 ** Now juggle transition times and types 1390 ** tracking offsets as you do. 1391 */ 1392 for (i = 0; i < sp->timecnt; ++i) { 1393 j = sp->types[i]; 1394 sp->types[i] = sp->ttis[j].tt_isdst; 1395 if (sp->ttis[j].tt_ttisut) { 1396 /* No adjustment to transition time */ 1397 } else { 1398 /* 1399 ** If daylight saving time is in 1400 ** effect, and the transition time was 1401 ** not specified as standard time, add 1402 ** the daylight saving time offset to 1403 ** the transition time; otherwise, add 1404 ** the standard time offset to the 1405 ** transition time. 1406 */ 1407 /* 1408 ** Transitions from DST to DDST 1409 ** will effectively disappear since 1410 ** POSIX provides for only one DST 1411 ** offset. 1412 */ 1413 if (isdst && !sp->ttis[j].tt_ttisstd) { 1414 sp->ats[i] += dstoffset - 1415 theirdstoffset; 1416 } else { 1417 sp->ats[i] += stdoffset - 1418 theirstdoffset; 1419 } 1420 } 1421 theiroffset = -sp->ttis[j].tt_utoff; 1422 if (sp->ttis[j].tt_isdst) 1423 theirdstoffset = theiroffset; 1424 else theirstdoffset = theiroffset; 1425 } 1426 /* 1427 ** Finally, fill in ttis. 1428 */ 1429 init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); 1430 init_ttinfo(&sp->ttis[1], -dstoffset, true, stdlen + 1); 1431 sp->typecnt = 2; 1432 sp->defaulttype = 0; 1433 } 1434 } else { 1435 dstlen = 0; 1436 sp->typecnt = 1; /* only standard time */ 1437 sp->timecnt = 0; 1438 init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); 1439 sp->defaulttype = 0; 1440 } 1441 sp->charcnt = charcnt; 1442 cp = sp->chars; 1443 memcpy(cp, stdname, stdlen); 1444 cp += stdlen; 1445 *cp++ = '\0'; 1446 if (dstlen != 0) { 1447 memcpy(cp, dstname, dstlen); 1448 *(cp + dstlen) = '\0'; 1449 } 1450 return true; 1451 } 1452 1453 static void 1454 gmtload(struct state *const sp) 1455 { 1456 if (tzload(etc_utc, sp, true) != 0) 1457 tzparse("UTC0", sp, NULL); 1458 } 1459 1460 #ifdef DETECT_TZ_CHANGES 1461 static int 1462 recheck_tzdata() 1463 { 1464 static time_t last_checked; 1465 struct timespec now; 1466 time_t current_time; 1467 int error; 1468 1469 /* 1470 * We want to recheck the timezone file every 61 sec. 1471 */ 1472 error = clock_gettime(CLOCK_MONOTONIC, &now); 1473 if (error < 0) { 1474 /* XXX: Can we somehow report this? */ 1475 return 0; 1476 } 1477 1478 current_time = now.tv_sec; 1479 if ((current_time - last_checked > DETECT_TZ_CHANGES_INTERVAL) || 1480 (last_checked > current_time)) { 1481 last_checked = current_time; 1482 return 1; 1483 } 1484 1485 return 0; 1486 } 1487 #else /* !DETECT_TZ_CHANGES */ 1488 #define recheck_tzdata() 0 1489 #endif /* !DETECT_TZ_CHANGES */ 1490 1491 /* Initialize *SP to a value appropriate for the TZ setting NAME. 1492 Return 0 on success, an errno value on failure. */ 1493 static int 1494 zoneinit(struct state *sp, char const *name) 1495 { 1496 if (name && ! name[0]) { 1497 /* 1498 ** User wants it fast rather than right. 1499 */ 1500 sp->leapcnt = 0; /* so, we're off a little */ 1501 sp->timecnt = 0; 1502 sp->typecnt = 0; 1503 sp->charcnt = 0; 1504 sp->goback = sp->goahead = false; 1505 init_ttinfo(&sp->ttis[0], 0, false, 0); 1506 strcpy(sp->chars, utc); 1507 sp->defaulttype = 0; 1508 return 0; 1509 } else { 1510 int err = tzload(name, sp, true); 1511 if (err != 0 && name && name[0] != ':' && tzparse(name, sp, NULL)) 1512 err = 0; 1513 if (err == 0) 1514 scrub_abbrs(sp); 1515 return err; 1516 } 1517 } 1518 1519 static void 1520 tzset_unlocked(void) 1521 { 1522 char const *name = getenv("TZ"); 1523 struct state *sp = lclptr; 1524 int lcl = name ? strlen(name) < sizeof lcl_TZname : -1; 1525 if (lcl < 0 1526 ? lcl_is_set < 0 1527 : 0 < lcl_is_set && strcmp(lcl_TZname, name) == 0) 1528 if (recheck_tzdata() == 0) 1529 return; 1530 #ifdef ALL_STATE 1531 if (! sp) 1532 lclptr = sp = malloc(sizeof *lclptr); 1533 #endif /* defined ALL_STATE */ 1534 if (sp) { 1535 if (zoneinit(sp, name) != 0) 1536 zoneinit(sp, ""); 1537 if (0 < lcl) 1538 strcpy(lcl_TZname, name); 1539 } 1540 settzname(); 1541 lcl_is_set = lcl; 1542 } 1543 1544 void 1545 tzset(void) 1546 { 1547 if (lock() != 0) 1548 return; 1549 tzset_unlocked(); 1550 unlock(); 1551 } 1552 1553 static void 1554 gmtcheck(void) 1555 { 1556 static bool gmt_is_set; 1557 if (lock() != 0) 1558 return; 1559 if (! gmt_is_set) { 1560 #ifdef ALL_STATE 1561 gmtptr = malloc(sizeof *gmtptr); 1562 #endif 1563 if (gmtptr) 1564 gmtload(gmtptr); 1565 gmt_is_set = true; 1566 } 1567 unlock(); 1568 } 1569 1570 #if NETBSD_INSPIRED 1571 1572 timezone_t 1573 tzalloc(char const *name) 1574 { 1575 timezone_t sp = malloc(sizeof *sp); 1576 if (sp) { 1577 int err = zoneinit(sp, name); 1578 if (err != 0) { 1579 free(sp); 1580 errno = err; 1581 return NULL; 1582 } 1583 } else if (!HAVE_MALLOC_ERRNO) 1584 errno = ENOMEM; 1585 return sp; 1586 } 1587 1588 void 1589 tzfree(timezone_t sp) 1590 { 1591 free(sp); 1592 } 1593 1594 /* 1595 ** NetBSD 6.1.4 has ctime_rz, but omit it because POSIX says ctime and 1596 ** ctime_r are obsolescent and have potential security problems that 1597 ** ctime_rz would share. Callers can instead use localtime_rz + strftime. 1598 ** 1599 ** NetBSD 6.1.4 has tzgetname, but omit it because it doesn't work 1600 ** in zones with three or more time zone abbreviations. 1601 ** Callers can instead use localtime_rz + strftime. 1602 */ 1603 1604 #endif 1605 1606 /* 1607 ** The easy way to behave "as if no library function calls" localtime 1608 ** is to not call it, so we drop its guts into "localsub", which can be 1609 ** freely called. (And no, the PANS doesn't require the above behavior, 1610 ** but it *is* desirable.) 1611 ** 1612 ** If successful and SETNAME is nonzero, 1613 ** set the applicable parts of tzname, timezone and altzone; 1614 ** however, it's OK to omit this step if the timezone is POSIX-compatible, 1615 ** since in that case tzset should have already done this step correctly. 1616 ** SETNAME's type is int_fast32_t for compatibility with gmtsub, 1617 ** but it is actually a boolean and its value should be 0 or 1. 1618 */ 1619 1620 /*ARGSUSED*/ 1621 static struct tm * 1622 localsub(struct state const *sp, time_t const *timep, int_fast32_t setname, 1623 struct tm *const tmp) 1624 { 1625 register const struct ttinfo * ttisp; 1626 register int i; 1627 register struct tm * result; 1628 const time_t t = *timep; 1629 1630 if (sp == NULL) { 1631 /* Don't bother to set tzname etc.; tzset has already done it. */ 1632 return gmtsub(gmtptr, timep, 0, tmp); 1633 } 1634 if ((sp->goback && t < sp->ats[0]) || 1635 (sp->goahead && t > sp->ats[sp->timecnt - 1])) { 1636 time_t newt; 1637 register time_t seconds; 1638 register time_t years; 1639 1640 if (t < sp->ats[0]) 1641 seconds = sp->ats[0] - t; 1642 else seconds = t - sp->ats[sp->timecnt - 1]; 1643 --seconds; 1644 1645 /* Beware integer overflow, as SECONDS might 1646 be close to the maximum time_t. */ 1647 years = seconds / SECSPERREPEAT * YEARSPERREPEAT; 1648 seconds = years * AVGSECSPERYEAR; 1649 years += YEARSPERREPEAT; 1650 if (t < sp->ats[0]) 1651 newt = t + seconds + SECSPERREPEAT; 1652 else 1653 newt = t - seconds - SECSPERREPEAT; 1654 1655 if (newt < sp->ats[0] || 1656 newt > sp->ats[sp->timecnt - 1]) 1657 return NULL; /* "cannot happen" */ 1658 result = localsub(sp, &newt, setname, tmp); 1659 if (result) { 1660 #if defined ckd_add && defined ckd_sub 1661 if (t < sp->ats[0] 1662 ? ckd_sub(&result->tm_year, 1663 result->tm_year, years) 1664 : ckd_add(&result->tm_year, 1665 result->tm_year, years)) 1666 return NULL; 1667 #else 1668 register int_fast64_t newy; 1669 1670 newy = result->tm_year; 1671 if (t < sp->ats[0]) 1672 newy -= years; 1673 else newy += years; 1674 if (! (INT_MIN <= newy && newy <= INT_MAX)) 1675 return NULL; 1676 result->tm_year = newy; 1677 #endif 1678 } 1679 return result; 1680 } 1681 if (sp->timecnt == 0 || t < sp->ats[0]) { 1682 i = sp->defaulttype; 1683 } else { 1684 register int lo = 1; 1685 register int hi = sp->timecnt; 1686 1687 while (lo < hi) { 1688 register int mid = (lo + hi) >> 1; 1689 1690 if (t < sp->ats[mid]) 1691 hi = mid; 1692 else lo = mid + 1; 1693 } 1694 i = sp->types[lo - 1]; 1695 } 1696 ttisp = &sp->ttis[i]; 1697 /* 1698 ** To get (wrong) behavior that's compatible with System V Release 2.0 1699 ** you'd replace the statement below with 1700 ** t += ttisp->tt_utoff; 1701 ** timesub(&t, 0L, sp, tmp); 1702 */ 1703 result = timesub(&t, ttisp->tt_utoff, sp, tmp); 1704 if (result) { 1705 result->tm_isdst = ttisp->tt_isdst; 1706 #ifdef TM_ZONE 1707 result->TM_ZONE = (char *) &sp->chars[ttisp->tt_desigidx]; 1708 #endif /* defined TM_ZONE */ 1709 if (setname) 1710 update_tzname_etc(sp, ttisp); 1711 } 1712 return result; 1713 } 1714 1715 #if NETBSD_INSPIRED 1716 1717 struct tm * 1718 localtime_rz(struct state *sp, time_t const *timep, struct tm *tmp) 1719 { 1720 return localsub(sp, timep, 0, tmp); 1721 } 1722 1723 #endif 1724 1725 static struct tm * 1726 localtime_tzset(time_t const *timep, struct tm *tmp, bool setname) 1727 { 1728 int err = lock(); 1729 if (err) { 1730 errno = err; 1731 return NULL; 1732 } 1733 #ifndef DETECT_TZ_CHANGES 1734 if (setname || !lcl_is_set) 1735 #endif 1736 tzset_unlocked(); 1737 tmp = localsub(lclptr, timep, setname, tmp); 1738 unlock(); 1739 return tmp; 1740 } 1741 1742 static void 1743 localtime_key_init(void) 1744 { 1745 1746 localtime_key_error = _pthread_key_create(&localtime_key, free); 1747 } 1748 1749 struct tm * 1750 localtime(const time_t *timep) 1751 { 1752 struct tm *p_tm = &tm; 1753 1754 if (__isthreaded != 0) { 1755 _pthread_once(&localtime_once, localtime_key_init); 1756 if (localtime_key_error != 0) { 1757 errno = localtime_key_error; 1758 return (NULL); 1759 } 1760 if ((p_tm = _pthread_getspecific(localtime_key)) == NULL) { 1761 if ((p_tm = malloc(sizeof(*p_tm))) == NULL) { 1762 return (NULL); 1763 } 1764 if (_pthread_setspecific(localtime_key, p_tm) != 0) { 1765 free(p_tm); 1766 return (NULL); 1767 } 1768 } 1769 } 1770 return localtime_tzset(timep, p_tm, true); 1771 } 1772 1773 struct tm * 1774 localtime_r(const time_t *timep, struct tm *tmp) 1775 { 1776 return localtime_tzset(timep, tmp, false); 1777 } 1778 1779 /* 1780 ** gmtsub is to gmtime as localsub is to localtime. 1781 */ 1782 1783 static struct tm * 1784 gmtsub(ATTRIBUTE_MAYBE_UNUSED struct state const *sp, time_t const *timep, 1785 int_fast32_t offset, struct tm *tmp) 1786 { 1787 register struct tm * result; 1788 1789 result = timesub(timep, offset, gmtptr, tmp); 1790 #ifdef TM_ZONE 1791 /* 1792 ** Could get fancy here and deliver something such as 1793 ** "+xx" or "-xx" if offset is non-zero, 1794 ** but this is no time for a treasure hunt. 1795 */ 1796 tmp->TM_ZONE = ((char *) 1797 (offset ? wildabbr : gmtptr ? gmtptr->chars : utc)); 1798 #endif /* defined TM_ZONE */ 1799 return result; 1800 } 1801 1802 /* 1803 * Re-entrant version of gmtime. 1804 */ 1805 1806 struct tm * 1807 gmtime_r(const time_t *timep, struct tm *tmp) 1808 { 1809 _once(&gmt_once, gmtcheck); 1810 return gmtsub(gmtptr, timep, 0, tmp); 1811 } 1812 1813 static void 1814 gmtime_key_init(void) 1815 { 1816 1817 gmtime_key_error = _pthread_key_create(&gmtime_key, free); 1818 } 1819 1820 struct tm * 1821 gmtime(const time_t *timep) 1822 { 1823 struct tm *p_tm = &tm; 1824 1825 if (__isthreaded != 0) { 1826 _pthread_once(&gmtime_once, gmtime_key_init); 1827 if (gmtime_key_error != 0) { 1828 errno = gmtime_key_error; 1829 return (NULL); 1830 } 1831 if ((p_tm = _pthread_getspecific(gmtime_key)) == NULL) { 1832 if ((p_tm = malloc(sizeof(*p_tm))) == NULL) { 1833 return (NULL); 1834 } 1835 if (_pthread_setspecific(gmtime_key, p_tm) != 0) { 1836 free(p_tm); 1837 return (NULL); 1838 } 1839 } 1840 } 1841 return gmtime_r(timep, p_tm); 1842 } 1843 1844 #ifdef STD_INSPIRED 1845 1846 struct tm * 1847 offtime(const time_t *timep, long offset) 1848 { 1849 _once(&gmt_once, gmtcheck); 1850 return gmtsub(gmtptr, timep, offset, &tm); 1851 } 1852 1853 #endif /* defined STD_INSPIRED */ 1854 1855 /* 1856 ** Return the number of leap years through the end of the given year 1857 ** where, to make the math easy, the answer for year zero is defined as zero. 1858 */ 1859 1860 static time_t 1861 leaps_thru_end_of_nonneg(time_t y) 1862 { 1863 return y / 4 - y / 100 + y / 400; 1864 } 1865 1866 static time_t 1867 leaps_thru_end_of(time_t y) 1868 { 1869 return (y < 0 1870 ? -1 - leaps_thru_end_of_nonneg(-1 - y) 1871 : leaps_thru_end_of_nonneg(y)); 1872 } 1873 1874 static struct tm * 1875 timesub(const time_t *timep, int_fast32_t offset, 1876 const struct state *sp, struct tm *tmp) 1877 { 1878 register const struct lsinfo * lp; 1879 register time_t tdays; 1880 register const int * ip; 1881 register int_fast32_t corr; 1882 register int i; 1883 int_fast32_t idays, rem, dayoff, dayrem; 1884 time_t y; 1885 1886 /* If less than SECSPERMIN, the number of seconds since the 1887 most recent positive leap second; otherwise, do not add 1 1888 to localtime tm_sec because of leap seconds. */ 1889 time_t secs_since_posleap = SECSPERMIN; 1890 1891 corr = 0; 1892 i = (sp == NULL) ? 0 : sp->leapcnt; 1893 while (--i >= 0) { 1894 lp = &sp->lsis[i]; 1895 if (*timep >= lp->ls_trans) { 1896 corr = lp->ls_corr; 1897 if ((i == 0 ? 0 : lp[-1].ls_corr) < corr) 1898 secs_since_posleap = *timep - lp->ls_trans; 1899 break; 1900 } 1901 } 1902 1903 /* Calculate the year, avoiding integer overflow even if 1904 time_t is unsigned. */ 1905 tdays = *timep / SECSPERDAY; 1906 rem = *timep % SECSPERDAY; 1907 rem += offset % SECSPERDAY - corr % SECSPERDAY + 3 * SECSPERDAY; 1908 dayoff = offset / SECSPERDAY - corr / SECSPERDAY + rem / SECSPERDAY - 3; 1909 rem %= SECSPERDAY; 1910 /* y = (EPOCH_YEAR 1911 + floor((tdays + dayoff) / DAYSPERREPEAT) * YEARSPERREPEAT), 1912 sans overflow. But calculate against 1570 (EPOCH_YEAR - 1913 YEARSPERREPEAT) instead of against 1970 so that things work 1914 for localtime values before 1970 when time_t is unsigned. */ 1915 dayrem = tdays % DAYSPERREPEAT; 1916 dayrem += dayoff % DAYSPERREPEAT; 1917 y = (EPOCH_YEAR - YEARSPERREPEAT 1918 + ((1 + dayoff / DAYSPERREPEAT + dayrem / DAYSPERREPEAT 1919 - ((dayrem % DAYSPERREPEAT) < 0) 1920 + tdays / DAYSPERREPEAT) 1921 * YEARSPERREPEAT)); 1922 /* idays = (tdays + dayoff) mod DAYSPERREPEAT, sans overflow. */ 1923 idays = tdays % DAYSPERREPEAT; 1924 idays += dayoff % DAYSPERREPEAT + 2 * DAYSPERREPEAT; 1925 idays %= DAYSPERREPEAT; 1926 /* Increase Y and decrease IDAYS until IDAYS is in range for Y. */ 1927 while (year_lengths[isleap(y)] <= idays) { 1928 int tdelta = idays / DAYSPERLYEAR; 1929 int_fast32_t ydelta = tdelta + !tdelta; 1930 time_t newy = y + ydelta; 1931 register int leapdays; 1932 leapdays = leaps_thru_end_of(newy - 1) - 1933 leaps_thru_end_of(y - 1); 1934 idays -= ydelta * DAYSPERNYEAR; 1935 idays -= leapdays; 1936 y = newy; 1937 } 1938 1939 #ifdef ckd_add 1940 if (ckd_add(&tmp->tm_year, y, -TM_YEAR_BASE)) { 1941 errno = EOVERFLOW; 1942 return NULL; 1943 } 1944 #else 1945 if (!TYPE_SIGNED(time_t) && y < TM_YEAR_BASE) { 1946 int signed_y = y; 1947 tmp->tm_year = signed_y - TM_YEAR_BASE; 1948 } else if ((!TYPE_SIGNED(time_t) || INT_MIN + TM_YEAR_BASE <= y) 1949 && y - TM_YEAR_BASE <= INT_MAX) 1950 tmp->tm_year = y - TM_YEAR_BASE; 1951 else { 1952 errno = EOVERFLOW; 1953 return NULL; 1954 } 1955 #endif 1956 tmp->tm_yday = idays; 1957 /* 1958 ** The "extra" mods below avoid overflow problems. 1959 */ 1960 tmp->tm_wday = (TM_WDAY_BASE 1961 + ((tmp->tm_year % DAYSPERWEEK) 1962 * (DAYSPERNYEAR % DAYSPERWEEK)) 1963 + leaps_thru_end_of(y - 1) 1964 - leaps_thru_end_of(TM_YEAR_BASE - 1) 1965 + idays); 1966 tmp->tm_wday %= DAYSPERWEEK; 1967 if (tmp->tm_wday < 0) 1968 tmp->tm_wday += DAYSPERWEEK; 1969 tmp->tm_hour = rem / SECSPERHOUR; 1970 rem %= SECSPERHOUR; 1971 tmp->tm_min = rem / SECSPERMIN; 1972 tmp->tm_sec = rem % SECSPERMIN; 1973 1974 /* Use "... ??:??:60" at the end of the localtime minute containing 1975 the second just before the positive leap second. */ 1976 tmp->tm_sec += secs_since_posleap <= tmp->tm_sec; 1977 1978 ip = mon_lengths[isleap(y)]; 1979 for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon)) 1980 idays -= ip[tmp->tm_mon]; 1981 tmp->tm_mday = idays + 1; 1982 tmp->tm_isdst = 0; 1983 #ifdef TM_GMTOFF 1984 tmp->TM_GMTOFF = offset; 1985 #endif /* defined TM_GMTOFF */ 1986 return tmp; 1987 } 1988 1989 char * 1990 ctime(const time_t *timep) 1991 { 1992 /* 1993 ** Section 4.12.3.2 of X3.159-1989 requires that 1994 ** The ctime function converts the calendar time pointed to by timer 1995 ** to local time in the form of a string. It is equivalent to 1996 ** asctime(localtime(timer)) 1997 */ 1998 struct tm *tmp = localtime(timep); 1999 return tmp ? asctime(tmp) : NULL; 2000 } 2001 2002 char * 2003 ctime_r(const time_t *timep, char *buf) 2004 { 2005 struct tm mytm; 2006 struct tm *tmp = localtime_r(timep, &mytm); 2007 return tmp ? asctime_r(tmp, buf) : NULL; 2008 } 2009 2010 /* 2011 ** Adapted from code provided by Robert Elz, who writes: 2012 ** The "best" way to do mktime I think is based on an idea of Bob 2013 ** Kridle's (so its said...) from a long time ago. 2014 ** It does a binary search of the time_t space. Since time_t's are 2015 ** just 32 bits, its a max of 32 iterations (even at 64 bits it 2016 ** would still be very reasonable). 2017 */ 2018 2019 #ifndef WRONG 2020 # define WRONG (-1) 2021 #endif /* !defined WRONG */ 2022 2023 /* 2024 ** Normalize logic courtesy Paul Eggert. 2025 */ 2026 2027 static bool 2028 increment_overflow(int *ip, int j) 2029 { 2030 #ifdef ckd_add 2031 return ckd_add(ip, *ip, j); 2032 #else 2033 register int const i = *ip; 2034 2035 /* 2036 ** If i >= 0 there can only be overflow if i + j > INT_MAX 2037 ** or if j > INT_MAX - i; given i >= 0, INT_MAX - i cannot overflow. 2038 ** If i < 0 there can only be overflow if i + j < INT_MIN 2039 ** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow. 2040 */ 2041 if ((i >= 0) ? (j > INT_MAX - i) : (j < INT_MIN - i)) 2042 return true; 2043 *ip += j; 2044 return false; 2045 #endif 2046 } 2047 2048 static bool 2049 increment_overflow32(int_fast32_t *const lp, int const m) 2050 { 2051 #ifdef ckd_add 2052 return ckd_add(lp, *lp, m); 2053 #else 2054 register int_fast32_t const l = *lp; 2055 2056 if ((l >= 0) ? (m > INT_FAST32_MAX - l) : (m < INT_FAST32_MIN - l)) 2057 return true; 2058 *lp += m; 2059 return false; 2060 #endif 2061 } 2062 2063 static bool 2064 increment_overflow_time(time_t *tp, int_fast32_t j) 2065 { 2066 #ifdef ckd_add 2067 return ckd_add(tp, *tp, j); 2068 #else 2069 /* 2070 ** This is like 2071 ** 'if (! (TIME_T_MIN <= *tp + j && *tp + j <= TIME_T_MAX)) ...', 2072 ** except that it does the right thing even if *tp + j would overflow. 2073 */ 2074 if (! (j < 0 2075 ? (TYPE_SIGNED(time_t) ? TIME_T_MIN - j <= *tp : -1 - j < *tp) 2076 : *tp <= TIME_T_MAX - j)) 2077 return true; 2078 *tp += j; 2079 return false; 2080 #endif 2081 } 2082 2083 static bool 2084 normalize_overflow(int *const tensptr, int *const unitsptr, const int base) 2085 { 2086 register int tensdelta; 2087 2088 tensdelta = (*unitsptr >= 0) ? 2089 (*unitsptr / base) : 2090 (-1 - (-1 - *unitsptr) / base); 2091 *unitsptr -= tensdelta * base; 2092 return increment_overflow(tensptr, tensdelta); 2093 } 2094 2095 static bool 2096 normalize_overflow32(int_fast32_t *tensptr, int *unitsptr, int base) 2097 { 2098 register int tensdelta; 2099 2100 tensdelta = (*unitsptr >= 0) ? 2101 (*unitsptr / base) : 2102 (-1 - (-1 - *unitsptr) / base); 2103 *unitsptr -= tensdelta * base; 2104 return increment_overflow32(tensptr, tensdelta); 2105 } 2106 2107 static int 2108 tmcomp(register const struct tm *const atmp, 2109 register const struct tm *const btmp) 2110 { 2111 register int result; 2112 2113 if (atmp->tm_year != btmp->tm_year) 2114 return atmp->tm_year < btmp->tm_year ? -1 : 1; 2115 if ((result = (atmp->tm_mon - btmp->tm_mon)) == 0 && 2116 (result = (atmp->tm_mday - btmp->tm_mday)) == 0 && 2117 (result = (atmp->tm_hour - btmp->tm_hour)) == 0 && 2118 (result = (atmp->tm_min - btmp->tm_min)) == 0) 2119 result = atmp->tm_sec - btmp->tm_sec; 2120 return result; 2121 } 2122 2123 /* Copy to *DEST from *SRC. Copy only the members needed for mktime, 2124 as other members might not be initialized. */ 2125 static void 2126 mktmcpy(struct tm *dest, struct tm const *src) 2127 { 2128 dest->tm_sec = src->tm_sec; 2129 dest->tm_min = src->tm_min; 2130 dest->tm_hour = src->tm_hour; 2131 dest->tm_mday = src->tm_mday; 2132 dest->tm_mon = src->tm_mon; 2133 dest->tm_year = src->tm_year; 2134 dest->tm_isdst = src->tm_isdst; 2135 #if defined TM_GMTOFF && ! UNINIT_TRAP 2136 dest->TM_GMTOFF = src->TM_GMTOFF; 2137 #endif 2138 } 2139 2140 static time_t 2141 time2sub(struct tm *const tmp, 2142 struct tm *(*funcp)(struct state const *, time_t const *, 2143 int_fast32_t, struct tm *), 2144 struct state const *sp, 2145 const int_fast32_t offset, 2146 bool *okayp, 2147 bool do_norm_secs) 2148 { 2149 register int dir; 2150 register int i, j; 2151 register int saved_seconds; 2152 register int_fast32_t li; 2153 register time_t lo; 2154 register time_t hi; 2155 int_fast32_t y; 2156 time_t newt; 2157 time_t t; 2158 struct tm yourtm, mytm; 2159 2160 *okayp = false; 2161 mktmcpy(&yourtm, tmp); 2162 2163 if (do_norm_secs) { 2164 if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec, 2165 SECSPERMIN)) 2166 return WRONG; 2167 } 2168 if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR)) 2169 return WRONG; 2170 if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY)) 2171 return WRONG; 2172 y = yourtm.tm_year; 2173 if (normalize_overflow32(&y, &yourtm.tm_mon, MONSPERYEAR)) 2174 return WRONG; 2175 /* 2176 ** Turn y into an actual year number for now. 2177 ** It is converted back to an offset from TM_YEAR_BASE later. 2178 */ 2179 if (increment_overflow32(&y, TM_YEAR_BASE)) 2180 return WRONG; 2181 while (yourtm.tm_mday <= 0) { 2182 if (increment_overflow32(&y, -1)) 2183 return WRONG; 2184 li = y + (1 < yourtm.tm_mon); 2185 yourtm.tm_mday += year_lengths[isleap(li)]; 2186 } 2187 while (yourtm.tm_mday > DAYSPERLYEAR) { 2188 li = y + (1 < yourtm.tm_mon); 2189 yourtm.tm_mday -= year_lengths[isleap(li)]; 2190 if (increment_overflow32(&y, 1)) 2191 return WRONG; 2192 } 2193 for ( ; ; ) { 2194 i = mon_lengths[isleap(y)][yourtm.tm_mon]; 2195 if (yourtm.tm_mday <= i) 2196 break; 2197 yourtm.tm_mday -= i; 2198 if (++yourtm.tm_mon >= MONSPERYEAR) { 2199 yourtm.tm_mon = 0; 2200 if (increment_overflow32(&y, 1)) 2201 return WRONG; 2202 } 2203 } 2204 #ifdef ckd_add 2205 if (ckd_add(&yourtm.tm_year, y, -TM_YEAR_BASE)) 2206 return WRONG; 2207 #else 2208 if (increment_overflow32(&y, -TM_YEAR_BASE)) 2209 return WRONG; 2210 if (! (INT_MIN <= y && y <= INT_MAX)) 2211 return WRONG; 2212 yourtm.tm_year = y; 2213 #endif 2214 if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN) 2215 saved_seconds = 0; 2216 else if (yourtm.tm_year < EPOCH_YEAR - TM_YEAR_BASE) { 2217 /* 2218 ** We can't set tm_sec to 0, because that might push the 2219 ** time below the minimum representable time. 2220 ** Set tm_sec to 59 instead. 2221 ** This assumes that the minimum representable time is 2222 ** not in the same minute that a leap second was deleted from, 2223 ** which is a safer assumption than using 58 would be. 2224 */ 2225 if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN)) 2226 return WRONG; 2227 saved_seconds = yourtm.tm_sec; 2228 yourtm.tm_sec = SECSPERMIN - 1; 2229 } else { 2230 saved_seconds = yourtm.tm_sec; 2231 yourtm.tm_sec = 0; 2232 } 2233 /* 2234 ** Do a binary search (this works whatever time_t's type is). 2235 */ 2236 lo = TIME_T_MIN; 2237 hi = TIME_T_MAX; 2238 for ( ; ; ) { 2239 t = lo / 2 + hi / 2; 2240 if (t < lo) 2241 t = lo; 2242 else if (t > hi) 2243 t = hi; 2244 if (! funcp(sp, &t, offset, &mytm)) { 2245 /* 2246 ** Assume that t is too extreme to be represented in 2247 ** a struct tm; arrange things so that it is less 2248 ** extreme on the next pass. 2249 */ 2250 dir = (t > 0) ? 1 : -1; 2251 } else dir = tmcomp(&mytm, &yourtm); 2252 if (dir != 0) { 2253 if (t == lo) { 2254 if (t == TIME_T_MAX) 2255 return WRONG; 2256 ++t; 2257 ++lo; 2258 } else if (t == hi) { 2259 if (t == TIME_T_MIN) 2260 return WRONG; 2261 --t; 2262 --hi; 2263 } 2264 if (lo > hi) 2265 return WRONG; 2266 if (dir > 0) 2267 hi = t; 2268 else lo = t; 2269 continue; 2270 } 2271 #if defined TM_GMTOFF && ! UNINIT_TRAP 2272 if (mytm.TM_GMTOFF != yourtm.TM_GMTOFF 2273 && (yourtm.TM_GMTOFF < 0 2274 ? (-SECSPERDAY <= yourtm.TM_GMTOFF 2275 && (mytm.TM_GMTOFF <= 2276 (min(INT_FAST32_MAX, LONG_MAX) 2277 + yourtm.TM_GMTOFF))) 2278 : (yourtm.TM_GMTOFF <= SECSPERDAY 2279 && ((max(INT_FAST32_MIN, LONG_MIN) 2280 + yourtm.TM_GMTOFF) 2281 <= mytm.TM_GMTOFF)))) { 2282 /* MYTM matches YOURTM except with the wrong UT offset. 2283 YOURTM.TM_GMTOFF is plausible, so try it instead. 2284 It's OK if YOURTM.TM_GMTOFF contains uninitialized data, 2285 since the guess gets checked. */ 2286 time_t altt = t; 2287 int_fast32_t diff = mytm.TM_GMTOFF - yourtm.TM_GMTOFF; 2288 if (!increment_overflow_time(&altt, diff)) { 2289 struct tm alttm; 2290 if (funcp(sp, &altt, offset, &alttm) 2291 && alttm.tm_isdst == mytm.tm_isdst 2292 && alttm.TM_GMTOFF == yourtm.TM_GMTOFF 2293 && tmcomp(&alttm, &yourtm) == 0) { 2294 t = altt; 2295 mytm = alttm; 2296 } 2297 } 2298 } 2299 #endif 2300 if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst) 2301 break; 2302 /* 2303 ** Right time, wrong type. 2304 ** Hunt for right time, right type. 2305 ** It's okay to guess wrong since the guess 2306 ** gets checked. 2307 */ 2308 if (sp == NULL) 2309 return WRONG; 2310 for (i = sp->typecnt - 1; i >= 0; --i) { 2311 if (sp->ttis[i].tt_isdst != yourtm.tm_isdst) 2312 continue; 2313 for (j = sp->typecnt - 1; j >= 0; --j) { 2314 if (sp->ttis[j].tt_isdst == yourtm.tm_isdst) 2315 continue; 2316 if (ttunspecified(sp, j)) 2317 continue; 2318 newt = (t + sp->ttis[j].tt_utoff 2319 - sp->ttis[i].tt_utoff); 2320 if (! funcp(sp, &newt, offset, &mytm)) 2321 continue; 2322 if (tmcomp(&mytm, &yourtm) != 0) 2323 continue; 2324 if (mytm.tm_isdst != yourtm.tm_isdst) 2325 continue; 2326 /* 2327 ** We have a match. 2328 */ 2329 t = newt; 2330 goto label; 2331 } 2332 } 2333 return WRONG; 2334 } 2335 label: 2336 newt = t + saved_seconds; 2337 if ((newt < t) != (saved_seconds < 0)) 2338 return WRONG; 2339 t = newt; 2340 if (funcp(sp, &t, offset, tmp)) 2341 *okayp = true; 2342 return t; 2343 } 2344 2345 static time_t 2346 time2(struct tm * const tmp, 2347 struct tm *(*funcp)(struct state const *, time_t const *, 2348 int_fast32_t, struct tm *), 2349 struct state const *sp, 2350 const int_fast32_t offset, 2351 bool *okayp) 2352 { 2353 time_t t; 2354 2355 /* 2356 ** First try without normalization of seconds 2357 ** (in case tm_sec contains a value associated with a leap second). 2358 ** If that fails, try with normalization of seconds. 2359 */ 2360 t = time2sub(tmp, funcp, sp, offset, okayp, false); 2361 return *okayp ? t : time2sub(tmp, funcp, sp, offset, okayp, true); 2362 } 2363 2364 static time_t 2365 time1(struct tm *const tmp, 2366 struct tm *(*funcp)(struct state const *, time_t const *, 2367 int_fast32_t, struct tm *), 2368 struct state const *sp, 2369 const int_fast32_t offset) 2370 { 2371 register time_t t; 2372 register int samei, otheri; 2373 register int sameind, otherind; 2374 register int i; 2375 register int nseen; 2376 char seen[TZ_MAX_TYPES]; 2377 unsigned char types[TZ_MAX_TYPES]; 2378 bool okay; 2379 2380 if (tmp == NULL) { 2381 errno = EINVAL; 2382 return WRONG; 2383 } 2384 2385 if (tmp->tm_isdst > 1) 2386 tmp->tm_isdst = 1; 2387 t = time2(tmp, funcp, sp, offset, &okay); 2388 if (okay) 2389 return t; 2390 if (tmp->tm_isdst < 0) 2391 #ifdef PCTS 2392 /* 2393 ** POSIX Conformance Test Suite code courtesy Grant Sullivan. 2394 */ 2395 tmp->tm_isdst = 0; /* reset to std and try again */ 2396 #else 2397 return t; 2398 #endif /* !defined PCTS */ 2399 /* 2400 ** We're supposed to assume that somebody took a time of one type 2401 ** and did some math on it that yielded a "struct tm" that's bad. 2402 ** We try to divine the type they started from and adjust to the 2403 ** type they need. 2404 */ 2405 if (sp == NULL) 2406 return WRONG; 2407 for (i = 0; i < sp->typecnt; ++i) 2408 seen[i] = false; 2409 nseen = 0; 2410 for (i = sp->timecnt - 1; i >= 0; --i) 2411 if (!seen[sp->types[i]] && !ttunspecified(sp, sp->types[i])) { 2412 seen[sp->types[i]] = true; 2413 types[nseen++] = sp->types[i]; 2414 } 2415 for (sameind = 0; sameind < nseen; ++sameind) { 2416 samei = types[sameind]; 2417 if (sp->ttis[samei].tt_isdst != tmp->tm_isdst) 2418 continue; 2419 for (otherind = 0; otherind < nseen; ++otherind) { 2420 otheri = types[otherind]; 2421 if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst) 2422 continue; 2423 tmp->tm_sec += (sp->ttis[otheri].tt_utoff 2424 - sp->ttis[samei].tt_utoff); 2425 tmp->tm_isdst = !tmp->tm_isdst; 2426 t = time2(tmp, funcp, sp, offset, &okay); 2427 if (okay) 2428 return t; 2429 tmp->tm_sec -= (sp->ttis[otheri].tt_utoff 2430 - sp->ttis[samei].tt_utoff); 2431 tmp->tm_isdst = !tmp->tm_isdst; 2432 } 2433 } 2434 return WRONG; 2435 } 2436 2437 static time_t 2438 mktime_tzname(struct state *sp, struct tm *tmp, bool setname) 2439 { 2440 if (sp) 2441 return time1(tmp, localsub, sp, setname); 2442 else { 2443 _once(&gmt_once, gmtcheck); 2444 return time1(tmp, gmtsub, gmtptr, 0); 2445 } 2446 } 2447 2448 #if NETBSD_INSPIRED 2449 2450 time_t 2451 mktime_z(struct state *sp, struct tm *tmp) 2452 { 2453 return mktime_tzname(sp, tmp, false); 2454 } 2455 2456 #endif 2457 2458 time_t 2459 mktime(struct tm *tmp) 2460 { 2461 time_t t; 2462 int err = lock(); 2463 if (err) { 2464 errno = err; 2465 return -1; 2466 } 2467 tzset_unlocked(); 2468 t = mktime_tzname(lclptr, tmp, true); 2469 unlock(); 2470 return t; 2471 } 2472 2473 #ifdef STD_INSPIRED 2474 time_t 2475 timelocal(struct tm *tmp) 2476 { 2477 if (tmp != NULL) 2478 tmp->tm_isdst = -1; /* in case it wasn't initialized */ 2479 return mktime(tmp); 2480 } 2481 #else 2482 static 2483 #endif 2484 time_t 2485 timeoff(struct tm *tmp, long offset) 2486 { 2487 if (tmp) 2488 tmp->tm_isdst = 0; 2489 _once(&gmt_once, gmtcheck); 2490 return time1(tmp, gmtsub, gmtptr, offset); 2491 } 2492 2493 time_t 2494 timegm(struct tm *tmp) 2495 { 2496 time_t t; 2497 struct tm tmcpy; 2498 mktmcpy(&tmcpy, tmp); 2499 tmcpy.tm_wday = -1; 2500 t = timeoff(&tmcpy, 0); 2501 if (0 <= tmcpy.tm_wday) 2502 *tmp = tmcpy; 2503 return t; 2504 } 2505 2506 static int_fast32_t 2507 leapcorr(struct state const *sp, time_t t) 2508 { 2509 register struct lsinfo const * lp; 2510 register int i; 2511 2512 i = sp->leapcnt; 2513 while (--i >= 0) { 2514 lp = &sp->lsis[i]; 2515 if (t >= lp->ls_trans) 2516 return lp->ls_corr; 2517 } 2518 return 0; 2519 } 2520 2521 /* 2522 ** XXX--is the below the right way to conditionalize?? 2523 */ 2524 2525 #ifdef STD_INSPIRED 2526 2527 /* NETBSD_INSPIRED_EXTERN functions are exported to callers if 2528 NETBSD_INSPIRED is defined, and are private otherwise. */ 2529 # if NETBSD_INSPIRED 2530 # define NETBSD_INSPIRED_EXTERN 2531 # else 2532 # define NETBSD_INSPIRED_EXTERN static 2533 # endif 2534 2535 /* 2536 ** IEEE Std 1003.1 (POSIX) says that 536457599 2537 ** shall correspond to "Wed Dec 31 23:59:59 UTC 1986", which 2538 ** is not the case if we are accounting for leap seconds. 2539 ** So, we provide the following conversion routines for use 2540 ** when exchanging timestamps with POSIX conforming systems. 2541 */ 2542 2543 NETBSD_INSPIRED_EXTERN time_t 2544 time2posix_z(struct state *sp, time_t t) 2545 { 2546 return t - leapcorr(sp, t); 2547 } 2548 2549 time_t 2550 time2posix(time_t t) 2551 { 2552 int err = lock(); 2553 if (err) { 2554 errno = err; 2555 return -1; 2556 } 2557 #ifndef DETECT_TZ_CHANGES 2558 if (!lcl_is_set) 2559 #endif 2560 tzset_unlocked(); 2561 if (lclptr) 2562 t = time2posix_z(lclptr, t); 2563 unlock(); 2564 return t; 2565 } 2566 2567 NETBSD_INSPIRED_EXTERN time_t 2568 posix2time_z(struct state *sp, time_t t) 2569 { 2570 time_t x; 2571 time_t y; 2572 /* 2573 ** For a positive leap second hit, the result 2574 ** is not unique. For a negative leap second 2575 ** hit, the corresponding time doesn't exist, 2576 ** so we return an adjacent second. 2577 */ 2578 x = t + leapcorr(sp, t); 2579 y = x - leapcorr(sp, x); 2580 if (y < t) { 2581 do { 2582 x++; 2583 y = x - leapcorr(sp, x); 2584 } while (y < t); 2585 x -= y != t; 2586 } else if (y > t) { 2587 do { 2588 --x; 2589 y = x - leapcorr(sp, x); 2590 } while (y > t); 2591 x += y != t; 2592 } 2593 return x; 2594 } 2595 2596 time_t 2597 posix2time(time_t t) 2598 { 2599 int err = lock(); 2600 if (err) { 2601 errno = err; 2602 return -1; 2603 } 2604 #ifndef DETECT_TZ_CHANGES 2605 if (!lcl_is_set) 2606 #endif 2607 tzset_unlocked(); 2608 if (lclptr) 2609 t = posix2time_z(lclptr, t); 2610 unlock(); 2611 return t; 2612 } 2613 2614 #endif /* defined STD_INSPIRED */ 2615 2616 #if TZ_TIME_T 2617 2618 # if !USG_COMPAT 2619 # define daylight 0 2620 # define timezone 0 2621 # endif 2622 # if !ALTZONE 2623 # define altzone 0 2624 # endif 2625 2626 /* Convert from the underlying system's time_t to the ersatz time_tz, 2627 which is called 'time_t' in this file. Typically, this merely 2628 converts the time's integer width. On some platforms, the system 2629 time is local time not UT, or uses some epoch other than the POSIX 2630 epoch. 2631 2632 Although this code appears to define a function named 'time' that 2633 returns time_t, the macros in private.h cause this code to actually 2634 define a function named 'tz_time' that returns tz_time_t. The call 2635 to sys_time invokes the underlying system's 'time' function. */ 2636 2637 time_t 2638 time(time_t *p) 2639 { 2640 time_t r = sys_time(0); 2641 if (r != (time_t) -1) { 2642 int_fast32_t offset = EPOCH_LOCAL ? (daylight ? timezone : altzone) : 0; 2643 if (increment_overflow32(&offset, -EPOCH_OFFSET) 2644 || increment_overflow_time(&r, offset)) { 2645 errno = EOVERFLOW; 2646 r = -1; 2647 } 2648 } 2649 if (p) 2650 *p = r; 2651 return r; 2652 } 2653 2654 #endif 2655