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