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