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