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