diff --git a/contrib/tzcode/localtime.c b/contrib/tzcode/localtime.c index 7ba72d730648..a8f97e31a4bb 100644 --- a/contrib/tzcode/localtime.c +++ b/contrib/tzcode/localtime.c @@ -1,2840 +1,2840 @@ /* Convert timestamp from time_t to struct tm. */ /* ** This file is in the public domain, so clarified as of ** 1996-06-05 by Arthur David Olson. */ /* ** Leap second handling from Bradley White. ** POSIX.1-1988 style TZ environment variable handling from Guy Harris. */ /*LINTLIBRARY*/ #define LOCALTIME_IMPLEMENTATION #ifdef __FreeBSD__ #include "namespace.h" #include #endif /* __FreeBSD__ */ #ifdef DETECT_TZ_CHANGES # ifndef DETECT_TZ_CHANGES_INTERVAL # define DETECT_TZ_CHANGES_INTERVAL 61 # endif int __tz_change_interval = DETECT_TZ_CHANGES_INTERVAL; # include #endif /* DETECT_TZ_CHANGES */ #include "private.h" #include "tzdir.h" #include "tzfile.h" #include #ifdef __FreeBSD__ #include "libc_private.h" #include "un-namespace.h" #endif /* __FreeBSD__ */ #if HAVE_SYS_STAT_H # include #endif #if !defined S_ISREG && defined S_IFREG /* Ancient UNIX or recent MS-Windows. */ # define S_ISREG(mode) (((mode) & S_IFMT) == S_IFREG) #endif #if defined THREAD_SAFE && THREAD_SAFE # include #ifdef __FreeBSD__ # define pthread_mutex_lock(l) (__isthreaded ? _pthread_mutex_lock(l) : 0) # define pthread_mutex_unlock(l) (__isthreaded ? _pthread_mutex_unlock(l) : 0) #endif /* __FreeBSD__ */ static pthread_mutex_t locallock = PTHREAD_MUTEX_INITIALIZER; static int lock(void) { return pthread_mutex_lock(&locallock); } static void unlock(void) { pthread_mutex_unlock(&locallock); } #else static int lock(void) { return 0; } static void unlock(void) { } #endif /* Unless intptr_t is missing, pacify gcc -Wcast-qual on char const * exprs. Use this carefully, as the casts disable type checking. This is a macro so that it can be used in static initializers. */ #ifdef INTPTR_MAX # define UNCONST(a) ((char *) (intptr_t) (a)) #else # define UNCONST(a) ((char *) (a)) #endif /* A signed type wider than int, so that we can add 1900 + tm_mon/12 to tm_year without overflow. The static_assert checks that it is indeed wider than int; if this fails on your platform please let us know. */ #if INT_MAX < LONG_MAX typedef long iinntt; # define IINNTT_MIN LONG_MIN # define IINNTT_MAX LONG_MAX #elif INT_MAX < LLONG_MAX typedef long long iinntt; # define IINNTT_MIN LLONG_MIN # define IINNTT_MAX LLONG_MAX #else typedef intmax_t iinntt; # define IINNTT_MIN INTMAX_MIN # define IINNTT_MAX INTMAX_MAX #endif static_assert(IINNTT_MIN < INT_MIN && INT_MAX < IINNTT_MAX); /* On platforms where offtime or mktime might overflow, strftime.c defines USE_TIMEX_T to be true and includes us. This tells us to #define time_t to an internal type timex_t that is wide enough so that strftime %s never suffers from integer overflow, and to #define offtime (if TM_GMTOFF is defined) or mktime (otherwise) to a static function that returns the redefined time_t. It also tells us to define only data and code needed to support the offtime or mktime variant. */ #ifndef USE_TIMEX_T # define USE_TIMEX_T false #endif #if USE_TIMEX_T # undef TIME_T_MIN # undef TIME_T_MAX # undef time_t # define time_t timex_t # if MKTIME_FITS_IN(LONG_MIN, LONG_MAX) typedef long timex_t; # define TIME_T_MIN LONG_MIN # define TIME_T_MAX LONG_MAX # elif MKTIME_FITS_IN(LLONG_MIN, LLONG_MAX) typedef long long timex_t; # define TIME_T_MIN LLONG_MIN # define TIME_T_MAX LLONG_MAX # else typedef intmax_t timex_t; # define TIME_T_MIN INTMAX_MIN # define TIME_T_MAX INTMAX_MAX # endif # ifdef TM_GMTOFF # undef timeoff # define timeoff timex_timeoff # undef EXTERN_TIMEOFF # else # undef mktime # define mktime timex_mktime # endif #endif #ifndef TZ_ABBR_CHAR_SET # define TZ_ABBR_CHAR_SET \ "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._" #endif /* !defined TZ_ABBR_CHAR_SET */ #ifndef TZ_ABBR_ERR_CHAR # define TZ_ABBR_ERR_CHAR '_' #endif /* !defined TZ_ABBR_ERR_CHAR */ /* Port to platforms that lack some O_* flags. Unless otherwise specified, the flags are standardized by POSIX. */ #ifndef O_BINARY # define O_BINARY 0 /* MS-Windows */ #endif #ifndef O_CLOEXEC # define O_CLOEXEC 0 #endif #ifndef O_CLOFORK # define O_CLOFORK 0 #endif #ifndef O_IGNORE_CTTY # define O_IGNORE_CTTY 0 /* GNU/Hurd */ #endif #ifndef O_NOCTTY # define O_NOCTTY 0 #endif #ifndef WILDABBR /* ** Someone might make incorrect use of a time zone abbreviation: ** 1. They might reference tzname[0] before calling tzset (explicitly ** or implicitly). ** 2. They might reference tzname[1] before calling tzset (explicitly ** or implicitly). ** 3. They might reference tzname[1] after setting to a time zone ** in which Daylight Saving Time is never observed. ** 4. They might reference tzname[0] after setting to a time zone ** in which Standard Time is never observed. ** 5. They might reference tm.TM_ZONE after calling offtime. ** What's best to do in the above cases is open to debate; ** for now, we just set things up so that in any of the five cases ** WILDABBR is used. Another possibility: initialize tzname[0] to the ** string "tzname[0] used before set", and similarly for the other cases. ** And another: initialize tzname[0] to "ERA", with an explanation in the ** manual page of what this "time zone abbreviation" means (doing this so ** that tzname[0] has the "normal" length of three characters). */ # define WILDABBR " " #endif /* !defined WILDABBR */ static const char wildabbr[] = WILDABBR; static char const etc_utc[] = "Etc/UTC"; #if !USE_TIMEX_T || defined TM_ZONE || !defined TM_GMTOFF static char const *utc = etc_utc + sizeof "Etc/" - 1; #endif /* ** The DST rules to use if TZ has no rules and we can't load TZDEFRULES. ** Default to US rules as of 2017-05-07. ** POSIX does not specify the default DST rules; ** for historical reasons, US rules are a common default. */ #ifndef TZDEFRULESTRING # define TZDEFRULESTRING ",M3.2.0,M11.1.0" #endif /* Limit to time zone abbreviation length in proleptic TZ strings. This is distinct from TZ_MAX_CHARS, which limits TZif file contents. It defaults to 254, not 255, so that desigidx_type can be an unsigned char. unsigned char suffices for TZif files, so the only reason to increase TZNAME_MAXIMUM is to support TZ strings specifying abbreviations longer than 254 bytes. There is little reason to do that, though, as strings that long are hardly "abbreviations". */ #ifndef TZNAME_MAXIMUM # define TZNAME_MAXIMUM 254 #endif #if TZNAME_MAXIMUM < UCHAR_MAX typedef unsigned char desigidx_type; #elif TZNAME_MAXIMUM < INT_MAX typedef int desigidx_type; #elif TZNAME_MAXIMUM < PTRDIFF_MAX typedef ptrdiff_t desigidx_type; #else # error "TZNAME_MAXIMUM too large" #endif struct ttinfo { /* time type information */ int_least32_t tt_utoff; /* UT offset in seconds */ desigidx_type tt_desigidx; /* abbreviation list index */ bool tt_isdst; /* used to set tm_isdst */ bool tt_ttisstd; /* transition is std time */ bool tt_ttisut; /* transition is UT */ }; struct lsinfo { /* leap second information */ time_t ls_trans; /* transition time */ int_fast32_t ls_corr; /* correction to apply */ }; /* This abbreviation means local time is unspecified. */ static char const UNSPEC[] = "-00"; /* How many extra bytes are needed at the end of struct state's chars array. This needs to be at least 1 for null termination in case the input data isn't properly terminated, and it also needs to be big enough for ttunspecified to work without crashing. */ enum { CHARS_EXTRA = max(sizeof UNSPEC, 2) - 1 }; /* A representation of the contents of a TZif file. Ideally this would have no size limits; the following sizes should suffice for practical use. This struct should not be too large, as instances are put on the stack and stacks are relatively small on some platforms. See tzfile.h for more about the sizes. */ struct state { int leapcnt; int timecnt; int typecnt; int charcnt; bool goback; bool goahead; time_t ats[TZ_MAX_TIMES]; unsigned char types[TZ_MAX_TIMES]; struct ttinfo ttis[TZ_MAX_TYPES]; char chars[max(max(TZ_MAX_CHARS + CHARS_EXTRA, sizeof "UTC"), 2 * (TZNAME_MAXIMUM + 1))]; struct lsinfo lsis[TZ_MAX_LEAPS]; }; enum r_type { JULIAN_DAY, /* Jn = Julian day */ DAY_OF_YEAR, /* n = day of year */ MONTH_NTH_DAY_OF_WEEK /* Mm.n.d = month, week, day of week */ }; struct rule { enum r_type r_type; /* type of rule */ int r_day; /* day number of rule */ int r_week; /* week number of rule */ int r_mon; /* month number of rule */ int_fast32_t r_time; /* transition time of rule */ }; #ifdef __FreeBSD__ static void tzset_unlocked_name(char const *); #endif /* __FreeBSD__ */ static struct tm *gmtsub(struct state const *, time_t const *, int_fast32_t, struct tm *); static bool increment_overflow(int *, int); static bool increment_overflow_time(time_t *, int_fast32_t); static int_fast32_t leapcorr(struct state const *, time_t); static struct tm *timesub(time_t const *, int_fast32_t, struct state const *, struct tm *); static bool tzparse(char const *, struct state *, struct state const *); #ifdef ALL_STATE static struct state * lclptr; static struct state * gmtptr; #endif /* defined ALL_STATE */ #ifndef ALL_STATE static struct state lclmem; static struct state gmtmem; static struct state *const lclptr = &lclmem; static struct state *const gmtptr = &gmtmem; #endif /* State Farm */ #ifndef TZ_STRLEN_MAX # define TZ_STRLEN_MAX 255 #endif /* !defined TZ_STRLEN_MAX */ #if !USE_TIMEX_T || !defined TM_GMTOFF static char lcl_TZname[TZ_STRLEN_MAX + 1]; static int lcl_is_set; #endif #ifdef __FreeBSD__ static pthread_once_t gmt_once = PTHREAD_ONCE_INIT; static pthread_once_t gmtime_once = PTHREAD_ONCE_INIT; static pthread_key_t gmtime_key; static int gmtime_key_error; static pthread_once_t offtime_once = PTHREAD_ONCE_INIT; static pthread_key_t offtime_key; static int offtime_key_error; static pthread_once_t localtime_once = PTHREAD_ONCE_INIT; static pthread_key_t localtime_key; static int localtime_key_error; #endif /* __FreeBSD__ */ /* ** Section 4.12.3 of X3.159-1989 requires that ** Except for the strftime function, these functions [asctime, ** ctime, gmtime, localtime] return values in one of two static ** objects: a broken-down time structure and an array of char. ** Thanks to Paul Eggert for noting this. ** ** Although this requirement was removed in C99 it is still present in POSIX. ** Follow the requirement if SUPPORT_C89, even though this is more likely to ** trigger latent bugs in programs. */ #if !USE_TIMEX_T # if SUPPORT_C89 static struct tm tm; #endif # if 2 <= HAVE_TZNAME + TZ_TIME_T char *tzname[2] = { UNCONST(wildabbr), UNCONST(wildabbr) }; # endif # if 2 <= USG_COMPAT + TZ_TIME_T long timezone; int daylight; # endif # if 2 <= ALTZONE + TZ_TIME_T long altzone; # endif #endif /* Initialize *S to a value based on UTOFF, ISDST, and DESIGIDX. */ static void init_ttinfo(struct ttinfo *s, int_fast32_t utoff, bool isdst, desigidx_type desigidx) { s->tt_utoff = utoff; s->tt_isdst = isdst; s->tt_desigidx = desigidx; s->tt_ttisstd = false; s->tt_ttisut = false; } /* Return true if SP's time type I does not specify local time. */ static bool ttunspecified(struct state const *sp, int i) { char const *abbr = &sp->chars[sp->ttis[i].tt_desigidx]; /* memcmp is likely faster than strcmp, and is safe due to CHARS_EXTRA. */ return memcmp(abbr, UNSPEC, sizeof UNSPEC) == 0; } static int_fast32_t detzcode(const char *const codep) { register int_fast32_t result; register int i; int_fast32_t one = 1; int_fast32_t halfmaxval = one << (32 - 2); int_fast32_t maxval = halfmaxval - 1 + halfmaxval; int_fast32_t minval = -1 - maxval; result = codep[0] & 0x7f; for (i = 1; i < 4; ++i) result = (result << 8) | (codep[i] & 0xff); if (codep[0] & 0x80) { /* Do two's-complement negation even on non-two's-complement machines. If the result would be minval - 1, return minval. */ result -= !TWOS_COMPLEMENT(int_fast32_t) && result != 0; result += minval; } return result; } static int_fast64_t detzcode64(const char *const codep) { register int_fast64_t result; register int i; int_fast64_t one = 1; int_fast64_t halfmaxval = one << (64 - 2); int_fast64_t maxval = halfmaxval - 1 + halfmaxval; int_fast64_t minval = -TWOS_COMPLEMENT(int_fast64_t) - maxval; result = codep[0] & 0x7f; for (i = 1; i < 8; ++i) result = (result << 8) | (codep[i] & 0xff); if (codep[0] & 0x80) { /* Do two's-complement negation even on non-two's-complement machines. If the result would be minval - 1, return minval. */ result -= !TWOS_COMPLEMENT(int_fast64_t) && result != 0; result += minval; } return result; } #if !USE_TIMEX_T || !defined TM_GMTOFF static void update_tzname_etc(struct state const *sp, struct ttinfo const *ttisp) { # if HAVE_TZNAME tzname[ttisp->tt_isdst] = UNCONST(&sp->chars[ttisp->tt_desigidx]); # endif # if USG_COMPAT if (!ttisp->tt_isdst) timezone = - ttisp->tt_utoff; # endif # if ALTZONE if (ttisp->tt_isdst) altzone = - ttisp->tt_utoff; # endif } /* If STDDST_MASK indicates that SP's TYPE provides useful info, update tzname, timezone, and/or altzone and return STDDST_MASK, diminished by the provided info if it is a specified local time. Otherwise, return STDDST_MASK. See settzname for STDDST_MASK. */ static int may_update_tzname_etc(int stddst_mask, struct state *sp, int type) { struct ttinfo *ttisp = &sp->ttis[type]; int this_bit = 1 << ttisp->tt_isdst; if (stddst_mask & this_bit) { update_tzname_etc(sp, ttisp); if (!ttunspecified(sp, type)) return stddst_mask & ~this_bit; } return stddst_mask; } static void settzname(void) { register struct state * const sp = lclptr; register int i; /* If STDDST_MASK & 1 we need info about a standard time. If STDDST_MASK & 2 we need info about a daylight saving time. When STDDST_MASK becomes zero we can stop looking. */ int stddst_mask = 0; # if HAVE_TZNAME tzname[0] = tzname[1] = UNCONST(sp ? wildabbr : utc); stddst_mask = 3; # endif # if USG_COMPAT timezone = 0; stddst_mask = 3; # endif # if ALTZONE altzone = 0; stddst_mask |= 2; # endif /* ** And to get the latest time zone abbreviations into tzname. . . */ if (sp) { for (i = sp->timecnt - 1; stddst_mask && 0 <= i; i--) stddst_mask = may_update_tzname_etc(stddst_mask, sp, sp->types[i]); for (i = sp->typecnt - 1; stddst_mask && 0 <= i; i--) stddst_mask = may_update_tzname_etc(stddst_mask, sp, i); } # if USG_COMPAT daylight = stddst_mask >> 1 ^ 1; # endif } /* Replace bogus characters in time zone abbreviations. Return 0 on success, an errno value if a time zone abbreviation is too long. */ static int scrub_abbrs(struct state *sp) { int i; /* Reject overlong abbreviations. */ for (i = 0; i < sp->charcnt - (TZNAME_MAXIMUM + 1); ) { int len = strlen(&sp->chars[i]); if (TZNAME_MAXIMUM < len) return EOVERFLOW; i += len + 1; } /* Replace bogus characters. */ for (i = 0; i < sp->charcnt; ++i) if (strchr(TZ_ABBR_CHAR_SET, sp->chars[i]) == NULL) sp->chars[i] = TZ_ABBR_ERR_CHAR; return 0; } #endif #ifdef DETECT_TZ_CHANGES /* * Check whether either the time zone name or the file it refers to has * changed since the last time we checked. * Returns: -1 on error * 0 if the time zone has not changed * 1 if the time zone has changed */ static int tzfile_changed(const char *name, int fd) { static char old_name[PATH_MAX]; static struct stat old_sb; struct stat sb; if (_fstat(fd, &sb) != 0) return -1; if (strcmp(name, old_name) != 0) { strlcpy(old_name, name, sizeof(old_name)); old_sb = sb; return 1; } if (sb.st_dev != old_sb.st_dev || sb.st_ino != old_sb.st_ino || sb.st_ctime != old_sb.st_ctime || sb.st_mtime != old_sb.st_mtime) { old_sb = sb; return 1; } return 0; } #endif /* DETECT_TZ_CHANGES */ /* Input buffer for data read from a compiled tz file. */ union input_buffer { /* The first part of the buffer, interpreted as a header. */ struct tzhead tzhead; /* The entire buffer. Ideally this would have no size limits; the following should suffice for practical use. */ char buf[2 * sizeof(struct tzhead) + 2 * sizeof(struct state) + 4 * TZ_MAX_TIMES]; }; #ifndef __FreeBSD__ /* TZDIR with a trailing '/' rather than a trailing '\0'. */ static char const tzdirslash[sizeof TZDIR] = TZDIR "/"; #endif /* !__FreeBSD__ */ /* Local storage needed for 'tzloadbody'. */ union local_storage { /* The results of analyzing the file's contents after it is opened. */ struct file_analysis { /* The input buffer. */ union input_buffer u; /* A temporary state used for parsing a TZ string in the file. */ struct state st; } u; #ifndef __FreeBSD__ /* The name of the file to be opened. Ideally this would have no size limits, to support arbitrarily long Zone names. Limiting Zone names to 1024 bytes should suffice for practical use. However, there is no need for this to be smaller than struct file_analysis as that struct is allocated anyway, as the other union member. */ char fullname[max(sizeof(struct file_analysis), sizeof tzdirslash + 1024)]; #endif /* !__FreeBSD__ */ }; /* These tzload flags can be ORed together, and fit into 'char'. */ enum { TZLOAD_FROMENV = 1 }; /* The TZ string came from the environment. */ enum { TZLOAD_TZSTRING = 2 }; /* Read any newline-surrounded TZ string. */ /* Load tz data from the file named NAME into *SP. Respect TZLOADFLAGS. Use *LSP for temporary storage. Return 0 on success, an errno value on failure. */ static int tzloadbody(char const *name, struct state *sp, char tzloadflags, union local_storage *lsp) { register int i; register int fid; register int stored; register ssize_t nread; #ifdef __FreeBSD__ struct stat sb; const char *relname; int dd, serrno; #else /* !__FreeBSD__ */ register bool doaccess; #endif /* !__FreeBSD__ */ register union input_buffer *up = &lsp->u.u; register int tzheadsize = sizeof(struct tzhead); sp->goback = sp->goahead = false; if (! name) { name = TZDEFAULT; if (! name) return EINVAL; tzloadflags &= ~TZLOAD_FROMENV; } if (name[0] == ':') ++name; #ifndef __FreeBSD__ #ifdef SUPPRESS_TZDIR /* Do not prepend TZDIR. This is intended for specialized applications only, due to its security implications. */ doaccess = true; #else doaccess = name[0] == '/'; #endif if (!doaccess) { char const *dot; if (sizeof lsp->fullname - sizeof tzdirslash <= strlen(name)) return ENAMETOOLONG; /* Create a string "TZDIR/NAME". Using sprintf here would pull in stdio (and would fail if the resulting string length exceeded INT_MAX!). */ memcpy(lsp->fullname, tzdirslash, sizeof tzdirslash); strcpy(lsp->fullname + sizeof tzdirslash, name); /* Set doaccess if NAME contains a ".." file name component, as such a name could read a file outside the TZDIR virtual subtree. */ for (dot = name; (dot = strchr(dot, '.')); dot++) if ((dot == name || dot[-1] == '/') && dot[1] == '.' && (dot[2] == '/' || !dot[2])) { doaccess = true; break; } name = lsp->fullname; } if (doaccess && (tzloadflags & TZLOAD_FROMENV)) { /* Check for security violations and for devices whose mere opening could have unwanted side effects. Although these checks are racy, they're better than nothing and there is no portable way to fix the races. */ if (access(name, R_OK) < 0) return errno; #ifdef S_ISREG { struct stat st; if (stat(name, &st) < 0) return errno; if (!S_ISREG(st.st_mode)) return EINVAL; } #endif } fid = _open(name, (O_RDONLY | O_BINARY | O_CLOEXEC | O_CLOFORK | O_IGNORE_CTTY | O_NOCTTY)); #else /* __FreeBSD__ */ if ((tzloadflags & TZLOAD_FROMENV) && strcmp(name, TZDEFAULT) == 0) tzloadflags &= ~TZLOAD_FROMENV; relname = name; if (strncmp(relname, TZDIR "/", strlen(TZDIR) + 1) == 0) relname += strlen(TZDIR) + 1; dd = _open(TZDIR, O_DIRECTORY | O_RDONLY); if ((tzloadflags & TZLOAD_FROMENV) && issetugid()) { if (dd < 0) return errno; if (fstatat(dd, name, &sb, AT_RESOLVE_BENEATH) < 0) { fid = -1; } else if (!S_ISREG(sb.st_mode)) { fid = -1; errno = EINVAL; } else { fid = _openat(dd, relname, O_RDONLY | O_BINARY, AT_RESOLVE_BENEATH); } } else { if (dd < 0) { relname = name; dd = AT_FDCWD; } fid = _openat(dd, relname, O_RDONLY | O_BINARY, 0); } if (dd != AT_FDCWD && dd >= 0) { serrno = errno; _close(dd); errno = serrno; } #endif /* __FreeBSD__ */ if (fid < 0) return errno; #ifdef DETECT_TZ_CHANGES if (tzloadflags) { /* * Detect if the timezone file has changed. Check tzloadflags * to ignore TZDEFRULES; the tzfile_changed() function can only * keep state for a single file. */ switch (tzfile_changed(name, fid)) { case -1: serrno = errno; _close(fid); return serrno; case 0: _close(fid); return 0; case 1: break; } } #endif /* DETECT_TZ_CHANGES */ nread = _read(fid, up->buf, sizeof up->buf); if (nread < tzheadsize) { int err = nread < 0 ? errno : EINVAL; _close(fid); return err; } if (_close(fid) < 0) return errno; for (stored = 4; stored <= 8; stored *= 2) { char version = up->tzhead.tzh_version[0]; bool skip_datablock = stored == 4 && version; int_fast32_t datablock_size; int_fast32_t ttisstdcnt = detzcode(up->tzhead.tzh_ttisstdcnt); int_fast32_t ttisutcnt = detzcode(up->tzhead.tzh_ttisutcnt); int_fast64_t prevtr = -1; int_fast32_t prevcorr; int_fast32_t leapcnt = detzcode(up->tzhead.tzh_leapcnt); int_fast32_t timecnt = detzcode(up->tzhead.tzh_timecnt); int_fast32_t typecnt = detzcode(up->tzhead.tzh_typecnt); int_fast32_t charcnt = detzcode(up->tzhead.tzh_charcnt); char const *p = up->buf + tzheadsize; /* Although tzfile(5) currently requires typecnt to be nonzero, support future formats that may allow zero typecnt in files that have a TZ string and no transitions. */ if (! (0 <= leapcnt && leapcnt < TZ_MAX_LEAPS && 0 <= typecnt && typecnt < TZ_MAX_TYPES && 0 <= timecnt && timecnt < TZ_MAX_TIMES && 0 <= charcnt && charcnt < TZ_MAX_CHARS && 0 <= ttisstdcnt && ttisstdcnt < TZ_MAX_TYPES && 0 <= ttisutcnt && ttisutcnt < TZ_MAX_TYPES)) return EINVAL; datablock_size = (timecnt * stored /* ats */ + timecnt /* types */ + typecnt * 6 /* ttinfos */ + charcnt /* chars */ + leapcnt * (stored + 4) /* lsinfos */ + ttisstdcnt /* ttisstds */ + ttisutcnt); /* ttisuts */ if (nread < tzheadsize + datablock_size) return EINVAL; if (skip_datablock) p += datablock_size; else { if (! ((ttisstdcnt == typecnt || ttisstdcnt == 0) && (ttisutcnt == typecnt || ttisutcnt == 0))) return EINVAL; sp->leapcnt = leapcnt; sp->timecnt = timecnt; sp->typecnt = typecnt; sp->charcnt = charcnt; /* Read transitions, discarding those out of time_t range. But pretend the last transition before TIME_T_MIN occurred at TIME_T_MIN. */ timecnt = 0; for (i = 0; i < sp->timecnt; ++i) { int_fast64_t at = stored == 4 ? detzcode(p) : detzcode64(p); sp->types[i] = at <= TIME_T_MAX; if (sp->types[i]) { time_t attime = ((TYPE_SIGNED(time_t) ? at < TIME_T_MIN : at < 0) ? TIME_T_MIN : at); if (timecnt && attime <= sp->ats[timecnt - 1]) { if (attime < sp->ats[timecnt - 1]) return EINVAL; sp->types[i - 1] = 0; timecnt--; } sp->ats[timecnt++] = attime; } p += stored; } timecnt = 0; for (i = 0; i < sp->timecnt; ++i) { unsigned char typ = *p++; if (sp->typecnt <= typ) return EINVAL; if (sp->types[i]) sp->types[timecnt++] = typ; } sp->timecnt = timecnt; for (i = 0; i < sp->typecnt; ++i) { register struct ttinfo * ttisp; unsigned char isdst, desigidx; ttisp = &sp->ttis[i]; ttisp->tt_utoff = detzcode(p); p += 4; isdst = *p++; if (! (isdst < 2)) return EINVAL; ttisp->tt_isdst = isdst; desigidx = *p++; if (! (desigidx < sp->charcnt)) return EINVAL; ttisp->tt_desigidx = desigidx; } for (i = 0; i < sp->charcnt; ++i) sp->chars[i] = *p++; /* Ensure '\0'-terminated, and make it safe to call ttunspecified later. */ memset(&sp->chars[i], 0, CHARS_EXTRA); /* Read leap seconds, discarding those out of time_t range. */ leapcnt = 0; for (i = 0; i < sp->leapcnt; ++i) { int_fast64_t tr = stored == 4 ? detzcode(p) : detzcode64(p); int_fast32_t corr = detzcode(p + stored); p += stored + 4; /* Leap seconds cannot occur before the Epoch, or out of order. */ if (tr <= prevtr) return EINVAL; /* To avoid other botches in this code, each leap second's correction must differ from the previous one's by 1 second or less, except that the first correction can be any value; these requirements are more generous than RFC 9636, to allow future RFC extensions. */ if (! (i == 0 || (prevcorr < corr ? corr == prevcorr + 1 : (corr == prevcorr || corr == prevcorr - 1)))) return EINVAL; prevtr = tr; prevcorr = corr; if (tr <= TIME_T_MAX) { sp->lsis[leapcnt].ls_trans = tr; sp->lsis[leapcnt].ls_corr = corr; leapcnt++; } } sp->leapcnt = leapcnt; for (i = 0; i < sp->typecnt; ++i) { register struct ttinfo * ttisp; ttisp = &sp->ttis[i]; if (ttisstdcnt == 0) ttisp->tt_ttisstd = false; else { if (*p != true && *p != false) return EINVAL; ttisp->tt_ttisstd = *p++; } } for (i = 0; i < sp->typecnt; ++i) { register struct ttinfo * ttisp; ttisp = &sp->ttis[i]; if (ttisutcnt == 0) ttisp->tt_ttisut = false; else { if (*p != true && *p != false) return EINVAL; ttisp->tt_ttisut = *p++; } } } nread -= p - up->buf; memmove(up->buf, p, nread); /* If this is an old file, we're done. */ if (!version) break; } if ((tzloadflags & TZLOAD_TZSTRING) && nread > 2 && up->buf[0] == '\n' && up->buf[nread - 1] == '\n' && sp->typecnt + 2 <= TZ_MAX_TYPES) { struct state *ts = &lsp->u.st; up->buf[nread - 1] = '\0'; if (tzparse(&up->buf[1], ts, sp)) { /* Attempt to reuse existing abbreviations. Without this, America/Anchorage would be right on the edge after 2037 when TZ_MAX_CHARS is 50, as sp->charcnt equals 40 (for LMT AST AWT APT AHST AHDT YST AKDT AKST) and ts->charcnt equals 10 (for AKST AKDT). Reusing means sp->charcnt can stay 40 in this example. */ int gotabbr = 0; int charcnt = sp->charcnt; for (i = 0; i < ts->typecnt; i++) { char *tsabbr = ts->chars + ts->ttis[i].tt_desigidx; int j; for (j = 0; j < charcnt; j++) if (strcmp(sp->chars + j, tsabbr) == 0) { ts->ttis[i].tt_desigidx = j; gotabbr++; break; } if (! (j < charcnt)) { int tsabbrlen = strlen(tsabbr); if (j + tsabbrlen < TZ_MAX_CHARS) { strcpy(sp->chars + j, tsabbr); charcnt = j + tsabbrlen + 1; ts->ttis[i].tt_desigidx = j; gotabbr++; } } } if (gotabbr == ts->typecnt) { sp->charcnt = charcnt; /* Ignore any trailing, no-op transitions generated by zic as they don't help here and can run afoul of bugs in zic 2016j or earlier. */ while (1 < sp->timecnt && (sp->types[sp->timecnt - 1] == sp->types[sp->timecnt - 2])) sp->timecnt--; sp->goahead = ts->goahead; for (i = 0; i < ts->timecnt; i++) { time_t t = ts->ats[i]; if (increment_overflow_time(&t, leapcorr(sp, t)) || (0 < sp->timecnt && t <= sp->ats[sp->timecnt - 1])) continue; if (TZ_MAX_TIMES <= sp->timecnt) { sp->goahead = false; break; } sp->ats[sp->timecnt] = t; sp->types[sp->timecnt] = (sp->typecnt + ts->types[i]); sp->timecnt++; } for (i = 0; i < ts->typecnt; i++) sp->ttis[sp->typecnt++] = ts->ttis[i]; } } } if (sp->typecnt == 0) return EINVAL; return 0; } /* Load tz data from the file named NAME into *SP. Respect TZLOADFLAGS. Return 0 on success, an errno value on failure. */ static int tzload(char const *name, struct state *sp, char tzloadflags) { #ifdef ALL_STATE union local_storage *lsp = malloc(sizeof *lsp); if (!lsp) { return HAVE_MALLOC_ERRNO ? errno : ENOMEM; } else { int err = tzloadbody(name, sp, tzloadflags, lsp); free(lsp); return err; } #else union local_storage ls; return tzloadbody(name, sp, tzloadflags, &ls); #endif } static const int mon_lengths[2][MONSPERYEAR] = { { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } }; static const int year_lengths[2] = { DAYSPERNYEAR, DAYSPERLYEAR }; /* Is C an ASCII digit? */ static bool is_digit(char c) { return '0' <= c && c <= '9'; } /* ** Given a pointer into a timezone string, scan until a character that is not ** a valid character in a time zone abbreviation is found. ** Return a pointer to that character. */ ATTRIBUTE_PURE_114833 static const char * getzname(register const char *strp) { register char c; while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' && c != '+') ++strp; return strp; } /* ** Given a pointer into an extended timezone string, scan until the ending ** delimiter of the time zone abbreviation is located. ** Return a pointer to the delimiter. ** ** As with getzname above, the legal character set is actually quite ** restricted, with other characters producing undefined results. ** We don't do any checking here; checking is done later in common-case code. */ ATTRIBUTE_PURE_114833 static const char * getqzname(register const char *strp, const int delim) { register int c; while ((c = *strp) != '\0' && c != delim) ++strp; return strp; } /* ** Given a pointer into a timezone string, extract a number from that string. ** Check that the number is within a specified range; if it is not, return ** NULL. ** Otherwise, return a pointer to the first character not part of the number. */ static const char * getnum(register const char *strp, int *const nump, const int min, const int max) { register char c; register int num; if (strp == NULL || !is_digit(c = *strp)) return NULL; num = 0; do { num = num * 10 + (c - '0'); if (num > max) return NULL; /* illegal value */ c = *++strp; } while (is_digit(c)); if (num < min) return NULL; /* illegal value */ *nump = num; return strp; } /* ** Given a pointer into a timezone string, extract a number of seconds, ** in hh[:mm[:ss]] form, from the string. ** If any error occurs, return NULL. ** Otherwise, return a pointer to the first character not part of the number ** of seconds. */ static const char * getsecs(register const char *strp, int_fast32_t *const secsp) { int num; int_fast32_t secsperhour = SECSPERHOUR; /* ** 'HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-POSIX rules like ** "M10.4.6/26", which does not conform to POSIX, ** but which specifies the equivalent of ** "02:00 on the first Sunday on or after 23 Oct". */ strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1); if (strp == NULL) return NULL; *secsp = num * secsperhour; if (*strp == ':') { ++strp; strp = getnum(strp, &num, 0, MINSPERHOUR - 1); if (strp == NULL) return NULL; *secsp += num * SECSPERMIN; if (*strp == ':') { ++strp; /* 'SECSPERMIN' allows for leap seconds. */ strp = getnum(strp, &num, 0, SECSPERMIN); if (strp == NULL) return NULL; *secsp += num; } } return strp; } /* ** Given a pointer into a timezone string, extract an offset, in ** [+-]hh[:mm[:ss]] form, from the string. ** If any error occurs, return NULL. ** Otherwise, return a pointer to the first character not part of the time. */ static const char * getoffset(register const char *strp, int_fast32_t *const offsetp) { register bool neg = false; if (*strp == '-') { neg = true; ++strp; } else if (*strp == '+') ++strp; strp = getsecs(strp, offsetp); if (strp == NULL) return NULL; /* illegal time */ if (neg) *offsetp = -*offsetp; return strp; } /* ** Given a pointer into a timezone string, extract a rule in the form ** date[/time]. See POSIX Base Definitions section 8.3 variable TZ ** for the format of "date" and "time". ** If a valid rule is not found, return NULL. ** Otherwise, return a pointer to the first character not part of the rule. */ static const char * getrule(const char *strp, register struct rule *const rulep) { if (*strp == 'J') { /* ** Julian day. */ rulep->r_type = JULIAN_DAY; ++strp; strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR); } else if (*strp == 'M') { /* ** Month, week, day. */ rulep->r_type = MONTH_NTH_DAY_OF_WEEK; ++strp; strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR); if (strp == NULL) return NULL; if (*strp++ != '.') return NULL; strp = getnum(strp, &rulep->r_week, 1, 5); if (strp == NULL) return NULL; if (*strp++ != '.') return NULL; strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1); } else if (is_digit(*strp)) { /* ** Day of year. */ rulep->r_type = DAY_OF_YEAR; strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1); } else return NULL; /* invalid format */ if (strp == NULL) return NULL; if (*strp == '/') { /* ** Time specified. */ ++strp; strp = getoffset(strp, &rulep->r_time); } else rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */ return strp; } /* ** Given a year, a rule, and the offset from UT at the time that rule takes ** effect, calculate the year-relative time that rule takes effect. */ static int_fast32_t transtime(const int year, register const struct rule *const rulep, const int_fast32_t offset) { register bool leapyear; register int_fast32_t value; register int i; int d, m1, yy0, yy1, yy2, dow; leapyear = isleap(year); switch (rulep->r_type) { case JULIAN_DAY: /* ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap ** years. ** In non-leap years, or if the day number is 59 or less, just ** add SECSPERDAY times the day number-1 to the time of ** January 1, midnight, to get the day. */ value = (rulep->r_day - 1) * SECSPERDAY; if (leapyear && rulep->r_day >= 60) value += SECSPERDAY; break; case DAY_OF_YEAR: /* ** n - day of year. ** Just add SECSPERDAY times the day number to the time of ** January 1, midnight, to get the day. */ value = rulep->r_day * SECSPERDAY; break; case MONTH_NTH_DAY_OF_WEEK: /* ** Mm.n.d - nth "dth day" of month m. */ /* ** Use Zeller's Congruence to get day-of-week of first day of ** month. */ m1 = (rulep->r_mon + 9) % 12 + 1; yy0 = (rulep->r_mon <= 2) ? (year - 1) : year; yy1 = yy0 / 100; yy2 = yy0 % 100; dow = ((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7; if (dow < 0) dow += DAYSPERWEEK; /* ** "dow" is the day-of-week of the first day of the month. Get ** the day-of-month (zero-origin) of the first "dow" day of the ** month. */ d = rulep->r_day - dow; if (d < 0) d += DAYSPERWEEK; for (i = 1; i < rulep->r_week; ++i) { if (d + DAYSPERWEEK >= mon_lengths[leapyear][rulep->r_mon - 1]) break; d += DAYSPERWEEK; } /* ** "d" is the day-of-month (zero-origin) of the day we want. */ value = d * SECSPERDAY; for (i = 0; i < rulep->r_mon - 1; ++i) value += mon_lengths[leapyear][i] * SECSPERDAY; break; default: unreachable(); } /* ** "value" is the year-relative time of 00:00:00 UT on the day in ** question. To get the year-relative time of the specified local ** time on that day, add the transition time and the current offset ** from UT. */ return value + rulep->r_time + offset; } /* ** Given a POSIX.1 proleptic TZ string, fill in the rule tables as ** appropriate. */ static bool tzparse(const char *name, struct state *sp, struct state const *basep) { const char * stdname; const char * dstname; int_fast32_t stdoffset; int_fast32_t dstoffset; register char * cp; register bool load_ok; ptrdiff_t stdlen, dstlen, charcnt; time_t atlo = TIME_T_MIN, leaplo = TIME_T_MIN; stdname = name; if (*name == '<') { name++; stdname = name; name = getqzname(name, '>'); if (*name != '>') return false; stdlen = name - stdname; name++; } else { name = getzname(name); stdlen = name - stdname; } if (! (0 < stdlen && stdlen <= TZNAME_MAXIMUM)) return false; name = getoffset(name, &stdoffset); if (name == NULL) return false; charcnt = stdlen + 1; if (basep) { if (0 < basep->timecnt) atlo = basep->ats[basep->timecnt - 1]; load_ok = false; sp->leapcnt = basep->leapcnt; memcpy(sp->lsis, basep->lsis, sp->leapcnt * sizeof *sp->lsis); } else { load_ok = tzload(TZDEFRULES, sp, 0) == 0; if (!load_ok) sp->leapcnt = 0; /* So, we're off a little. */ } if (0 < sp->leapcnt) leaplo = sp->lsis[sp->leapcnt - 1].ls_trans; sp->goback = sp->goahead = false; if (*name != '\0') { if (*name == '<') { dstname = ++name; name = getqzname(name, '>'); if (*name != '>') return false; dstlen = name - dstname; name++; } else { dstname = name; name = getzname(name); dstlen = name - dstname; /* length of DST abbr. */ } if (! (0 < dstlen && dstlen <= TZNAME_MAXIMUM)) return false; charcnt += dstlen + 1; if (*name != '\0' && *name != ',' && *name != ';') { name = getoffset(name, &dstoffset); if (name == NULL) return false; } else dstoffset = stdoffset - SECSPERHOUR; if (*name == '\0' && !load_ok) name = TZDEFRULESTRING; if (*name == ',' || *name == ';') { struct rule start; struct rule end; register int year; register int timecnt; time_t janfirst; int_fast32_t janoffset = 0; int yearbeg, yearlim; ++name; if ((name = getrule(name, &start)) == NULL) return false; if (*name++ != ',') return false; if ((name = getrule(name, &end)) == NULL) return false; if (*name != '\0') return false; sp->typecnt = 2; /* standard time and DST */ /* ** Two transitions per year, from EPOCH_YEAR forward. */ init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); init_ttinfo(&sp->ttis[1], -dstoffset, true, stdlen + 1); timecnt = 0; janfirst = 0; yearbeg = EPOCH_YEAR; do { int_fast32_t yearsecs = year_lengths[isleap(yearbeg - 1)] * SECSPERDAY; time_t janfirst1 = janfirst; yearbeg--; if (increment_overflow_time(&janfirst1, -yearsecs)) { janoffset = -yearsecs; break; } janfirst = janfirst1; } while (atlo < janfirst && EPOCH_YEAR - YEARSPERREPEAT / 2 < yearbeg); while (true) { int_fast32_t yearsecs = year_lengths[isleap(yearbeg)] * SECSPERDAY; int yearbeg1 = yearbeg; time_t janfirst1 = janfirst; if (increment_overflow_time(&janfirst1, yearsecs) || increment_overflow(&yearbeg1, 1) || atlo <= janfirst1) break; yearbeg = yearbeg1; janfirst = janfirst1; } yearlim = yearbeg; if (increment_overflow(&yearlim, years_of_observations)) yearlim = INT_MAX; for (year = yearbeg; year < yearlim; year++) { int_fast32_t starttime = transtime(year, &start, stdoffset), endtime = transtime(year, &end, dstoffset); int_fast32_t yearsecs = (year_lengths[isleap(year)] * SECSPERDAY); bool reversed = endtime < starttime; if (reversed) { int_fast32_t swap = starttime; starttime = endtime; endtime = swap; } if (reversed || (starttime < endtime && endtime - starttime < yearsecs)) { if (TZ_MAX_TIMES - 2 < timecnt) break; sp->ats[timecnt] = janfirst; if (! increment_overflow_time (&sp->ats[timecnt], janoffset + starttime) && atlo <= sp->ats[timecnt]) sp->types[timecnt++] = !reversed; sp->ats[timecnt] = janfirst; if (! increment_overflow_time (&sp->ats[timecnt], janoffset + endtime) && atlo <= sp->ats[timecnt]) { sp->types[timecnt++] = reversed; } } if (endtime < leaplo) { yearlim = year; if (increment_overflow(&yearlim, years_of_observations)) yearlim = INT_MAX; } if (increment_overflow_time (&janfirst, janoffset + yearsecs)) break; janoffset = 0; } sp->timecnt = timecnt; if (! timecnt) { sp->ttis[0] = sp->ttis[1]; sp->typecnt = 1; /* Perpetual DST. */ } else if (years_of_observations <= year - yearbeg) sp->goback = sp->goahead = true; } else { register int_fast32_t theirstdoffset; register int_fast32_t theirdstoffset; register int_fast32_t theiroffset; register bool isdst; register int i; register int j; if (*name != '\0') return false; /* ** Initial values of theirstdoffset and theirdstoffset. */ theirstdoffset = 0; for (i = 0; i < sp->timecnt; ++i) { j = sp->types[i]; if (!sp->ttis[j].tt_isdst) { theirstdoffset = - sp->ttis[j].tt_utoff; break; } } theirdstoffset = 0; for (i = 0; i < sp->timecnt; ++i) { j = sp->types[i]; if (sp->ttis[j].tt_isdst) { theirdstoffset = - sp->ttis[j].tt_utoff; break; } } /* ** Initially we're assumed to be in standard time. */ isdst = false; /* ** Now juggle transition times and types ** tracking offsets as you do. */ for (i = 0; i < sp->timecnt; ++i) { j = sp->types[i]; sp->types[i] = sp->ttis[j].tt_isdst; if (sp->ttis[j].tt_ttisut) { /* No adjustment to transition time */ } else { /* ** If daylight saving time is in ** effect, and the transition time was ** not specified as standard time, add ** the daylight saving time offset to ** the transition time; otherwise, add ** the standard time offset to the ** transition time. */ /* ** Transitions from DST to DDST ** will effectively disappear since ** proleptic TZ strings have only one ** DST offset. */ if (isdst && !sp->ttis[j].tt_ttisstd) { sp->ats[i] += dstoffset - theirdstoffset; } else { sp->ats[i] += stdoffset - theirstdoffset; } } theiroffset = -sp->ttis[j].tt_utoff; if (sp->ttis[j].tt_isdst) theirdstoffset = theiroffset; else theirstdoffset = theiroffset; } /* ** Finally, fill in ttis. */ init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); init_ttinfo(&sp->ttis[1], -dstoffset, true, stdlen + 1); sp->typecnt = 2; } } else { dstlen = 0; sp->typecnt = 1; /* only standard time */ sp->timecnt = 0; init_ttinfo(&sp->ttis[0], -stdoffset, false, 0); } sp->charcnt = charcnt; cp = sp->chars; memcpy(cp, stdname, stdlen); cp += stdlen; *cp++ = '\0'; if (dstlen != 0) { memcpy(cp, dstname, dstlen); *(cp + dstlen) = '\0'; } return true; } static void gmtload(struct state *const sp) { if (tzload(etc_utc, sp, TZLOAD_TZSTRING) != 0) tzparse("UTC0", sp, NULL); } #ifdef DETECT_TZ_CHANGES /* * Check if the time zone data we have is still fresh. */ static int tzdata_is_fresh(void) { static time_t last_checked; struct timespec now; if (clock_gettime(CLOCK_MONOTONIC, &now) < 0) return 0; if ((now.tv_sec - last_checked >= __tz_change_interval) || (last_checked > now.tv_sec)) { last_checked = now.tv_sec; return 1; } return 0; } #endif /* DETECT_TZ_CHANGES */ #if !USE_TIMEX_T || !defined TM_GMTOFF /* Initialize *SP to a value appropriate for the TZ setting NAME. Respect TZLOADFLAGS. Return 0 on success, an errno value on failure. */ static int zoneinit(struct state *sp, char const *name, char tzloadflags) { if (name && ! name[0]) { /* ** User wants it fast rather than right. */ sp->leapcnt = 0; /* so, we're off a little */ sp->timecnt = 0; sp->typecnt = 0; sp->charcnt = 0; sp->goback = sp->goahead = false; init_ttinfo(&sp->ttis[0], 0, false, 0); strcpy(sp->chars, utc); return 0; } else { int err = tzload(name, sp, tzloadflags); if (err != 0 && name && name[0] != ':' && tzparse(name, sp, NULL)) err = 0; if (err == 0) err = scrub_abbrs(sp); return err; } } static void tzset_unlocked(void) { char const *name = getenv("TZ"); #ifdef __FreeBSD__ tzset_unlocked_name(name); } static void tzset_unlocked_name(char const *name) { #endif struct state *sp = lclptr; int lcl = name ? strlen(name) < sizeof lcl_TZname : -1; if (lcl < 0 ? lcl_is_set < 0 : 0 < lcl_is_set && strcmp(lcl_TZname, name) == 0) #ifdef DETECT_TZ_CHANGES if (tzdata_is_fresh() == 0) #endif /* DETECT_TZ_CHANGES */ return; # ifdef ALL_STATE if (! sp) lclptr = sp = malloc(sizeof *lclptr); # endif if (sp) { int err = zoneinit(sp, name, TZLOAD_FROMENV | TZLOAD_TZSTRING); if (err != 0) { zoneinit(sp, "", 0); /* Abbreviate with "-00" if there was an error. Do not treat a missing TZDEFAULT file as an error. */ if (name || err != ENOENT) strcpy(sp->chars, UNSPEC); } if (0 < lcl) strcpy(lcl_TZname, name); } settzname(); lcl_is_set = lcl; } #endif #if !USE_TIMEX_T void tzset(void) { if (lock() != 0) return; tzset_unlocked(); unlock(); } #endif #ifdef __FreeBSD__ void freebsd13_tzsetwall(void) { if (lock() != 0) return; tzset_unlocked_name(NULL); unlock(); } __sym_compat(tzsetwall, freebsd13_tzsetwall, FBSD_1.0); __warn_references(tzsetwall, "warning: tzsetwall() is deprecated, use tzset() instead."); #endif /* __FreeBSD__ */ static void gmtcheck(void) { static bool gmt_is_set; if (lock() != 0) return; if (! gmt_is_set) { #ifdef ALL_STATE gmtptr = malloc(sizeof *gmtptr); #endif if (gmtptr) gmtload(gmtptr); gmt_is_set = true; } unlock(); } #ifdef __FreeBSD__ #define gmtcheck() _once(&gmt_once, gmtcheck) #endif #if NETBSD_INSPIRED && !USE_TIMEX_T timezone_t tzalloc(char const *name) { timezone_t sp = malloc(sizeof *sp); if (sp) { int err = zoneinit(sp, name, TZLOAD_TZSTRING); if (err != 0) { free(sp); errno = err; return NULL; } } else if (!HAVE_MALLOC_ERRNO) errno = ENOMEM; return sp; } void tzfree(timezone_t sp) { free(sp); } /* ** NetBSD 6.1.4 has ctime_rz, but omit it because C23 deprecates ctime and ** POSIX.1-2024 removes ctime_r. Both have potential security problems that ** ctime_rz would share. Callers can instead use localtime_rz + strftime. ** ** NetBSD 6.1.4 has tzgetname, but omit it because it doesn't work ** in zones with three or more time zone abbreviations. ** Callers can instead use localtime_rz + strftime. */ #endif #if !USE_TIMEX_T || !defined TM_GMTOFF /* ** The easy way to behave "as if no library function calls" localtime ** is to not call it, so we drop its guts into "localsub", which can be ** freely called. (And no, the PANS doesn't require the above behavior, ** but it *is* desirable.) ** ** If successful and SETNAME is nonzero, ** set the applicable parts of tzname, timezone and altzone; ** however, it's OK to omit this step for proleptic TZ strings ** since in that case tzset should have already done this step correctly. ** SETNAME's type is int_fast32_t for compatibility with gmtsub, ** but it is actually a boolean and its value should be 0 or 1. */ /*ARGSUSED*/ static struct tm * localsub(struct state const *sp, time_t const *timep, int_fast32_t setname, struct tm *const tmp) { register const struct ttinfo * ttisp; register int i; register struct tm * result; const time_t t = *timep; if (sp == NULL) { /* Don't bother to set tzname etc.; tzset has already done it. */ return gmtsub(gmtptr, timep, 0, tmp); } if ((sp->goback && t < sp->ats[0]) || (sp->goahead && t > sp->ats[sp->timecnt - 1])) { time_t newt; register time_t seconds; register time_t years; if (t < sp->ats[0]) seconds = sp->ats[0] - t; else seconds = t - sp->ats[sp->timecnt - 1]; --seconds; /* Beware integer overflow, as SECONDS might be close to the maximum time_t. */ years = seconds / SECSPERREPEAT * YEARSPERREPEAT; seconds = years * AVGSECSPERYEAR; years += YEARSPERREPEAT; if (t < sp->ats[0]) newt = t + seconds + SECSPERREPEAT; else newt = t - seconds - SECSPERREPEAT; if (newt < sp->ats[0] || newt > sp->ats[sp->timecnt - 1]) return NULL; /* "cannot happen" */ result = localsub(sp, &newt, setname, tmp); if (result) { # if defined ckd_add && defined ckd_sub if (t < sp->ats[0] ? ckd_sub(&result->tm_year, result->tm_year, years) : ckd_add(&result->tm_year, result->tm_year, years)) return NULL; # else register int_fast64_t newy; newy = result->tm_year; if (t < sp->ats[0]) newy -= years; else newy += years; if (! (INT_MIN <= newy && newy <= INT_MAX)) return NULL; result->tm_year = newy; # endif } return result; } if (sp->timecnt == 0 || t < sp->ats[0]) { i = 0; } else { register int lo = 1; register int hi = sp->timecnt; while (lo < hi) { register int mid = (lo + hi) >> 1; if (t < sp->ats[mid]) hi = mid; else lo = mid + 1; } i = sp->types[lo - 1]; } ttisp = &sp->ttis[i]; /* ** To get (wrong) behavior that's compatible with System V Release 2.0 ** you'd replace the statement below with ** t += ttisp->tt_utoff; ** timesub(&t, 0L, sp, tmp); */ result = timesub(&t, ttisp->tt_utoff, sp, tmp); if (result) { result->tm_isdst = ttisp->tt_isdst; # ifdef TM_ZONE result->TM_ZONE = UNCONST(&sp->chars[ttisp->tt_desigidx]); # endif if (setname) update_tzname_etc(sp, ttisp); } return result; } #endif #if !USE_TIMEX_T # if NETBSD_INSPIRED struct tm * localtime_rz(struct state *restrict sp, time_t const *restrict timep, struct tm *restrict tmp) { return localsub(sp, timep, 0, tmp); } # endif static struct tm * localtime_tzset(time_t const *timep, struct tm *tmp, bool setname) { int err = lock(); if (err) { errno = err; return NULL; } #ifndef DETECT_TZ_CHANGES if (setname || !lcl_is_set) #endif /* DETECT_TZ_CHANGES */ tzset_unlocked(); tmp = localsub(lclptr, timep, setname, tmp); unlock(); return tmp; } #ifdef __FreeBSD__ static void localtime_key_init(void) { localtime_key_error = _pthread_key_create(&localtime_key, free); } #endif /* __FreeBSD__ */ struct tm * localtime(const time_t *timep) { # if !SUPPORT_C89 static struct tm tm; # endif #ifdef __FreeBSD__ struct tm *p_tm = &tm; if (__isthreaded != 0) { _pthread_once(&localtime_once, localtime_key_init); if (localtime_key_error != 0) { errno = localtime_key_error; return (NULL); } if ((p_tm = _pthread_getspecific(localtime_key)) == NULL) { if ((p_tm = malloc(sizeof(*p_tm))) == NULL) { return (NULL); } if (_pthread_setspecific(localtime_key, p_tm) != 0) { free(p_tm); return (NULL); } } } #endif /* __FreeBSD__ */ return localtime_tzset(timep, p_tm, true); } struct tm * localtime_r(const time_t *restrict timep, struct tm *restrict tmp) { return localtime_tzset(timep, tmp, false); } #endif /* ** gmtsub is to gmtime as localsub is to localtime. */ static struct tm * gmtsub(ATTRIBUTE_MAYBE_UNUSED struct state const *sp, time_t const *timep, int_fast32_t offset, struct tm *tmp) { register struct tm * result; result = timesub(timep, offset, gmtptr, tmp); #ifdef TM_ZONE /* ** Could get fancy here and deliver something such as ** "+xx" or "-xx" if offset is non-zero, ** but this is no time for a treasure hunt. */ tmp->TM_ZONE = UNCONST(offset ? wildabbr : gmtptr ? gmtptr->chars : utc); #endif /* defined TM_ZONE */ return result; } #if !USE_TIMEX_T /* * Re-entrant version of gmtime. */ struct tm * gmtime_r(time_t const *restrict timep, struct tm *restrict tmp) { gmtcheck(); return gmtsub(gmtptr, timep, 0, tmp); } #ifdef __FreeBSD__ static void gmtime_key_init(void) { gmtime_key_error = _pthread_key_create(&gmtime_key, free); } #endif /* __FreeBSD__ */ struct tm * gmtime(const time_t *timep) { # if !SUPPORT_C89 static struct tm tm; # endif #ifdef __FreeBSD__ struct tm *p_tm = &tm; if (__isthreaded != 0) { _pthread_once(&gmtime_once, gmtime_key_init); if (gmtime_key_error != 0) { errno = gmtime_key_error; return (NULL); } if ((p_tm = _pthread_getspecific(gmtime_key)) == NULL) { if ((p_tm = malloc(sizeof(*p_tm))) == NULL) { return (NULL); } if (_pthread_setspecific(gmtime_key, p_tm) != 0) { free(p_tm); return (NULL); } } } #endif /* __FreeBSD__ */ return gmtime_r(timep, p_tm); } # if STD_INSPIRED /* This function is obsolescent and may disappear in future releases. Callers can instead use localtime_rz with a fixed-offset zone. */ struct tm * offtime_r(time_t const *restrict timep, long offset, struct tm *restrict tmp) { gmtcheck(); return gmtsub(gmtptr, timep, offset, tmp); } #ifdef __FreeBSD__ static void offtime_key_init(void) { offtime_key_error = _pthread_key_create(&offtime_key, free); } #endif /* __FreeBSD__ */ struct tm * -offtime(const time_t *timep, long offset) +offtime(time_t const *timep, long offset) { # if !SUPPORT_C89 static struct tm tm; # endif #ifdef __FreeBSD__ struct tm *p_tm = &tm; if (__isthreaded != 0) { _pthread_once(&offtime_once, offtime_key_init); if (offtime_key_error != 0) { errno = offtime_key_error; return (NULL); } if ((p_tm = _pthread_getspecific(offtime_key)) == NULL) { if ((p_tm = malloc(sizeof(*p_tm))) == NULL) { return (NULL); } if (_pthread_setspecific(offtime_key, p_tm) != 0) { free(p_tm); return (NULL); } } } #endif return offtime_r(timep, offset, p_tm); } # endif #endif /* ** Return the number of leap years through the end of the given year ** where, to make the math easy, the answer for year zero is defined as zero. */ static time_t leaps_thru_end_of_nonneg(time_t y) { return y / 4 - y / 100 + y / 400; } static time_t leaps_thru_end_of(time_t y) { return (y < 0 ? -1 - leaps_thru_end_of_nonneg(-1 - y) : leaps_thru_end_of_nonneg(y)); } static struct tm * timesub(const time_t *timep, int_fast32_t offset, const struct state *sp, struct tm *tmp) { register const struct lsinfo * lp; register time_t tdays; register const int * ip; register int_fast32_t corr; register int i; int_fast32_t idays, rem, dayoff, dayrem; time_t y; /* If less than SECSPERMIN, the number of seconds since the most recent positive leap second; otherwise, do not add 1 to localtime tm_sec because of leap seconds. */ time_t secs_since_posleap = SECSPERMIN; corr = 0; i = (sp == NULL) ? 0 : sp->leapcnt; while (--i >= 0) { lp = &sp->lsis[i]; if (*timep >= lp->ls_trans) { corr = lp->ls_corr; if ((i == 0 ? 0 : lp[-1].ls_corr) < corr) secs_since_posleap = *timep - lp->ls_trans; break; } } /* Calculate the year, avoiding integer overflow even if time_t is unsigned. */ tdays = *timep / SECSPERDAY; rem = *timep % SECSPERDAY; rem += offset % SECSPERDAY - corr % SECSPERDAY + 3 * SECSPERDAY; dayoff = offset / SECSPERDAY - corr / SECSPERDAY + rem / SECSPERDAY - 3; rem %= SECSPERDAY; /* y = (EPOCH_YEAR + floor((tdays + dayoff) / DAYSPERREPEAT) * YEARSPERREPEAT), sans overflow. But calculate against 1570 (EPOCH_YEAR - YEARSPERREPEAT) instead of against 1970 so that things work for localtime values before 1970 when time_t is unsigned. */ dayrem = tdays % DAYSPERREPEAT; dayrem += dayoff % DAYSPERREPEAT; y = (EPOCH_YEAR - YEARSPERREPEAT + ((1 + dayoff / DAYSPERREPEAT + dayrem / DAYSPERREPEAT - ((dayrem % DAYSPERREPEAT) < 0) + tdays / DAYSPERREPEAT) * YEARSPERREPEAT)); /* idays = (tdays + dayoff) mod DAYSPERREPEAT, sans overflow. */ idays = tdays % DAYSPERREPEAT; idays += dayoff % DAYSPERREPEAT + 2 * DAYSPERREPEAT; idays %= DAYSPERREPEAT; /* Increase Y and decrease IDAYS until IDAYS is in range for Y. */ while (year_lengths[isleap(y)] <= idays) { int tdelta = idays / DAYSPERLYEAR; int_fast32_t ydelta = tdelta + !tdelta; time_t newy = y + ydelta; register int leapdays; leapdays = leaps_thru_end_of(newy - 1) - leaps_thru_end_of(y - 1); idays -= ydelta * DAYSPERNYEAR; idays -= leapdays; y = newy; } #ifdef ckd_add if (ckd_add(&tmp->tm_year, y, -TM_YEAR_BASE)) { errno = EOVERFLOW; return NULL; } #else if (!TYPE_SIGNED(time_t) && y < TM_YEAR_BASE) { int signed_y = y; tmp->tm_year = signed_y - TM_YEAR_BASE; } else if ((!TYPE_SIGNED(time_t) || INT_MIN + TM_YEAR_BASE <= y) && y - TM_YEAR_BASE <= INT_MAX) tmp->tm_year = y - TM_YEAR_BASE; else { errno = EOVERFLOW; return NULL; } #endif tmp->tm_yday = idays; /* ** The "extra" mods below avoid overflow problems. */ tmp->tm_wday = (TM_WDAY_BASE + ((tmp->tm_year % DAYSPERWEEK) * (DAYSPERNYEAR % DAYSPERWEEK)) + leaps_thru_end_of(y - 1) - leaps_thru_end_of(TM_YEAR_BASE - 1) + idays); tmp->tm_wday %= DAYSPERWEEK; if (tmp->tm_wday < 0) tmp->tm_wday += DAYSPERWEEK; tmp->tm_hour = rem / SECSPERHOUR; rem %= SECSPERHOUR; tmp->tm_min = rem / SECSPERMIN; tmp->tm_sec = rem % SECSPERMIN; /* Use "... ??:??:60" at the end of the localtime minute containing the second just before the positive leap second. */ tmp->tm_sec += secs_since_posleap <= tmp->tm_sec; ip = mon_lengths[isleap(y)]; for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon)) idays -= ip[tmp->tm_mon]; tmp->tm_mday = idays + 1; tmp->tm_isdst = 0; #ifdef TM_GMTOFF tmp->TM_GMTOFF = offset; #endif /* defined TM_GMTOFF */ return tmp; } /* ** Adapted from code provided by Robert Elz, who writes: ** The "best" way to do mktime I think is based on an idea of Bob ** Kridle's (so its said...) from a long time ago. ** It does a binary search of the time_t space. Since time_t's are ** just 32 bits, its a max of 32 iterations (even at 64 bits it ** would still be very reasonable). */ #ifndef WRONG # define WRONG (-1) #endif /* !defined WRONG */ /* ** Normalize logic courtesy Paul Eggert. */ static bool increment_overflow(int *ip, int j) { #ifdef ckd_add return ckd_add(ip, *ip, j); #else register int const i = *ip; /* ** If i >= 0 there can only be overflow if i + j > INT_MAX ** or if j > INT_MAX - i; given i >= 0, INT_MAX - i cannot overflow. ** If i < 0 there can only be overflow if i + j < INT_MIN ** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow. */ if ((i >= 0) ? (j > INT_MAX - i) : (j < INT_MIN - i)) return true; *ip += j; return false; #endif } static bool increment_overflow_time_iinntt(time_t *tp, iinntt j) { #ifdef ckd_add return ckd_add(tp, *tp, j); #else if (j < 0 ? (TYPE_SIGNED(time_t) ? *tp < TIME_T_MIN - j : *tp <= -1 - j) : TIME_T_MAX - j < *tp) return true; *tp += j; return false; #endif } static bool increment_overflow_time(time_t *tp, int_fast32_t j) { #ifdef ckd_add return ckd_add(tp, *tp, j); #else /* ** This is like ** 'if (! (TIME_T_MIN <= *tp + j && *tp + j <= TIME_T_MAX)) ...', ** except that it does the right thing even if *tp + j would overflow. */ if (! (j < 0 ? (TYPE_SIGNED(time_t) ? TIME_T_MIN - j <= *tp : -1 - j < *tp) : *tp <= TIME_T_MAX - j)) return true; *tp += j; return false; #endif } static int tmcomp(register const struct tm *const atmp, register const struct tm *const btmp) { register int result; if (atmp->tm_year != btmp->tm_year) return atmp->tm_year < btmp->tm_year ? -1 : 1; if ((result = (atmp->tm_mon - btmp->tm_mon)) == 0 && (result = (atmp->tm_mday - btmp->tm_mday)) == 0 && (result = (atmp->tm_hour - btmp->tm_hour)) == 0 && (result = (atmp->tm_min - btmp->tm_min)) == 0) result = atmp->tm_sec - btmp->tm_sec; return result; } /* Copy to *DEST from *SRC. Copy only the members needed for mktime, as other members might not be initialized. */ static void mktmcpy(struct tm *dest, struct tm const *src) { dest->tm_sec = src->tm_sec; dest->tm_min = src->tm_min; dest->tm_hour = src->tm_hour; dest->tm_mday = src->tm_mday; dest->tm_mon = src->tm_mon; dest->tm_year = src->tm_year; dest->tm_isdst = src->tm_isdst; #if defined TM_GMTOFF && ! UNINIT_TRAP dest->TM_GMTOFF = src->TM_GMTOFF; #endif } static time_t time2sub(struct tm *const tmp, struct tm *(*funcp)(struct state const *, time_t const *, int_fast32_t, struct tm *), struct state const *sp, const int_fast32_t offset, bool *okayp, bool do_norm_secs) { register int dir; register int i, j; register time_t lo; register time_t hi; iinntt y, mday, hour, min, saved_seconds; time_t newt; time_t t; struct tm yourtm, mytm; *okayp = false; mktmcpy(&yourtm, tmp); min = yourtm.tm_min; if (do_norm_secs) { min += yourtm.tm_sec / SECSPERMIN; yourtm.tm_sec %= SECSPERMIN; if (yourtm.tm_sec < 0) { yourtm.tm_sec += SECSPERMIN; min--; } } hour = yourtm.tm_hour; hour += min / MINSPERHOUR; yourtm.tm_min = min % MINSPERHOUR; if (yourtm.tm_min < 0) { yourtm.tm_min += MINSPERHOUR; hour--; } mday = yourtm.tm_mday; mday += hour / HOURSPERDAY; yourtm.tm_hour = hour % HOURSPERDAY; if (yourtm.tm_hour < 0) { yourtm.tm_hour += HOURSPERDAY; mday--; } y = yourtm.tm_year; y += yourtm.tm_mon / MONSPERYEAR; yourtm.tm_mon %= MONSPERYEAR; if (yourtm.tm_mon < 0) { yourtm.tm_mon += MONSPERYEAR; y--; } /* ** Turn y into an actual year number for now. ** It is converted back to an offset from TM_YEAR_BASE later. */ y += TM_YEAR_BASE; while (mday <= 0) { iinntt li = y - (yourtm.tm_mon <= 1); mday += year_lengths[isleap(li)]; y--; } while (DAYSPERLYEAR < mday) { iinntt li = y + (1 < yourtm.tm_mon); mday -= year_lengths[isleap(li)]; y++; } yourtm.tm_mday = mday; for ( ; ; ) { i = mon_lengths[isleap(y)][yourtm.tm_mon]; if (yourtm.tm_mday <= i) break; yourtm.tm_mday -= i; if (++yourtm.tm_mon >= MONSPERYEAR) { yourtm.tm_mon = 0; y++; } } #ifdef ckd_add if (ckd_add(&yourtm.tm_year, y, -TM_YEAR_BASE)) return WRONG; #else y -= TM_YEAR_BASE; if (! (INT_MIN <= y && y <= INT_MAX)) return WRONG; yourtm.tm_year = y; #endif if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN) saved_seconds = 0; else if (yourtm.tm_year < EPOCH_YEAR - TM_YEAR_BASE) { /* ** We can't set tm_sec to 0, because that might push the ** time below the minimum representable time. ** Set tm_sec to 59 instead. ** This assumes that the minimum representable time is ** not in the same minute that a leap second was deleted from, ** which is a safer assumption than using 58 would be. */ saved_seconds = yourtm.tm_sec; saved_seconds -= SECSPERMIN - 1; yourtm.tm_sec = SECSPERMIN - 1; } else { saved_seconds = yourtm.tm_sec; yourtm.tm_sec = 0; } /* ** Do a binary search (this works whatever time_t's type is). */ lo = TIME_T_MIN; hi = TIME_T_MAX; for ( ; ; ) { t = lo / 2 + hi / 2; if (t < lo) t = lo; else if (t > hi) t = hi; if (! funcp(sp, &t, offset, &mytm)) { /* ** Assume that t is too extreme to be represented in ** a struct tm; arrange things so that it is less ** extreme on the next pass. */ dir = (t > 0) ? 1 : -1; } else dir = tmcomp(&mytm, &yourtm); if (dir != 0) { if (t == lo) { if (t == TIME_T_MAX) return WRONG; ++t; ++lo; } else if (t == hi) { if (t == TIME_T_MIN) return WRONG; --t; --hi; } if (lo > hi) return WRONG; if (dir > 0) hi = t; else lo = t; continue; } #if defined TM_GMTOFF && ! UNINIT_TRAP if (mytm.TM_GMTOFF != yourtm.TM_GMTOFF && (yourtm.TM_GMTOFF < 0 ? (-SECSPERDAY <= yourtm.TM_GMTOFF && (mytm.TM_GMTOFF <= (min(INT_FAST32_MAX, LONG_MAX) + yourtm.TM_GMTOFF))) : (yourtm.TM_GMTOFF <= SECSPERDAY && ((max(INT_FAST32_MIN, LONG_MIN) + yourtm.TM_GMTOFF) <= mytm.TM_GMTOFF)))) { /* MYTM matches YOURTM except with the wrong UT offset. YOURTM.TM_GMTOFF is plausible, so try it instead. It's OK if YOURTM.TM_GMTOFF contains uninitialized data, since the guess gets checked. */ time_t altt = t; int_fast32_t diff = mytm.TM_GMTOFF - yourtm.TM_GMTOFF; if (!increment_overflow_time(&altt, diff)) { struct tm alttm; if (funcp(sp, &altt, offset, &alttm) && alttm.tm_isdst == mytm.tm_isdst && alttm.TM_GMTOFF == yourtm.TM_GMTOFF && tmcomp(&alttm, &yourtm) == 0) { t = altt; mytm = alttm; } } } #endif if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst) break; /* ** Right time, wrong type. ** Hunt for right time, right type. ** It's okay to guess wrong since the guess ** gets checked. */ if (sp == NULL) return WRONG; for (i = sp->typecnt - 1; i >= 0; --i) { if (sp->ttis[i].tt_isdst != yourtm.tm_isdst) continue; for (j = sp->typecnt - 1; j >= 0; --j) { if (sp->ttis[j].tt_isdst == yourtm.tm_isdst) continue; if (ttunspecified(sp, j)) continue; newt = (t + sp->ttis[j].tt_utoff - sp->ttis[i].tt_utoff); if (! funcp(sp, &newt, offset, &mytm)) continue; if (tmcomp(&mytm, &yourtm) != 0) continue; if (mytm.tm_isdst != yourtm.tm_isdst) continue; /* ** We have a match. */ t = newt; goto label; } } return WRONG; } label: if (increment_overflow_time_iinntt(&t, saved_seconds)) return WRONG; if (funcp(sp, &t, offset, tmp)) *okayp = true; return t; } static time_t time2(struct tm * const tmp, struct tm *(*funcp)(struct state const *, time_t const *, int_fast32_t, struct tm *), struct state const *sp, const int_fast32_t offset, bool *okayp) { time_t t; /* ** First try without normalization of seconds ** (in case tm_sec contains a value associated with a leap second). ** If that fails, try with normalization of seconds. */ t = time2sub(tmp, funcp, sp, offset, okayp, false); return *okayp ? t : time2sub(tmp, funcp, sp, offset, okayp, true); } static time_t time1(struct tm *const tmp, struct tm *(*funcp)(struct state const *, time_t const *, int_fast32_t, struct tm *), struct state const *sp, const int_fast32_t offset) { register time_t t; register int samei, otheri; register int sameind, otherind; register int i; register int nseen; char seen[TZ_MAX_TYPES]; unsigned char types[TZ_MAX_TYPES]; bool okay; if (tmp == NULL) { errno = EINVAL; return WRONG; } if (tmp->tm_isdst > 1) tmp->tm_isdst = 1; t = time2(tmp, funcp, sp, offset, &okay); if (okay) return t; if (tmp->tm_isdst < 0) #ifdef PCTS /* ** POSIX Conformance Test Suite code courtesy Grant Sullivan. */ tmp->tm_isdst = 0; /* reset to std and try again */ #else return t; #endif /* !defined PCTS */ /* ** We're supposed to assume that somebody took a time of one type ** and did some math on it that yielded a "struct tm" that's bad. ** We try to divine the type they started from and adjust to the ** type they need. */ if (sp == NULL) return WRONG; for (i = 0; i < sp->typecnt; ++i) seen[i] = false; nseen = 0; for (i = sp->timecnt - 1; i >= 0; --i) if (!seen[sp->types[i]] && !ttunspecified(sp, sp->types[i])) { seen[sp->types[i]] = true; types[nseen++] = sp->types[i]; } for (sameind = 0; sameind < nseen; ++sameind) { samei = types[sameind]; if (sp->ttis[samei].tt_isdst != tmp->tm_isdst) continue; for (otherind = 0; otherind < nseen; ++otherind) { otheri = types[otherind]; if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst) continue; tmp->tm_sec += (sp->ttis[otheri].tt_utoff - sp->ttis[samei].tt_utoff); tmp->tm_isdst = !tmp->tm_isdst; t = time2(tmp, funcp, sp, offset, &okay); if (okay) return t; tmp->tm_sec -= (sp->ttis[otheri].tt_utoff - sp->ttis[samei].tt_utoff); tmp->tm_isdst = !tmp->tm_isdst; } } return WRONG; } #if !defined TM_GMTOFF || !USE_TIMEX_T static time_t mktime_tzname(struct state *sp, struct tm *tmp, bool setname) { if (sp) return time1(tmp, localsub, sp, setname); else { gmtcheck(); return time1(tmp, gmtsub, gmtptr, 0); } } # if USE_TIMEX_T static # endif time_t mktime(struct tm *tmp) { time_t t; int err = lock(); if (err) { errno = err; return -1; } tzset_unlocked(); t = mktime_tzname(lclptr, tmp, true); unlock(); return t; } #endif #if NETBSD_INSPIRED && !USE_TIMEX_T time_t mktime_z(struct state *restrict sp, struct tm *restrict tmp) { return mktime_tzname(sp, tmp, false); } #endif #if STD_INSPIRED && !USE_TIMEX_T /* This function is obsolescent and may disappear in future releases. Callers can instead use mktime. */ time_t timelocal(struct tm *tmp) { if (tmp != NULL) tmp->tm_isdst = -1; /* in case it wasn't initialized */ return mktime(tmp); } #endif #if defined TM_GMTOFF || !USE_TIMEX_T # ifndef EXTERN_TIMEOFF # ifndef timeoff # define timeoff my_timeoff /* Don't collide with OpenBSD 7.4 . */ # endif # define EXTERN_TIMEOFF static # endif /* This function is obsolescent and may disappear in future releases. Callers can instead use mktime_z with a fixed-offset zone. */ EXTERN_TIMEOFF time_t timeoff(struct tm *tmp, long offset) { if (tmp) tmp->tm_isdst = 0; gmtcheck(); return time1(tmp, gmtsub, gmtptr, offset); } #endif #if !USE_TIMEX_T time_t timegm(struct tm *tmp) { time_t t; struct tm tmcpy; mktmcpy(&tmcpy, tmp); tmcpy.tm_wday = -1; t = timeoff(&tmcpy, 0); if (0 <= tmcpy.tm_wday) *tmp = tmcpy; return t; } #endif static int_fast32_t leapcorr(struct state const *sp, time_t t) { register struct lsinfo const * lp; register int i; i = sp->leapcnt; while (--i >= 0) { lp = &sp->lsis[i]; if (t >= lp->ls_trans) return lp->ls_corr; } return 0; } /* ** XXX--is the below the right way to conditionalize?? */ #if !USE_TIMEX_T # if STD_INSPIRED /* NETBSD_INSPIRED_EXTERN functions are exported to callers if NETBSD_INSPIRED is defined, and are private otherwise. */ # if NETBSD_INSPIRED # define NETBSD_INSPIRED_EXTERN # else # define NETBSD_INSPIRED_EXTERN static # endif /* ** IEEE Std 1003.1 (POSIX) says that 536457599 ** shall correspond to "Wed Dec 31 23:59:59 UTC 1986", which ** is not the case if we are accounting for leap seconds. ** So, we provide the following conversion routines for use ** when exchanging timestamps with POSIX conforming systems. */ NETBSD_INSPIRED_EXTERN time_t time2posix_z(struct state *sp, time_t t) { return t - leapcorr(sp, t); } time_t time2posix(time_t t) { int err = lock(); if (err) { errno = err; return -1; } #ifndef DETECT_TZ_CHANGES if (!lcl_is_set) #endif /* DETECT_TZ_CHANGES */ tzset_unlocked(); if (lclptr) t = time2posix_z(lclptr, t); unlock(); return t; } NETBSD_INSPIRED_EXTERN time_t posix2time_z(struct state *sp, time_t t) { time_t x; time_t y; /* ** For a positive leap second hit, the result ** is not unique. For a negative leap second ** hit, the corresponding time doesn't exist, ** so we return an adjacent second. */ x = t + leapcorr(sp, t); y = x - leapcorr(sp, x); if (y < t) { do { x++; y = x - leapcorr(sp, x); } while (y < t); x -= y != t; } else if (y > t) { do { --x; y = x - leapcorr(sp, x); } while (y > t); x += y != t; } return x; } time_t posix2time(time_t t) { int err = lock(); if (err) { errno = err; return -1; } #ifndef DETECT_TZ_CHANGES if (!lcl_is_set) #endif /* DETECT_TZ_CHANGES */ tzset_unlocked(); if (lclptr) t = posix2time_z(lclptr, t); unlock(); return t; } # endif /* STD_INSPIRED */ # if TZ_TIME_T # if !USG_COMPAT # define timezone 0 # endif /* Convert from the underlying system's time_t to the ersatz time_tz, which is called 'time_t' in this file. Typically, this merely converts the time's integer width. On some platforms, the system time is local time not UT, or uses some epoch other than the POSIX epoch. Although this code appears to define a function named 'time' that returns time_t, the macros in private.h cause this code to actually define a function named 'tz_time' that returns tz_time_t. The call to sys_time invokes the underlying system's 'time' function. */ time_t time(time_t *p) { time_t r = sys_time(0); if (r != (time_t) -1) { iinntt offset = EPOCH_LOCAL ? timezone : 0; if (offset < IINNTT_MIN + EPOCH_OFFSET || increment_overflow_time_iinntt(&r, offset - EPOCH_OFFSET)) { errno = EOVERFLOW; r = -1; } } if (p) *p = r; return r; } # endif #endif diff --git a/contrib/tzcode/private.h b/contrib/tzcode/private.h index 532d9ddc81c8..e6b206690b73 100644 --- a/contrib/tzcode/private.h +++ b/contrib/tzcode/private.h @@ -1,1108 +1,1108 @@ /* Private header for tzdb code. */ #ifndef PRIVATE_H #define PRIVATE_H /* ** This file is in the public domain, so clarified as of ** 1996-06-05 by Arthur David Olson. */ /* ** This header is for use ONLY with the time conversion code. ** There is no guarantee that it will remain unchanged, ** or that it will remain at all. ** Do NOT copy it to any system include directory. ** Thank you! */ /* PORT_TO_C89 means the code should work even if the underlying compiler and library support only C89 plus C99's 'long long' and perhaps a few other extensions to C89. This macro is obsolescent, and the plan is to remove it along with associated code. A good time to do that might be in the year 2029 because RHEL 7 (whose GCC defaults to C89) extended life cycle support (ELS) is scheduled to end on 2028-06-30. */ #ifndef PORT_TO_C89 # define PORT_TO_C89 0 #endif /* SUPPORT_C89 means the tzcode library should support C89 callers in addition to the usual support for C99-and-later callers. This defaults to 1 as POSIX requires, even though that can trigger latent bugs in callers. */ #ifndef SUPPORT_C89 # define SUPPORT_C89 1 #endif /* The following feature-test macros should be defined before any #include of a system header. */ /* Enable tm_gmtoff, tm_zone, and environ on GNUish systems. */ #define _GNU_SOURCE 1 /* Fix asctime_r on Solaris 11. */ #define _POSIX_PTHREAD_SEMANTICS 1 /* Enable strtoimax on pre-C99 Solaris 11. */ #define __EXTENSIONS__ 1 /* Cause MS-Windows headers to define POSIX names. */ #define _CRT_DECLARE_NONSTDC_NAMES 1 /* Prevent MS-Windows headers from defining min and max. */ #define NOMINMAX 1 /* On GNUish systems where time_t might be 32 or 64 bits, use 64. On these platforms _FILE_OFFSET_BITS must also be 64; otherwise setting _TIME_BITS to 64 does not work. The code does not otherwise rely on _FILE_OFFSET_BITS being 64, since it does not use off_t or functions like 'stat' that depend on off_t. */ #ifndef _TIME_BITS # ifndef _FILE_OFFSET_BITS # define _FILE_OFFSET_BITS 64 # endif # if _FILE_OFFSET_BITS == 64 # define _TIME_BITS 64 # endif #endif /* End of feature-test macro definitions. */ #ifndef __STDC_VERSION__ # define __STDC_VERSION__ 0 #endif /* Define true, false and bool if they don't work out of the box. */ #if PORT_TO_C89 && __STDC_VERSION__ < 199901 # define true 1 # define false 0 # define bool int #elif __STDC_VERSION__ < 202311 # include #endif #if __STDC_VERSION__ < 202311 # undef static_assert # define static_assert(cond) extern int static_assert_check[(cond) ? 1 : -1] #endif /* ** zdump has been made independent of the rest of the time ** conversion package to increase confidence in the verification it provides. ** You can use zdump to help in verifying other implementations. ** To do this, compile with -DUSE_LTZ=0 and link without the tz library. */ #ifndef USE_LTZ # define USE_LTZ 1 #endif /* This string was in the Factory zone through version 2016f. */ #define GRANDPARENTED "Local time zone must be set--use tzsetup" /* ** Defaults for preprocessor symbols. ** You can override these in your C compiler options, e.g. '-DHAVE_GETTEXT=1'. */ #if !defined HAVE__GENERIC && defined __has_extension # if !__has_extension(c_generic_selections) # define HAVE__GENERIC 0 # endif #endif /* _Generic is buggy in pre-4.9 GCC. */ #if !defined HAVE__GENERIC && defined __GNUC__ && !defined __STRICT_ANSI__ # define HAVE__GENERIC (4 < __GNUC__ + (9 <= __GNUC_MINOR__)) #endif #ifndef HAVE__GENERIC # define HAVE__GENERIC (201112 <= __STDC_VERSION__) #endif #if !defined HAVE_GETTEXT && defined __has_include # if __has_include() # define HAVE_GETTEXT 1 # endif #endif #ifndef HAVE_GETTEXT # define HAVE_GETTEXT 0 #endif #ifndef HAVE_INCOMPATIBLE_CTIME_R # define HAVE_INCOMPATIBLE_CTIME_R 0 #endif #ifndef HAVE_LINK # define HAVE_LINK 1 #endif /* !defined HAVE_LINK */ #ifndef HAVE_MALLOC_ERRNO # define HAVE_MALLOC_ERRNO 1 #endif #ifndef HAVE_POSIX_DECLS # define HAVE_POSIX_DECLS 1 #endif #ifndef HAVE_SETENV # define HAVE_SETENV 1 #endif #ifndef HAVE_STRDUP # define HAVE_STRDUP 1 #endif #ifndef HAVE_SYMLINK # define HAVE_SYMLINK 1 #endif /* !defined HAVE_SYMLINK */ #if !defined HAVE_SYS_STAT_H && defined __has_include # if !__has_include() # define HAVE_SYS_STAT_H 0 # endif #endif #ifndef HAVE_SYS_STAT_H # define HAVE_SYS_STAT_H 1 #endif #if !defined HAVE_UNISTD_H && defined __has_include # if !__has_include() # define HAVE_UNISTD_H 0 # endif #endif #ifndef HAVE_UNISTD_H # define HAVE_UNISTD_H 1 #endif #ifndef NETBSD_INSPIRED # define NETBSD_INSPIRED 1 #endif #if HAVE_INCOMPATIBLE_CTIME_R # define asctime_r _incompatible_asctime_r # define ctime_r _incompatible_ctime_r #endif /* HAVE_INCOMPATIBLE_CTIME_R */ /* ** Nested includes */ /* Avoid clashes with NetBSD by renaming NetBSD's declarations. If defining the 'timezone' variable, avoid a clash with FreeBSD's 'timezone' function by renaming its declaration. */ #define localtime_rz sys_localtime_rz #define mktime_z sys_mktime_z #define posix2time_z sys_posix2time_z #define time2posix_z sys_time2posix_z #if defined USG_COMPAT && USG_COMPAT == 2 # define timezone sys_timezone #endif #define timezone_t sys_timezone_t #define tzalloc sys_tzalloc #define tzfree sys_tzfree #include #undef localtime_rz #undef mktime_z #undef posix2time_z #undef time2posix_z #if defined USG_COMPAT && USG_COMPAT == 2 # undef timezone #endif #undef timezone_t #undef tzalloc #undef tzfree #include #include #if !PORT_TO_C89 # include #endif #include /* for CHAR_BIT et al. */ #include #include #ifndef EINVAL # define EINVAL ERANGE #endif #ifndef ELOOP # define ELOOP EINVAL #endif #ifndef ENAMETOOLONG # define ENAMETOOLONG EINVAL #endif #ifndef ENOMEM # define ENOMEM EINVAL #endif #ifndef ENOTSUP # define ENOTSUP EINVAL #endif #ifndef EOVERFLOW # define EOVERFLOW EINVAL #endif #if HAVE_GETTEXT # include #endif /* HAVE_GETTEXT */ #if HAVE_UNISTD_H # include /* for R_OK, and other POSIX goodness */ #endif /* HAVE_UNISTD_H */ /* SUPPORT_POSIX2008 means the tzcode library should support POSIX.1-2017-and-earlier callers in addition to the usual support for POSIX.1-2024-and-later callers; however, this can be incompatible with POSIX.1-2024-and-later callers. This macro is obsolescent, and the plan is to remove it along with any code needed only when it is nonzero. A good time to do that might be in the year 2034. This macro's name is SUPPORT_POSIX2008 because _POSIX_VERSION == 200809 in POSIX.1-2017, a minor revision of POSIX.1-2008. */ #ifndef SUPPORT_POSIX2008 # if defined _POSIX_VERSION && _POSIX_VERSION <= 200809 # define SUPPORT_POSIX2008 1 # else # define SUPPORT_POSIX2008 0 # endif #endif #ifndef HAVE_DECL_ASCTIME_R # if SUPPORT_POSIX2008 # define HAVE_DECL_ASCTIME_R 1 # else # define HAVE_DECL_ASCTIME_R 0 # endif #endif #ifndef HAVE_SNPRINTF # define HAVE_SNPRINTF (!PORT_TO_C89 || 199901 <= __STDC_VERSION__) #endif #ifndef HAVE_STRFTIME_L # if _POSIX_VERSION < 200809 # define HAVE_STRFTIME_L 0 # else # define HAVE_STRFTIME_L 1 # endif #endif #ifndef USG_COMPAT # ifndef _XOPEN_VERSION # define USG_COMPAT 0 # else # define USG_COMPAT 1 # endif #endif #ifndef HAVE_TZNAME # if _POSIX_VERSION < 198808 && !USG_COMPAT # define HAVE_TZNAME 0 # else # define HAVE_TZNAME 1 # endif #endif #ifndef ALTZONE # if defined __sun || defined _M_XENIX # define ALTZONE 1 # else # define ALTZONE 0 # endif #endif #ifndef R_OK # define R_OK 4 #endif /* !defined R_OK */ #if PORT_TO_C89 /* ** Define HAVE_STDINT_H's default value here, rather than at the ** start, since __GLIBC__ and INTMAX_MAX's values depend on ** previously included files. glibc 2.1 and Solaris 10 and later have ** stdint.h, even with pre-C99 compilers. */ #if !defined HAVE_STDINT_H && defined __has_include # define HAVE_STDINT_H 1 /* C23 __has_include implies C99 stdint.h. */ #endif #ifndef HAVE_STDINT_H # define HAVE_STDINT_H \ (199901 <= __STDC_VERSION__ \ || 2 < __GLIBC__ + (1 <= __GLIBC_MINOR__) \ || __CYGWIN__ || INTMAX_MAX) #endif /* !defined HAVE_STDINT_H */ #if HAVE_STDINT_H # include #endif /* !HAVE_STDINT_H */ #ifndef HAVE_INTTYPES_H # define HAVE_INTTYPES_H HAVE_STDINT_H #endif #if HAVE_INTTYPES_H # include #endif /* Pre-C99 GCC compilers define __LONG_LONG_MAX__ instead of LLONG_MAX. */ #if defined __LONG_LONG_MAX__ && !defined __STRICT_ANSI__ # ifndef LLONG_MAX # define LLONG_MAX __LONG_LONG_MAX__ # endif # ifndef LLONG_MIN # define LLONG_MIN (-1 - LLONG_MAX) # endif # ifndef ULLONG_MAX # define ULLONG_MAX (LLONG_MAX * 2ull + 1) # endif #endif #ifndef INT_FAST64_MAX # if 1 <= LONG_MAX >> 31 >> 31 typedef long int_fast64_t; # define INT_FAST64_MIN LONG_MIN # define INT_FAST64_MAX LONG_MAX # else /* If this fails, compile with -DHAVE_STDINT_H or with a better compiler. */ typedef long long int_fast64_t; # define INT_FAST64_MIN LLONG_MIN # define INT_FAST64_MAX LLONG_MAX # endif #endif #ifndef PRIdFAST64 # if INT_FAST64_MAX == LONG_MAX # define PRIdFAST64 "ld" # else # define PRIdFAST64 "lld" # endif #endif #ifndef SCNdFAST64 # define SCNdFAST64 PRIdFAST64 #endif #ifndef INT_FAST32_MAX # if INT_MAX >> 31 == 0 typedef long int_fast32_t; # define INT_FAST32_MAX LONG_MAX # define INT_FAST32_MIN LONG_MIN # else typedef int int_fast32_t; # define INT_FAST32_MAX INT_MAX # define INT_FAST32_MIN INT_MIN # endif #endif #ifndef INT_LEAST32_MAX typedef int_fast32_t int_least32_t; #endif #ifndef INTMAX_MAX # ifdef LLONG_MAX typedef long long intmax_t; # ifndef HAVE_STRTOLL # define HAVE_STRTOLL 1 # endif # if HAVE_STRTOLL # define strtoimax strtoll # endif # define INTMAX_MAX LLONG_MAX # define INTMAX_MIN LLONG_MIN # else typedef long intmax_t; # define INTMAX_MAX LONG_MAX # define INTMAX_MIN LONG_MIN # endif # ifndef strtoimax # define strtoimax strtol # endif #endif #ifndef PRIdMAX # if INTMAX_MAX == LLONG_MAX # define PRIdMAX "lld" # else # define PRIdMAX "ld" # endif #endif #ifndef PTRDIFF_MAX # define PTRDIFF_MAX MAXVAL(ptrdiff_t, TYPE_BIT(ptrdiff_t)) #endif #ifndef UINT_FAST32_MAX typedef unsigned long uint_fast32_t; #endif #ifndef UINT_FAST64_MAX # if 3 <= ULONG_MAX >> 31 >> 31 typedef unsigned long uint_fast64_t; # define UINT_FAST64_MAX ULONG_MAX # else /* If this fails, compile with -DHAVE_STDINT_H or with a better compiler. */ typedef unsigned long long uint_fast64_t; # define UINT_FAST64_MAX ULLONG_MAX # endif #endif #ifndef UINTMAX_MAX # ifdef ULLONG_MAX typedef unsigned long long uintmax_t; # define UINTMAX_MAX ULLONG_MAX # else typedef unsigned long uintmax_t; # define UINTMAX_MAX ULONG_MAX # endif #endif #ifndef PRIuMAX # ifdef ULLONG_MAX # define PRIuMAX "llu" # else # define PRIuMAX "lu" # endif #endif #ifndef SIZE_MAX # define SIZE_MAX ((size_t) -1) #endif #endif /* PORT_TO_C89 */ /* The maximum size of any created object, as a signed integer. Although the C standard does not outright prohibit larger objects, behavior is undefined if the result of pointer subtraction does not fit into ptrdiff_t, and the code assumes in several places that pointer subtraction works. As a practical matter it's OK to not support objects larger than this. */ #define INDEX_MAX ((ptrdiff_t) min(PTRDIFF_MAX, SIZE_MAX)) /* Support ckd_add, ckd_sub, ckd_mul on C23 or recent-enough GCC-like hosts, unless compiled with -DHAVE_STDCKDINT_H=0 or with pre-C23 EDG. */ #if !defined HAVE_STDCKDINT_H && defined __has_include # if __has_include() # define HAVE_STDCKDINT_H 1 # endif #endif #ifdef HAVE_STDCKDINT_H # if HAVE_STDCKDINT_H # include # endif #elif defined __EDG__ /* Do nothing, to work around EDG bug . */ #elif defined __has_builtin # if __has_builtin(__builtin_add_overflow) # define ckd_add(r, a, b) __builtin_add_overflow(a, b, r) # endif # if __has_builtin(__builtin_sub_overflow) # define ckd_sub(r, a, b) __builtin_sub_overflow(a, b, r) # endif # if __has_builtin(__builtin_mul_overflow) # define ckd_mul(r, a, b) __builtin_mul_overflow(a, b, r) # endif #elif 7 <= __GNUC__ # define ckd_add(r, a, b) __builtin_add_overflow(a, b, r) # define ckd_sub(r, a, b) __builtin_sub_overflow(a, b, r) # define ckd_mul(r, a, b) __builtin_mul_overflow(a, b, r) #endif #if (defined __has_c_attribute \ && (202311 <= __STDC_VERSION__ || !defined __STRICT_ANSI__)) # define HAVE___HAS_C_ATTRIBUTE true #else # define HAVE___HAS_C_ATTRIBUTE false #endif #if HAVE___HAS_C_ATTRIBUTE # if __has_c_attribute(deprecated) # define ATTRIBUTE_DEPRECATED [[deprecated]] # endif #endif #ifndef ATTRIBUTE_DEPRECATED # if 3 < __GNUC__ + (2 <= __GNUC_MINOR__) # define ATTRIBUTE_DEPRECATED __attribute__((deprecated)) # else # define ATTRIBUTE_DEPRECATED /* empty */ # endif #endif #if HAVE___HAS_C_ATTRIBUTE # if __has_c_attribute(fallthrough) # define ATTRIBUTE_FALLTHROUGH [[fallthrough]] # endif #endif #ifndef ATTRIBUTE_FALLTHROUGH # if 7 <= __GNUC__ # define ATTRIBUTE_FALLTHROUGH __attribute__((fallthrough)) # else # define ATTRIBUTE_FALLTHROUGH ((void) 0) # endif #endif #if HAVE___HAS_C_ATTRIBUTE # if __has_c_attribute(maybe_unused) # define ATTRIBUTE_MAYBE_UNUSED [[maybe_unused]] # endif #endif #ifndef ATTRIBUTE_MAYBE_UNUSED # if 2 < __GNUC__ + (7 <= __GNUC_MINOR__) # define ATTRIBUTE_MAYBE_UNUSED __attribute__((unused)) # else # define ATTRIBUTE_MAYBE_UNUSED /* empty */ # endif #endif #if HAVE___HAS_C_ATTRIBUTE # if __has_c_attribute(noreturn) # define ATTRIBUTE_NORETURN [[noreturn]] # endif #endif #ifndef ATTRIBUTE_NORETURN # if 201112 <= __STDC_VERSION__ # define ATTRIBUTE_NORETURN _Noreturn # elif 2 < __GNUC__ + (8 <= __GNUC_MINOR__) # define ATTRIBUTE_NORETURN __attribute__((noreturn)) # else # define ATTRIBUTE_NORETURN /* empty */ # endif #endif #if HAVE___HAS_C_ATTRIBUTE # if __has_c_attribute(reproducible) # define ATTRIBUTE_REPRODUCIBLE [[reproducible]] # endif #endif #ifndef ATTRIBUTE_REPRODUCIBLE # define ATTRIBUTE_REPRODUCIBLE /* empty */ #endif #if HAVE___HAS_C_ATTRIBUTE # if __has_c_attribute(unsequenced) # define ATTRIBUTE_UNSEQUENCED [[unsequenced]] # endif #endif #ifndef ATTRIBUTE_UNSEQUENCED # define ATTRIBUTE_UNSEQUENCED /* empty */ #endif /* GCC attributes that are useful in tzcode. __attribute__((const)) is stricter than [[unsequenced]], so the latter is an adequate substitute in non-GCC C23 platforms. __attribute__((pure)) is stricter than [[reproducible]], so the latter is an adequate substitute in non-GCC C23 platforms. */ #if __GNUC__ < 3 # define ATTRIBUTE_CONST ATTRIBUTE_UNSEQUENCED # define ATTRIBUTE_FORMAT(spec) /* empty */ # define ATTRIBUTE_PURE ATTRIBUTE_REPRODUCIBLE #else # define ATTRIBUTE_CONST __attribute__((const)) # define ATTRIBUTE_FORMAT(spec) __attribute__((format spec)) # define ATTRIBUTE_PURE __attribute__((pure)) #endif /* Avoid GCC bug 114833 . Remove this macro and its uses when the bug is fixed in a GCC release, because only the latest GCC matters for $(GCC_DEBUG_FLAGS). */ #ifdef GCC_LINT # define ATTRIBUTE_PURE_114833 ATTRIBUTE_PURE #else # define ATTRIBUTE_PURE_114833 /* empty */ #endif #if (__STDC_VERSION__ < 199901 && !defined restrict \ && (PORT_TO_C89 || defined _MSC_VER)) # define restrict /* empty */ #endif /* ** Workarounds for compilers/systems. */ #ifndef EPOCH_LOCAL # define EPOCH_LOCAL 0 #endif #ifndef EPOCH_OFFSET # define EPOCH_OFFSET 0 #endif #ifndef RESERVE_STD_EXT_IDS # define RESERVE_STD_EXT_IDS 0 #endif #ifdef time_tz # define defined_time_tz true #else # define defined_time_tz false #endif /* If standard C identifiers with external linkage (e.g., localtime) are reserved and are not already being renamed anyway, rename them as if compiling with '-Dtime_tz=time_t'. */ #if !defined time_tz && RESERVE_STD_EXT_IDS && USE_LTZ # define time_tz time_t #endif /* ** Compile with -Dtime_tz=T to build the tz package with a private ** time_t type equivalent to T rather than the system-supplied time_t. ** This debugging feature can test unusual design decisions ** (e.g., time_t wider than 'long', or unsigned time_t) even on ** typical platforms. */ #if defined time_tz || EPOCH_LOCAL || EPOCH_OFFSET != 0 # define TZ_TIME_T true #else # define TZ_TIME_T false #endif #if defined LOCALTIME_IMPLEMENTATION && TZ_TIME_T static time_t sys_time(time_t *x) { return time(x); } #endif #if TZ_TIME_T typedef time_tz tz_time_t; # undef asctime # define asctime tz_asctime # undef ctime # define ctime tz_ctime # undef difftime # define difftime tz_difftime # undef gmtime # define gmtime tz_gmtime # undef gmtime_r # define gmtime_r tz_gmtime_r # undef localtime # define localtime tz_localtime # undef localtime_r # define localtime_r tz_localtime_r # undef localtime_rz # define localtime_rz tz_localtime_rz # undef mktime # define mktime tz_mktime # undef mktime_z # define mktime_z tz_mktime_z # undef offtime # define offtime tz_offtime # undef offtime_r # define offtime_r tz_offtime_r # undef posix2time # define posix2time tz_posix2time # undef posix2time_z # define posix2time_z tz_posix2time_z # undef strftime # define strftime tz_strftime # undef time # define time tz_time # undef time2posix # define time2posix tz_time2posix # undef time2posix_z # define time2posix_z tz_time2posix_z # undef time_t # define time_t tz_time_t # undef timegm # define timegm tz_timegm # undef timelocal # define timelocal tz_timelocal # undef timeoff # define timeoff tz_timeoff # undef tzalloc # define tzalloc tz_tzalloc # undef tzfree # define tzfree tz_tzfree # undef tzset # define tzset tz_tzset # if SUPPORT_POSIX2008 # undef asctime_r # define asctime_r tz_asctime_r # undef ctime_r # define ctime_r tz_ctime_r # endif # if HAVE_STRFTIME_L # undef strftime_l # define strftime_l tz_strftime_l # endif # if HAVE_TZNAME # undef tzname # define tzname tz_tzname # endif # if USG_COMPAT # undef daylight # define daylight tz_daylight # undef timezone # define timezone tz_timezone # endif # if ALTZONE # undef altzone # define altzone tz_altzone # endif # if __STDC_VERSION__ < 202311 # define DEPRECATED_IN_C23 /* empty */ # else # define DEPRECATED_IN_C23 ATTRIBUTE_DEPRECATED # endif DEPRECATED_IN_C23 char *asctime(struct tm const *); DEPRECATED_IN_C23 char *ctime(time_t const *); #if SUPPORT_POSIX2008 char *asctime_r(struct tm const *restrict, char *restrict); char *ctime_r(time_t const *, char *); #endif ATTRIBUTE_CONST double difftime(time_t, time_t); size_t strftime(char *restrict, size_t, char const *restrict, struct tm const *restrict); # if HAVE_STRFTIME_L size_t strftime_l(char *restrict, size_t, char const *restrict, struct tm const *restrict, locale_t); # endif struct tm *gmtime(time_t const *); struct tm *gmtime_r(time_t const *restrict, struct tm *restrict); struct tm *localtime(time_t const *); struct tm *localtime_r(time_t const *restrict, struct tm *restrict); time_t mktime(struct tm *); time_t time(time_t *); time_t timegm(struct tm *); void tzset(void); #endif #ifndef HAVE_DECL_TIMEGM # if (202311 <= __STDC_VERSION__ \ || defined __GLIBC__ || defined __tm_zone /* musl */ \ || defined __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ \ || (defined __APPLE__ && defined __MACH__)) # define HAVE_DECL_TIMEGM 1 # else # define HAVE_DECL_TIMEGM 0 # endif #endif #if !HAVE_DECL_TIMEGM && !defined timegm time_t timegm(struct tm *); #endif #if !HAVE_DECL_ASCTIME_R && !defined asctime_r && SUPPORT_POSIX2008 extern char *asctime_r(struct tm const *restrict, char *restrict); #endif #ifndef HAVE_DECL_ENVIRON # if defined environ || defined __USE_GNU # define HAVE_DECL_ENVIRON 1 # else # define HAVE_DECL_ENVIRON 0 # endif #endif #if !HAVE_DECL_ENVIRON extern char **environ; #endif #if 2 <= HAVE_TZNAME + (TZ_TIME_T || !HAVE_POSIX_DECLS) extern char *tzname[]; #endif #if 2 <= USG_COMPAT + (TZ_TIME_T || !HAVE_POSIX_DECLS) extern long timezone; extern int daylight; #endif #if 2 <= ALTZONE + (TZ_TIME_T || !HAVE_POSIX_DECLS) extern long altzone; #endif /* ** The STD_INSPIRED functions are similar, but most also need ** declarations if time_tz is defined. */ #ifndef STD_INSPIRED # ifdef __NetBSD__ # define STD_INSPIRED 1 # else # define STD_INSPIRED 0 # endif #endif #if STD_INSPIRED # if TZ_TIME_T || !defined offtime struct tm *offtime(time_t const *, long); # endif # if TZ_TIME_T || !defined offtime_r -struct tm *offtime_r(time_t const *, long, struct tm *); +struct tm *offtime_r(time_t const *restrict, long, struct tm *restrict); # endif # if TZ_TIME_T || !defined timelocal time_t timelocal(struct tm *); # endif # if TZ_TIME_T || !defined timeoff # define EXTERN_TIMEOFF # endif # if TZ_TIME_T || !defined time2posix time_t time2posix(time_t); # endif # if TZ_TIME_T || !defined posix2time time_t posix2time(time_t); # endif #endif /* Infer TM_ZONE on systems where this information is known, but suppress guessing if NO_TM_ZONE is defined. Similarly for TM_GMTOFF. */ #if (200809 < _POSIX_VERSION \ || defined __GLIBC__ \ || defined __tm_zone /* musl */ \ || defined __FreeBSD__ || defined __NetBSD__ || defined __OpenBSD__ \ || (defined __APPLE__ && defined __MACH__)) # if !defined TM_GMTOFF && !defined NO_TM_GMTOFF # define TM_GMTOFF tm_gmtoff # endif # if !defined TM_ZONE && !defined NO_TM_ZONE # define TM_ZONE tm_zone # endif #endif /* ** Define functions that are ABI compatible with NetBSD but have ** better prototypes. NetBSD 6.1.4 defines a pointer type timezone_t ** and labors under the misconception that 'const timezone_t' is a ** pointer to a constant. This use of 'const' is ineffective, so it ** is not done here. What we call 'struct state' NetBSD calls ** 'struct __state', but this is a private name so it doesn't matter. */ #if NETBSD_INSPIRED typedef struct state *timezone_t; struct tm *localtime_rz(timezone_t restrict, time_t const *restrict, struct tm *restrict); time_t mktime_z(timezone_t restrict, struct tm *restrict); timezone_t tzalloc(char const *); void tzfree(timezone_t); # if STD_INSPIRED # if TZ_TIME_T || !defined posix2time_z ATTRIBUTE_PURE time_t posix2time_z(timezone_t, time_t); # endif # if TZ_TIME_T || !defined time2posix_z ATTRIBUTE_PURE time_t time2posix_z(timezone_t, time_t); # endif # endif #endif /* ** Finally, some convenience items. */ #define TYPE_BIT(type) (CHAR_BIT * (ptrdiff_t) sizeof(type)) #define TYPE_SIGNED(type) (((type) -1) < 0) #define TWOS_COMPLEMENT(t) ((t) ~ (t) 0 < 0) /* Minimum and maximum of two values. Use lower case to avoid naming clashes with standard include files. */ #define max(a, b) ((a) > (b) ? (a) : (b)) #define min(a, b) ((a) < (b) ? (a) : (b)) /* Max and min values of the integer type T, of which only the bottom B bits are used, and where the highest-order used bit is considered to be a sign bit if T is signed. */ #define MAXVAL(t, b) \ ((t) (((t) 1 << ((b) - 1 - TYPE_SIGNED(t))) \ - 1 + ((t) 1 << ((b) - 1 - TYPE_SIGNED(t))))) #define MINVAL(t, b) \ ((t) (TYPE_SIGNED(t) ? - TWOS_COMPLEMENT(t) - MAXVAL(t, b) : 0)) /* The extreme time values, assuming no padding. */ #define TIME_T_MIN_NO_PADDING MINVAL(time_t, TYPE_BIT(time_t)) #define TIME_T_MAX_NO_PADDING MAXVAL(time_t, TYPE_BIT(time_t)) /* The extreme time values. These are macros, not constants, so that any portability problems occur only when compiling .c files that use the macros, which is safer for applications that need only zdump and zic. This implementation assumes no padding if time_t is signed and either the compiler lacks support for _Generic or time_t is not one of the standard signed integer types. */ #if HAVE__GENERIC # define TIME_T_MIN \ _Generic((time_t) 0, \ signed char: SCHAR_MIN, short: SHRT_MIN, \ int: INT_MIN, long: LONG_MIN, long long: LLONG_MIN, \ default: TIME_T_MIN_NO_PADDING) # define TIME_T_MAX \ (TYPE_SIGNED(time_t) \ ? _Generic((time_t) 0, \ signed char: SCHAR_MAX, short: SHRT_MAX, \ int: INT_MAX, long: LONG_MAX, long long: LLONG_MAX, \ default: TIME_T_MAX_NO_PADDING) \ : (time_t) -1) enum { SIGNED_PADDING_CHECK_NEEDED = _Generic((time_t) 0, signed char: false, short: false, int: false, long: false, long long: false, default: true) }; #else # define TIME_T_MIN TIME_T_MIN_NO_PADDING # define TIME_T_MAX TIME_T_MAX_NO_PADDING enum { SIGNED_PADDING_CHECK_NEEDED = true }; #endif /* Try to check the padding assumptions. Although TIME_T_MAX and the following check can both have undefined behavior on oddball platforms due to shifts exceeding widths of signed integers, these platforms' compilers are likely to diagnose these issues in integer constant expressions, so it shouldn't hurt to check statically. */ static_assert(! TYPE_SIGNED(time_t) || ! SIGNED_PADDING_CHECK_NEEDED || TIME_T_MAX >> (TYPE_BIT(time_t) - 2) == 1); /* ** 302 / 1000 is log10(2.0) rounded up. ** Subtract one for the sign bit if the type is signed; ** add one for integer division truncation; ** add one more for a minus sign if the type is signed. */ #define INT_STRLEN_MAXIMUM(type) \ ((TYPE_BIT(type) - TYPE_SIGNED(type)) * 302 / 1000 + \ 1 + TYPE_SIGNED(type)) /* ** INITIALIZE(x) */ #ifdef GCC_LINT # define INITIALIZE(x) ((x) = 0) #else # define INITIALIZE(x) #endif /* Whether memory access must strictly follow the C standard. If 0, it's OK to read uninitialized storage so long as the value is not relied upon. Defining it to 0 lets mktime access parts of struct tm that might be uninitialized, as a heuristic when the standard doesn't say what to return and when tm_gmtoff can help mktime likely infer a better value. */ #ifndef UNINIT_TRAP # define UNINIT_TRAP 0 #endif /* strftime.c sometimes needs access to timeoff if it is not already public. tz_private_timeoff should be used only by localtime.c and strftime.c. */ #if (!defined EXTERN_TIMEOFF \ && defined TM_GMTOFF && (200809 < _POSIX_VERSION || ! UNINIT_TRAP)) # ifndef timeoff # define timeoff tz_private_timeoff # endif # define EXTERN_TIMEOFF #endif #ifdef EXTERN_TIMEOFF time_t timeoff(struct tm *, long); #endif #ifdef DEBUG # undef unreachable # define unreachable() abort() #elif !defined unreachable # ifdef __has_builtin # if __has_builtin(__builtin_unreachable) # define unreachable() __builtin_unreachable() # endif # elif 4 < __GNUC__ + (5 <= __GNUC_MINOR__) # define unreachable() __builtin_unreachable() # endif # ifndef unreachable # define unreachable() ((void) 0) # endif #endif /* ** For the benefit of GNU folk... ** '_(MSGID)' uses the current locale's message library string for MSGID. ** The default is to use gettext if available, and use MSGID otherwise. */ #if HAVE_GETTEXT #define _(msgid) gettext(msgid) #else /* !HAVE_GETTEXT */ #define _(msgid) msgid #endif /* !HAVE_GETTEXT */ #if !defined TZ_DOMAIN && defined HAVE_GETTEXT # define TZ_DOMAIN "tz" #endif #if HAVE_INCOMPATIBLE_CTIME_R #undef asctime_r #undef ctime_r char *asctime_r(struct tm const *restrict, char *restrict); char *ctime_r(time_t const *, char *); #endif /* HAVE_INCOMPATIBLE_CTIME_R */ /* Handy macros that are independent of tzfile implementation. */ enum { SECSPERMIN = 60, MINSPERHOUR = 60, SECSPERHOUR = SECSPERMIN * MINSPERHOUR, HOURSPERDAY = 24, DAYSPERWEEK = 7, DAYSPERNYEAR = 365, DAYSPERLYEAR = DAYSPERNYEAR + 1, MONSPERYEAR = 12, YEARSPERREPEAT = 400 /* years before a Gregorian repeat */ }; #define SECSPERDAY ((int_fast32_t) SECSPERHOUR * HOURSPERDAY) #define DAYSPERREPEAT ((int_fast32_t) 400 * 365 + 100 - 4 + 1) #define SECSPERREPEAT ((int_fast64_t) DAYSPERREPEAT * SECSPERDAY) #define AVGSECSPERYEAR (SECSPERREPEAT / YEARSPERREPEAT) /* How many years to generate (in zic.c) or search through (in localtime.c). This is two years larger than the obvious 400, to avoid edge cases. E.g., suppose a rule applies from 2012 on with transitions in March and September, plus one-off transitions in November 2013, and suppose the rule cannot be expressed as a proleptic TZ string. If zic looked only at the last 400 years, it would set max_year=2413, with the intent that the 400 years 2014 through 2413 will be repeated. The last transition listed in the tzfile would be in 2413-09, less than 400 years after the last one-off transition in 2013-11. Two years is not overkill for localtime.c, as a one-year bump would mishandle 2023d's America/Ciudad_Juarez for November 2422. */ enum { years_of_observations = YEARSPERREPEAT + 2 }; enum { TM_SUNDAY, TM_MONDAY, TM_TUESDAY, TM_WEDNESDAY, TM_THURSDAY, TM_FRIDAY, TM_SATURDAY }; enum { TM_JANUARY, TM_FEBRUARY, TM_MARCH, TM_APRIL, TM_MAY, TM_JUNE, TM_JULY, TM_AUGUST, TM_SEPTEMBER, TM_OCTOBER, TM_NOVEMBER, TM_DECEMBER }; enum { TM_YEAR_BASE = 1900, TM_WDAY_BASE = TM_MONDAY, EPOCH_YEAR = 1970, EPOCH_WDAY = TM_THURSDAY }; #define isleap(y) (((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) == 0)) /* ** Since everything in isleap is modulo 400 (or a factor of 400), we know that ** isleap(y) == isleap(y % 400) ** and so ** isleap(a + b) == isleap((a + b) % 400) ** or ** isleap(a + b) == isleap(a % 400 + b % 400) ** This is true even if % means modulo rather than Fortran remainder ** (which is allowed by C89 but not by C99 or later). ** We use this to avoid addition overflow problems. */ #define isleap_sum(a, b) isleap((a) % 400 + (b) % 400) #endif /* !defined PRIVATE_H */ diff --git a/include/time.h b/include/time.h index 89a76ca5fd93..9e71a85f6a9a 100644 --- a/include/time.h +++ b/include/time.h @@ -1,199 +1,201 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 1989, 1993 * The Regents of the University of California. All rights reserved. * (c) UNIX System Laboratories, Inc. * All or some portions of this file are derived from material licensed * to the University of California by American Telephone and Telegraph * Co. or Unix System Laboratories, Inc. and are reproduced herein with * the permission of UNIX System Laboratories, Inc. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /* */ #ifndef _TIME_H_ #define _TIME_H_ #include #include #include #include #if __POSIX_VISIBLE > 0 && __POSIX_VISIBLE < 200112 || __BSD_VISIBLE /* * Frequency of the clock ticks reported by times(). Deprecated - use * sysconf(_SC_CLK_TCK) instead. (Removed in 1003.1-2001.) */ #define CLK_TCK 128 #endif /* Frequency of the clock ticks reported by clock(). */ #define CLOCKS_PER_SEC 128 #ifndef _CLOCK_T_DECLARED typedef __clock_t clock_t; #define _CLOCK_T_DECLARED #endif #ifndef _TIME_T_DECLARED typedef __time_t time_t; #define _TIME_T_DECLARED #endif #ifndef _SIZE_T_DECLARED typedef __size_t size_t; #define _SIZE_T_DECLARED #endif #if __POSIX_VISIBLE >= 199309 /* * New in POSIX 1003.1b-1993. */ #ifndef _CLOCKID_T_DECLARED typedef __clockid_t clockid_t; #define _CLOCKID_T_DECLARED #endif #ifndef _TIMER_T_DECLARED typedef __timer_t timer_t; #define _TIMER_T_DECLARED #endif #include #endif /* __POSIX_VISIBLE >= 199309 */ #if __POSIX_VISIBLE >= 200112 #ifndef _PID_T_DECLARED typedef __pid_t pid_t; #define _PID_T_DECLARED #endif #endif struct tm { int tm_sec; /* seconds after the minute [0-60] */ int tm_min; /* minutes after the hour [0-59] */ int tm_hour; /* hours since midnight [0-23] */ int tm_mday; /* day of the month [1-31] */ int tm_mon; /* months since January [0-11] */ int tm_year; /* years since 1900 */ int tm_wday; /* days since Sunday [0-6] */ int tm_yday; /* days since January 1 [0-365] */ int tm_isdst; /* Daylight Savings Time flag */ long tm_gmtoff; /* offset from UTC in seconds */ char *tm_zone; /* timezone abbreviation */ }; #if __POSIX_VISIBLE extern char *tzname[]; #endif __BEGIN_DECLS char *asctime(const struct tm *); clock_t clock(void); char *ctime(const time_t *); #ifndef _STANDALONE double difftime(time_t, time_t); #endif /* XXX missing: getdate() */ struct tm *gmtime(const time_t *); struct tm *localtime(const time_t *); time_t mktime(struct tm *); size_t strftime(char * __restrict, size_t, const char * __restrict, const struct tm * __restrict); time_t time(time_t *); #if __POSIX_VISIBLE >= 200112 struct sigevent; int timer_create(clockid_t, struct sigevent *__restrict, timer_t *__restrict); int timer_delete(timer_t); int timer_gettime(timer_t, struct itimerspec *); int timer_getoverrun(timer_t); int timer_settime(timer_t, int, const struct itimerspec *__restrict, struct itimerspec *__restrict); #endif #if __POSIX_VISIBLE void tzset(void); #endif #if __POSIX_VISIBLE >= 199309 int clock_getres(clockid_t, struct timespec *); int clock_gettime(clockid_t, struct timespec *); int clock_settime(clockid_t, const struct timespec *); int nanosleep(const struct timespec *, struct timespec *); #endif /* __POSIX_VISIBLE >= 199309 */ #if __POSIX_VISIBLE >= 200112 int clock_getcpuclockid(pid_t, clockid_t *); int clock_nanosleep(clockid_t, int, const struct timespec *, struct timespec *); #endif #if __POSIX_VISIBLE >= 199506 char *asctime_r(const struct tm *, char *); char *ctime_r(const time_t *, char *); #endif #if __POSIX_VISIBLE >= 199506 || __ISO_C_VISIBLE >= 2023 struct tm *gmtime_r(const time_t *, struct tm *); struct tm *localtime_r(const time_t *, struct tm *); #endif #if __XSI_VISIBLE char *strptime(const char * __restrict, const char * __restrict, struct tm * __restrict); extern long timezone; extern int daylight; #endif #if __BSD_VISIBLE time_t timelocal(struct tm * const); time_t timegm(struct tm * const); int timer_oshandle_np(timer_t timerid); time_t time2posix(time_t t); time_t posix2time(time_t t); +struct tm *offtime(const time_t *, long); +struct tm *offtime_r(const time_t *__restrict, long, struct tm *__restrict); #endif /* __BSD_VISIBLE */ #if __POSIX_VISIBLE >= 200809 || defined(_XLOCALE_H_) #include #endif #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 2011 || \ (defined(__cplusplus) && __cplusplus >= 201703) #include /* ISO/IEC 9899:2011 7.27.2.5 The timespec_get function */ #define TIME_UTC 1 /* time elapsed since epoch */ int timespec_get(struct timespec *ts, int base); #if __BSD_VISIBLE || __ISO_C_VISIBLE >= 2023 /* ISO/IEC 9899:2024 7.29.1 Components of time */ #define TIME_MONOTONIC 2 /* monotonic time */ /* ISO/IEC 9899:2024 7.29.2.7 The timespec_getres function */ int timespec_getres(struct timespec *, int); #endif #endif __END_DECLS #endif /* !_TIME_H_ */ diff --git a/lib/libc/stdtime/ctime.3 b/lib/libc/stdtime/ctime.3 index 96b7f775535a..6384e8bd959b 100644 --- a/lib/libc/stdtime/ctime.3 +++ b/lib/libc/stdtime/ctime.3 @@ -1,402 +1,429 @@ .\" Copyright (c) 1989, 1991, 1993 .\" The Regents of the University of California. All rights reserved. .\" .\" This code is derived from software contributed to Berkeley by .\" Arthur Olson. .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" 3. Neither the name of the University nor the names of its contributors .\" may be used to endorse or promote products derived from this software .\" without specific prior written permission. .\" .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" -.Dd March 26, 2024 +.Dd September 23, 2025 .Dt CTIME 3 .Os .Sh NAME .Nm asctime , .Nm asctime_r , .Nm ctime , .Nm ctime_r , .Nm difftime , .Nm gmtime , .Nm gmtime_r , .Nm localtime , .Nm localtime_r , .Nm mktime , +.Nm offtime , +.Nm offtime_r , .Nm timegm .Nd transform binary date and time values .Sh LIBRARY .Lb libc .Sh SYNOPSIS .In time.h .Vt extern char *tzname[2] ; .Ft char * .Fn asctime "const struct tm *tm" .Ft char * .Fn asctime_r "const struct tm *tm" "char *buf" .Ft char * .Fn ctime "const time_t *clock" .Ft char * .Fn ctime_r "const time_t *clock" "char *buf" .Ft double .Fn difftime "time_t time1" "time_t time0" .Ft struct tm * .Fn gmtime "const time_t *clock" .Ft struct tm * .Fn gmtime_r "const time_t *clock" "struct tm *result" .Ft struct tm * .Fn localtime "const time_t *clock" .Ft struct tm * .Fn localtime_r "const time_t *clock" "struct tm *result" .Ft time_t .Fn mktime "struct tm *tm" +.Ft struct tm * +.Fn offtime "const time_t *clock" "long offset" +.Ft struct tm * +.Fn offtime_r "const time_t *clock" "long offset" "struct tm *result" .Ft time_t .Fn timegm "struct tm *tm" .Sh DESCRIPTION The .Fn ctime , .Fn gmtime , +.Fn localtime , and -.Fn localtime +.Fn offtime functions all take as argument a pointer to a time value representing the time in seconds since the Epoch (00:00:00 UTC on January 1, 1970; see .Xr time 3 ) . .Pp The .Fn localtime function converts the time value pointed to by .Fa clock , and returns a pointer to a .Vt struct tm (described below) which contains the broken-out time information for the value after adjusting for the current time zone (see .Xr tzset 3 ) . When the specified time translates to a year that will not fit in an .Vt int , .Fn localtime returns .Dv NULL . The .Fn localtime function uses .Xr tzset 3 to initialize time conversion information if .Xr tzset 3 has not already been called by the process. .Pp After filling in the .Vt struct tm , .Fn localtime sets the .Va tm_isdst Ns 'th element of .Va tzname to a pointer to an ASCII string that is the time zone abbreviation to be used with .Fn localtime Ns 's return value. .Pp The .Fn gmtime function similarly converts the time value, but without any time zone adjustment, and returns a pointer to a .Vt struct tm . .Pp The +.Fn offtime +function similarly converts the time value with a time zone adjustment +corresponding to the provided +.Fa offset , +which is expressed in seconds, with positive values indicating a time +zone ahead of UTC (east of the Prime Meridian). +It does not call +.Xr tzset 3 +or modify +.Va tzname . +.Pp +The .Fn ctime function adjusts the time value for the current time zone in the same manner as .Fn localtime , and returns a pointer to a 26-character string of the form: .Bd -literal -offset indent Thu Nov 24 18:22:48 1986\en\e0 .Ed .Pp All the fields have constant width. .Pp The .Fn asctime function converts the broken down time in the .Vt struct tm pointed to by .Fa tm to the form shown in the example above. .Pp The .Fn ctime_r and .Fn asctime_r functions provide the same functionality as .Fn ctime and .Fn asctime except the caller must provide the output buffer .Fa buf , which must be at least 26 characters long, to store the result in. The -.Fn localtime_r +.Fn localtime_r , +.Fn gmtime_r , and -.Fn gmtime_r +.Fn offtime_r functions provide the same functionality as -.Fn localtime +.Fn localtime , +.Fn gmtime , and -.Fn gmtime +.Fn offtime respectively, except the caller must provide the output buffer .Fa result . .Pp The functions .Fn mktime and .Fn timegm convert the broken-down time in the .Vt struct tm pointed to by .Fa tm into a time value with the same encoding as that of the values returned by the .Xr time 3 function (that is, seconds from the Epoch, UTC). The .Fn mktime function interprets the input structure according to the current timezone setting (see .Xr tzset 3 ) while the .Fn timegm function interprets the input structure as representing Universal Coordinated Time .Pq UTC . .Pp The original values of the .Fa tm_wday and .Fa tm_yday components of the structure are ignored, and the original values of the other components are not restricted to their normal ranges, and will be normalized if needed. For example, October 40 is changed into November 9, a .Fa tm_hour of \-1 means 1 hour before midnight, .Fa tm_mday of 0 means the day preceding the current month, and .Fa tm_mon of \-2 means 2 months before January of .Fa tm_year . (A positive or zero value for .Fa tm_isdst causes .Fn mktime to presume initially that summer time (for example, Daylight Saving Time) is or is not in effect for the specified time, respectively. A negative value for .Fa tm_isdst causes the .Fn mktime function to attempt to guess whether summer time is in effect for the specified time. The .Fa tm_isdst and .Fa tm_gmtoff members are forced to zero by .Fn timegm . ) .Pp On successful completion, the values of the .Fa tm_wday and .Fa tm_yday components of the structure are set appropriately, and the other components are set to represent the specified calendar time, but with their values forced to their normal ranges; the final value of .Fa tm_mday is not set until .Fa tm_mon and .Fa tm_year are determined. The .Fn mktime function returns the specified calendar time; if the calendar time cannot be represented, it returns \-1 and sets .Xr errno 3 to an appropriate value. .Pp Note that \-1 is a valid result (representing one second before midnight UTC on the evening of 31 December 1969), so this cannot be relied upon to indicate success or failure; instead, .Fa tm_wday and / or .Fa tm_yday should be set to an out-of-bounds value (e.g. \-1) prior to calling .Fn mktime or .Fn timegm and checked after the call. .Pp The .Fn difftime function returns the difference in seconds between two time values, .Fa time1 \- .Fa time0 . .Pp External declarations as well as the definition of .Vt struct tm are in the .In time.h header. The .Vt tm structure includes at least the following fields: .Bd -literal -offset indent int tm_sec; /* seconds (0 - 60) */ int tm_min; /* minutes (0 - 59) */ int tm_hour; /* hours (0 - 23) */ int tm_mday; /* day of month (1 - 31) */ int tm_mon; /* month of year (0 - 11) */ int tm_year; /* year \- 1900 */ int tm_wday; /* day of week (Sunday = 0) */ int tm_yday; /* day of year (0 - 365) */ int tm_isdst; /* is summer time in effect? */ char *tm_zone; /* abbreviation of timezone name */ long tm_gmtoff; /* offset from UTC in seconds */ .Ed .Pp The .Fa tm_isdst field is non-zero if summer time is in effect. .Pp The .Fa tm_gmtoff field is the offset in seconds of the time represented from UTC, with positive values indicating a time zone ahead of UTC (east of the Prime Meridian). .Sh SEE ALSO .Xr date 1 , .Xr clock_gettime 2 , .Xr gettimeofday 2 , .Xr getenv 3 , .Xr time 3 , .Xr tzset 3 , .Xr tzfile 5 .Sh STANDARDS The .Fn asctime , .Fn ctime , .Fn difftime , .Fn gmtime , .Fn localtime , and .Fn mktime functions conform to .St -isoC , and conform to .St -p1003.1-96 provided the selected local timezone does not contain a leap-second table (see .Xr zic 8 ) . .Pp The .Fn asctime_r , .Fn ctime_r , .Fn gmtime_r , and .Fn localtime_r functions are expected to conform to .St -p1003.1-96 (again provided the selected local timezone does not contain a leap-second table). .Pp The .Fn timegm function is not specified by any standard; its function cannot be completely emulated using the standard functions described above. .Sh HISTORY This manual page is derived from the time package contributed to Berkeley by .An Arthur Olson and which appeared in .Bx 4.3 . .Pp The functions .Fn asctime , .Fn gmtime , and .Fn localtime first appeared in .At v5 , .Fn difftime and .Fn mktime in .Bx 4.3 Reno , and .Fn timegm and .Fn timelocal in SunOS 4.0. .Pp The .Fn asctime_r , .Fn ctime_r , .Fn gmtime_r and .Fn localtime_r functions have been available since .Fx 8.0 . +The +.Fn offtime +and +.Fn offtime_r +functions were added in +.Fx 15.0 . .Sh BUGS Except for .Fn difftime , .Fn mktime , and the .Fn \&_r variants of the other functions, these functions leave their result in an internal static object and return a pointer to that object. Subsequent calls to these function will modify the same object. .Pp The C Standard provides no mechanism for a program to modify its current local timezone setting, and the POSIX-standard method is not reentrant. (However, thread-safe implementations are provided in the POSIX threaded environment.) .Pp The .Va tm_zone field of a returned .Vt tm structure points to a static array of characters, which will also be overwritten by any subsequent calls (as well as by subsequent calls to .Xr tzset 3 ) . .Pp Use of the external variable .Fa tzname is discouraged; the .Fa tm_zone entry in the tm structure is preferred.