307ebf5f84d31ea6ae13e04204880de60c716e7b
[reactos.git] / reactos / lib / msvcrt / time / ctime.c
1
2 // fix djdir
3
4 /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
5 /* This file has been modified by DJ Delorie. These modifications are
6 ** Copyright (C) 1995 DJ Delorie, 24 Kirsten Ave, Rochester NH,
7 ** 03867-2954, USA.
8 */
9
10 /*
11 * Copyright (c) 1987, 1989 Regents of the University of California.
12 * All rights reserved.
13 *
14 * This code is derived from software contributed to Berkeley by
15 * Arthur David Olson of the National Cancer Institute.
16 *
17 * Redistribution and use in source and binary forms are permitted provided
18 * that: (1) source distributions retain this entire copyright notice and
19 * comment, and (2) distributions including binaries display the following
20 * acknowledgement: ``This product includes software developed by the
21 * University of California, Berkeley and its contributors'' in the
22 * documentation or other materials provided with the distribution and in
23 * all advertising materials mentioning features or use of this software.
24 * Neither the name of the University nor the names of its contributors may
25 * be used to endorse or promote products derived from this software without
26 * specific prior written permission.
27 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
28 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
29 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
30 */
31
32 /*
33 ** Leap second handling from Bradley White (bww@k.gp.cs.cmu.edu).
34 ** POSIX-style TZ environment variable handling from Guy Harris
35 ** (guy@auspex.com).
36 */
37
38 #include <msvcrt/fcntl.h>
39 #include <msvcrt/time.h>
40 #include <msvcrt/string.h>
41 #include <msvcrt/ctype.h>
42 #include <msvcrt/stdio.h>
43 #include <msvcrt/stdlib.h>
44
45 #include <windows.h>
46 #include "tzfile.h"
47
48 #include <msvcrt/io.h>
49
50 #include "posixrul.h"
51
52
53 #ifdef __cplusplus
54 #define CPP_CONST const
55 #else
56 #define CPP_CONST
57 #endif
58
59 #define P(s) s
60 #define alloc_size_t size_t
61 #define qsort_size_t size_t
62 #define fread_size_t size_t
63 #define fwrite_size_t size_t
64
65 #define ACCESS_MODE O_RDONLY|O_BINARY
66 #define OPEN_MODE O_RDONLY|O_BINARY
67
68 /*
69 ** Someone might make incorrect use of a time zone abbreviation:
70 ** 1. They might reference tzname[0] before calling tzset (explicitly
71 ** or implicitly).
72 ** 2. They might reference tzname[1] before calling tzset (explicitly
73 ** or implicitly).
74 ** 3. They might reference tzname[1] after setting to a time zone
75 ** in which Daylight Saving Time is never observed.
76 ** 4. They might reference tzname[0] after setting to a time zone
77 ** in which Standard Time is never observed.
78 ** 5. They might reference tm.TM_ZONE after calling offtime.
79 ** What's best to do in the above cases is open to debate;
80 ** for now, we just set things up so that in any of the five cases
81 ** WILDABBR is used. Another possibility: initialize tzname[0] to the
82 ** string "tzname[0] used before set", and similarly for the other cases.
83 ** And another: initialize tzname[0] to "ERA", with an explanation in the
84 ** manual page of what this "time zone abbreviation" means (doing this so
85 ** that tzname[0] has the "normal" length of three characters).
86 */
87
88 void _set_daylight_export(int);
89 void _set_timezone_export(int);
90
91
92 static char WILDABBR[] = " ";
93
94 #ifndef TRUE
95 #define TRUE 1
96 #define FALSE 0
97 #endif /* !defined TRUE */
98
99 static const char GMT[] = "GMT";
100
101 struct ttinfo { /* time type information */
102 long tt_gmtoff; /* GMT offset in seconds */
103 int tt_isdst; /* used to set tm_isdst */
104 int tt_abbrind; /* abbreviation list index */
105 int tt_ttisstd; /* TRUE if transition is std time */
106 };
107
108 struct lsinfo { /* leap second information */
109 time_t ls_trans; /* transition time */
110 long ls_corr; /* correction to apply */
111 };
112
113 struct state {
114 int leapcnt;
115 int timecnt;
116 int typecnt;
117 int charcnt;
118 time_t ats[TZ_MAX_TIMES];
119 unsigned char types[TZ_MAX_TIMES];
120 struct ttinfo ttis[TZ_MAX_TYPES];
121 char chars[(TZ_MAX_CHARS + 1 > sizeof GMT) ? TZ_MAX_CHARS + 1 : sizeof GMT];
122 struct lsinfo lsis[TZ_MAX_LEAPS];
123 };
124
125 struct rule {
126 int r_type; /* type of rule--see below */
127 int r_day; /* day number of rule */
128 int r_week; /* week number of rule */
129 int r_mon; /* month number of rule */
130 long r_time; /* transition time of rule */
131 };
132
133 #define JULIAN_DAY 0 /* Jn - Julian day */
134 #define DAY_OF_YEAR 1 /* n - day of year */
135 #define MONTH_NTH_DAY_OF_WEEK 2 /* Mm.n.d - month, week, day of week */
136
137 /*
138 ** Prototypes for static functions.
139 */
140 #if 0
141 static long detzcode P((const char * codep));
142 static const char * getzname P((const char * strp));
143 static const char * getnum P((const char * strp, int * nump, int min, int max));
144 static const char * getsecs P((const char * strp, long * secsp));
145 static const char * getoffset P((const char * strp, long * offsetp));
146 static const char * getrule P((const char * strp, struct rule * rulep));
147 static void gmtload P((struct state * sp));
148 static void gmtsub P((const time_t * timep, long offset, struct tm * tmp));
149 static void localsub P((const time_t * timep, long offset, struct tm * tmp));
150 static void normalize P((int * tensptr, int * unitsptr, int base));
151 static void settzname P((void));
152 static time_t time1 P((struct tm * tmp, void (* funcp)(const time_t * CPP_CONST, const long, struct tm * CPP_CONST), long offset));
153 static time_t time2 P((struct tm *tmp, void (* funcp)(const time_t * CPP_CONST, const long, struct tm * CPP_CONST), long offset, int * okayp));
154 static void timesub P((const time_t * timep, long offset, const struct state * sp, struct tm * tmp));
155 static int tmcomp P((const struct tm * atmp, const struct tm * btmp));
156 static time_t transtime P((time_t janfirst, int year, const struct rule * rulep, long offset));
157 static int tzload P((const char * name, struct state * sp));
158 static int tzparse P((const char * name, struct state * sp, int lastditch));
159 static void tzsetwall(void);
160
161 #else
162
163 static const char * getnum(const char * strp, int * CPP_CONST nump, const int min, const int max);
164 static void timesub(const time_t * CPP_CONST timep, const long offset, const struct state * CPP_CONST sp, struct tm * CPP_CONST tmp);
165 static time_t transtime(const time_t janfirst, const int year, const struct rule * CPP_CONST rulep, const long offset);
166 static void tzsetwall(void);
167
168 #endif
169
170 #ifdef ALL_STATE
171 static struct state *lclptr;
172 static struct state *gmtptr;
173 #endif /* defined ALL_STATE */
174
175 #ifndef ALL_STATE
176 static struct state lclmem;
177 static struct state gmtmem;
178 #define lclptr (&lclmem)
179 #define gmtptr (&gmtmem)
180 #endif /* State Farm */
181
182 static int lcl_is_set;
183 static int gmt_is_set;
184
185 char * _tzname[2] = {
186 WILDABBR,
187 WILDABBR
188 };
189
190 static long
191 detzcode(const char * CPP_CONST codep)
192 {
193 long result;
194 int i;
195
196 result = 0;
197 for (i = 0; i < 4; ++i)
198 result = (result << 8) | (codep[i] & 0xff);
199 return result;
200 }
201
202 static void
203 settzname(void)
204 {
205 const struct state * CPP_CONST sp = lclptr;
206 int i;
207
208 _tzname[0] = WILDABBR;
209 _tzname[1] = WILDABBR;
210 #ifdef ALL_STATE
211 if (sp == NULL)
212 {
213 _tzname[0] = _tzname[1] = GMT;
214 return;
215 }
216 #endif /* defined ALL_STATE */
217 for (i = 0; i < sp->typecnt; ++i)
218 {
219 register const struct ttinfo * CPP_CONST ttisp = &sp->ttis[i];
220
221 _tzname[ttisp->tt_isdst] =
222 (char *)&sp->chars[ttisp->tt_abbrind];
223 #if 0
224 if (ttisp->tt_isdst) {
225 //_daylight = 1;
226 _set_daylight_export(1);
227 }
228 if (i == 0 || !ttisp->tt_isdst) {
229 //_timezone_dll = -(ttisp->tt_gmtoff);
230 _set_timezone_export(-(ttisp->tt_gmtoff));
231 }
232 if (i == 0 || ttisp->tt_isdst) {
233 _altzone = -(ttisp->tt_gmtoff);
234 }
235 #endif
236 }
237 /*
238 ** And to get the latest zone names into tzname. . .
239 */
240 for (i = 0; i < sp->timecnt; ++i)
241 {
242 const struct ttinfo * CPP_CONST ttisp = &sp->ttis[sp->types[i]];
243
244 _tzname[ttisp->tt_isdst] = (char *)&sp->chars[ttisp->tt_abbrind];
245 }
246 }
247
248 static char *
249 tzdir(void)
250 {
251 static char dir[80]={0}, *cp;
252 if (dir[0] == 0)
253 {
254 if ((cp = getenv("TZDIR")))
255 {
256 strcpy(dir, cp);
257 }
258 else if ((cp = getenv("DJDIR")))
259 {
260 strcpy(dir, cp);
261 strcat(dir, "/zoneinfo");
262 }
263 else
264 strcpy(dir, "./");
265 }
266 return dir;
267 }
268
269 static int
270 tzload(const char *name, struct state * CPP_CONST sp)
271 {
272 const char * p;
273 int i;
274 int fid;
275 char fullname[FILENAME_MAX + 1];
276 const struct tzhead * tzhp;
277 char buf[sizeof *sp + sizeof *tzhp];
278 int ttisstdcnt;
279
280 if (name == NULL && (name = TZDEFAULT) == NULL)
281 return -1;
282
283 if (name[0] == ':')
284 ++name;
285 if (name[0] != '/')
286 {
287 if ((p = tzdir()) == NULL)
288 return -1;
289 if ((strlen(p) + strlen(name) + 1) >= sizeof fullname)
290 return -1;
291 strcpy(fullname, p);
292 strcat(fullname, "/");
293 strcat(fullname, name);
294 name = fullname;
295 }
296
297 if ((fid = open(name, OPEN_MODE)) == -1)
298 {
299 const char *base = strrchr(name, '/');
300 if (base)
301 base++;
302 else
303 base = name;
304 if (strcmp(base, "posixrules"))
305 return -1;
306
307 /* We've got a built-in copy of posixrules just in case */
308 memcpy(buf, _posixrules_data, sizeof(_posixrules_data));
309 i = sizeof(_posixrules_data);
310 }
311 else
312 {
313 i = read(fid, buf, sizeof buf);
314 if (close(fid) != 0 || i < sizeof *tzhp)
315 return -1;
316 }
317
318 tzhp = (struct tzhead *) buf;
319 ttisstdcnt = (int) detzcode(tzhp->tzh_ttisstdcnt);
320 sp->leapcnt = (int) detzcode(tzhp->tzh_leapcnt);
321 sp->timecnt = (int) detzcode(tzhp->tzh_timecnt);
322 sp->typecnt = (int) detzcode(tzhp->tzh_typecnt);
323 sp->charcnt = (int) detzcode(tzhp->tzh_charcnt);
324 if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS ||
325 sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES ||
326 sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES ||
327 sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||
328 (ttisstdcnt != sp->typecnt && ttisstdcnt != 0))
329 return -1;
330 if (i < sizeof *tzhp +
331 sp->timecnt * (4 + sizeof (char)) +
332 sp->typecnt * (4 + 2 * sizeof (char)) +
333 sp->charcnt * sizeof (char) +
334 sp->leapcnt * 2 * 4 +
335 ttisstdcnt * sizeof (char))
336 return -1;
337 p = buf + sizeof *tzhp;
338 for (i = 0; i < sp->timecnt; ++i)
339 {
340 sp->ats[i] = detzcode(p);
341 p += 4;
342 }
343 for (i = 0; i < sp->timecnt; ++i)
344 {
345 sp->types[i] = (unsigned char) *p++;
346 if (sp->types[i] >= sp->typecnt)
347 return -1;
348 }
349 for (i = 0; i < sp->typecnt; ++i)
350 {
351 struct ttinfo * ttisp;
352
353 ttisp = &sp->ttis[i];
354 ttisp->tt_gmtoff = detzcode(p);
355 p += 4;
356 ttisp->tt_isdst = (unsigned char) *p++;
357 if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
358 return -1;
359 ttisp->tt_abbrind = (unsigned char) *p++;
360 if (ttisp->tt_abbrind < 0 ||
361 ttisp->tt_abbrind > sp->charcnt)
362 return -1;
363 }
364 for (i = 0; i < sp->charcnt; ++i)
365 sp->chars[i] = *p++;
366 sp->chars[i] = '\0'; /* ensure '\0' at end */
367 for (i = 0; i < sp->leapcnt; ++i)
368 {
369 struct lsinfo * lsisp;
370
371 lsisp = &sp->lsis[i];
372 lsisp->ls_trans = detzcode(p);
373 p += 4;
374 lsisp->ls_corr = detzcode(p);
375 p += 4;
376 }
377 for (i = 0; i < sp->typecnt; ++i)
378 {
379 struct ttinfo * ttisp;
380
381 ttisp = &sp->ttis[i];
382 if (ttisstdcnt == 0)
383 ttisp->tt_ttisstd = FALSE;
384 else
385 {
386 ttisp->tt_ttisstd = *p++;
387 if (ttisp->tt_ttisstd != TRUE &&
388 ttisp->tt_ttisstd != FALSE)
389 return -1;
390 }
391 }
392 return 0;
393 }
394
395 static const int mon_lengths[2][MONSPERYEAR] = {
396 { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
397 { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
398 };
399
400 static const int year_lengths[2] = {
401 DAYSPERNYEAR, DAYSPERLYEAR
402 };
403
404 /*
405 ** Given a pointer into a time zone string, scan until a character that is not
406 ** a valid character in a zone name is found. Return a pointer to that
407 ** character.
408 */
409
410 static const char *
411 getzname(const char *strp)
412 {
413 char c;
414
415 while ((c = *strp) != '\0' && !isdigit(c) && c != ',' && c != '-' &&
416 c != '+')
417 ++strp;
418 return strp;
419 }
420
421 /*
422 ** Given a pointer into a time zone string, extract a number from that string.
423 ** Check that the number is within a specified range; if it is not, return
424 ** NULL.
425 ** Otherwise, return a pointer to the first character not part of the number.
426 */
427
428 static const char *
429 getnum(const char *strp, int * CPP_CONST nump, const int min, const int max)
430 {
431 char c;
432 int num;
433
434 if (strp == NULL || !isdigit(*strp))
435 return NULL;
436 num = 0;
437 while ((c = *strp) != '\0' && isdigit(c))
438 {
439 num = num * 10 + (c - '0');
440 if (num > max)
441 return NULL;
442 ++strp;
443 }
444 if (num < min)
445 return NULL;
446 *nump = num;
447 return strp;
448 }
449
450 /*
451 ** Given a pointer into a time zone string, extract a number of seconds,
452 ** in hh[:mm[:ss]] form, from the string.
453 ** If any error occurs, return NULL.
454 ** Otherwise, return a pointer to the first character not part of the number
455 ** of seconds.
456 */
457
458 static const char *
459 getsecs(const char *strp, long * CPP_CONST secsp)
460 {
461 int num;
462
463 strp = getnum(strp, &num, 0, HOURSPERDAY);
464 if (strp == NULL)
465 return NULL;
466 *secsp = num * SECSPERHOUR;
467 if (*strp == ':')
468 {
469 ++strp;
470 strp = getnum(strp, &num, 0, MINSPERHOUR - 1);
471 if (strp == NULL)
472 return NULL;
473 *secsp += num * SECSPERMIN;
474 if (*strp == ':')
475 {
476 ++strp;
477 strp = getnum(strp, &num, 0, SECSPERMIN - 1);
478 if (strp == NULL)
479 return NULL;
480 *secsp += num;
481 }
482 }
483 return strp;
484 }
485
486 /*
487 ** Given a pointer into a time zone string, extract an offset, in
488 ** [+-]hh[:mm[:ss]] form, from the string.
489 ** If any error occurs, return NULL.
490 ** Otherwise, return a pointer to the first character not part of the time.
491 */
492
493 static const char *
494 getoffset(const char *strp, long * CPP_CONST offsetp)
495 {
496 int neg;
497
498 if (*strp == '-')
499 {
500 neg = 1;
501 ++strp;
502 }
503 else if (isdigit(*strp) || *strp++ == '+')
504 neg = 0;
505 else
506 return NULL; /* illegal offset */
507 strp = getsecs(strp, offsetp);
508 if (strp == NULL)
509 return NULL; /* illegal time */
510 if (neg)
511 *offsetp = -*offsetp;
512 return strp;
513 }
514
515 /*
516 ** Given a pointer into a time zone string, extract a rule in the form
517 ** date[/time]. See POSIX section 8 for the format of "date" and "time".
518 ** If a valid rule is not found, return NULL.
519 ** Otherwise, return a pointer to the first character not part of the rule.
520 */
521
522 static const char *
523 getrule(const char *strp, struct rule * CPP_CONST rulep)
524 {
525 if (*strp == 'J')
526 {
527 /*
528 ** Julian day.
529 */
530 rulep->r_type = JULIAN_DAY;
531 ++strp;
532 strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);
533 }
534 else if (*strp == 'M')
535 {
536 /*
537 ** Month, week, day.
538 */
539 rulep->r_type = MONTH_NTH_DAY_OF_WEEK;
540 ++strp;
541 strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);
542 if (strp == NULL)
543 return NULL;
544 if (*strp++ != '.')
545 return NULL;
546 strp = getnum(strp, &rulep->r_week, 1, 5);
547 if (strp == NULL)
548 return NULL;
549 if (*strp++ != '.')
550 return NULL;
551 strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);
552 }
553 else if (isdigit(*strp))
554 {
555 /*
556 ** Day of year.
557 */
558 rulep->r_type = DAY_OF_YEAR;
559 strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);
560 }
561 else
562 return NULL; /* invalid format */
563 if (strp == NULL)
564 return NULL;
565 if (*strp == '/')
566 {
567 /*
568 ** Time specified.
569 */
570 ++strp;
571 strp = getsecs(strp, &rulep->r_time);
572 }
573 else
574 rulep->r_time = 2 * SECSPERHOUR; /* default = 2:00:00 */
575 return strp;
576 }
577
578 /*
579 ** Given the Epoch-relative time of January 1, 00:00:00 GMT, in a year, the
580 ** year, a rule, and the offset from GMT at the time that rule takes effect,
581 ** calculate the Epoch-relative time that rule takes effect.
582 */
583
584 static time_t
585 transtime(const time_t janfirst, const int year, const struct rule * CPP_CONST rulep, const long offset)
586 {
587 int leapyear;
588 time_t value=0;
589 int i;
590 int d, m1, yy0, yy1, yy2, dow;
591
592 leapyear = isleap(year);
593 switch (rulep->r_type)
594 {
595
596 case JULIAN_DAY:
597 /*
598 ** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
599 ** years.
600 ** In non-leap years, or if the day number is 59 or less, just
601 ** add SECSPERDAY times the day number-1 to the time of
602 ** January 1, midnight, to get the day.
603 */
604 value = janfirst + (rulep->r_day - 1) * SECSPERDAY;
605 if (leapyear && rulep->r_day >= 60)
606 value += SECSPERDAY;
607 break;
608
609 case DAY_OF_YEAR:
610 /*
611 ** n - day of year.
612 ** Just add SECSPERDAY times the day number to the time of
613 ** January 1, midnight, to get the day.
614 */
615 value = janfirst + rulep->r_day * SECSPERDAY;
616 break;
617
618 case MONTH_NTH_DAY_OF_WEEK:
619 /*
620 ** Mm.n.d - nth "dth day" of month m.
621 */
622 value = janfirst;
623 for (i = 0; i < rulep->r_mon - 1; ++i)
624 value += mon_lengths[leapyear][i] * SECSPERDAY;
625
626 /*
627 ** Use Zeller's Congruence to get day-of-week of first day of
628 ** month.
629 */
630 m1 = (rulep->r_mon + 9) % 12 + 1;
631 yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
632 yy1 = yy0 / 100;
633 yy2 = yy0 % 100;
634 dow = ((26 * m1 - 2) / 10 +
635 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
636 if (dow < 0)
637 dow += DAYSPERWEEK;
638
639 /*
640 ** "dow" is the day-of-week of the first day of the month. Get
641 ** the day-of-month (zero-origin) of the first "dow" day of the
642 ** month.
643 */
644 d = rulep->r_day - dow;
645 if (d < 0)
646 d += DAYSPERWEEK;
647 for (i = 1; i < rulep->r_week; ++i)
648 {
649 if (d + DAYSPERWEEK >=
650 mon_lengths[leapyear][rulep->r_mon - 1])
651 break;
652 d += DAYSPERWEEK;
653 }
654
655 /*
656 ** "d" is the day-of-month (zero-origin) of the day we want.
657 */
658 value += d * SECSPERDAY;
659 break;
660 }
661
662 /*
663 ** "value" is the Epoch-relative time of 00:00:00 GMT on the day in
664 ** question. To get the Epoch-relative time of the specified local
665 ** time on that day, add the transition time and the current offset
666 ** from GMT.
667 */
668 return value + rulep->r_time + offset;
669 }
670
671 /*
672 ** Given a POSIX section 8-style TZ string, fill in the rule tables as
673 ** appropriate.
674 */
675
676 static int
677 tzparse(const char *name, struct state * CPP_CONST sp, const int lastditch)
678 {
679 const char * stdname;
680 const char * dstname=0;
681 int stdlen;
682 int dstlen;
683 long stdoffset;
684 long dstoffset;
685 time_t * atp;
686 unsigned char * typep;
687 char * cp;
688 int load_result;
689
690 stdname = name;
691 if (lastditch)
692 {
693 stdlen = strlen(name); /* length of standard zone name */
694 name += stdlen;
695 if (stdlen >= sizeof sp->chars)
696 stdlen = (sizeof sp->chars) - 1;
697 }
698 else
699 {
700 name = getzname(name);
701 stdlen = name - stdname;
702 if (stdlen < 3)
703 return -1;
704 }
705 if (*name == '\0')
706 return -1;
707 else
708 {
709 name = getoffset(name, &stdoffset);
710 if (name == NULL)
711 return -1;
712 }
713 load_result = tzload(TZDEFRULES, sp);
714 if (load_result != 0)
715 sp->leapcnt = 0; /* so, we're off a little */
716 if (*name != '\0')
717 {
718 dstname = name;
719 name = getzname(name);
720 dstlen = name - dstname; /* length of DST zone name */
721 if (dstlen < 3)
722 return -1;
723 if (*name != '\0' && *name != ',' && *name != ';')
724 {
725 name = getoffset(name, &dstoffset);
726 if (name == NULL)
727 return -1;
728 }
729 else
730 dstoffset = stdoffset - SECSPERHOUR;
731 if (*name == ',' || *name == ';')
732 {
733 struct rule start;
734 struct rule end;
735 int year;
736 time_t janfirst;
737 time_t starttime;
738 time_t endtime;
739
740 ++name;
741 if ((name = getrule(name, &start)) == NULL)
742 return -1;
743 if (*name++ != ',')
744 return -1;
745 if ((name = getrule(name, &end)) == NULL)
746 return -1;
747 if (*name != '\0')
748 return -1;
749 sp->typecnt = 2; /* standard time and DST */
750 /*
751 ** Two transitions per year, from EPOCH_YEAR to 2037.
752 */
753 sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);
754 if (sp->timecnt > TZ_MAX_TIMES)
755 return -1;
756 sp->ttis[0].tt_gmtoff = -dstoffset;
757 sp->ttis[0].tt_isdst = 1;
758 sp->ttis[0].tt_abbrind = stdlen + 1;
759 sp->ttis[1].tt_gmtoff = -stdoffset;
760 sp->ttis[1].tt_isdst = 0;
761 sp->ttis[1].tt_abbrind = 0;
762 atp = sp->ats;
763 typep = sp->types;
764 janfirst = 0;
765 for (year = EPOCH_YEAR; year <= 2037; ++year)
766 {
767 starttime = transtime(janfirst, year, &start,
768 stdoffset);
769 endtime = transtime(janfirst, year, &end,
770 dstoffset);
771 if (starttime > endtime)
772 {
773 *atp++ = endtime;
774 *typep++ = 1; /* DST ends */
775 *atp++ = starttime;
776 *typep++ = 0; /* DST begins */
777 }
778 else
779 {
780 *atp++ = starttime;
781 *typep++ = 0; /* DST begins */
782 *atp++ = endtime;
783 *typep++ = 1; /* DST ends */
784 }
785 janfirst +=
786 year_lengths[isleap(year)] * SECSPERDAY;
787 }
788 }
789 else
790 {
791 int sawstd;
792 int sawdst;
793 long stdfix;
794 long dstfix;
795 long oldfix;
796 int isdst;
797 int i;
798
799 if (*name != '\0')
800 return -1;
801 if (load_result != 0)
802 return -1;
803 /*
804 ** Compute the difference between the real and
805 ** prototype standard and summer time offsets
806 ** from GMT, and put the real standard and summer
807 ** time offsets into the rules in place of the
808 ** prototype offsets.
809 */
810 sawstd = FALSE;
811 sawdst = FALSE;
812 stdfix = 0;
813 dstfix = 0;
814 for (i = 0; i < sp->typecnt; ++i)
815 {
816 if (sp->ttis[i].tt_isdst)
817 {
818 oldfix = dstfix;
819 dstfix =
820 sp->ttis[i].tt_gmtoff + dstoffset;
821 if (sawdst && (oldfix != dstfix))
822 return -1;
823 sp->ttis[i].tt_gmtoff = -dstoffset;
824 sp->ttis[i].tt_abbrind = stdlen + 1;
825 sawdst = TRUE;
826 }
827 else
828 {
829 oldfix = stdfix;
830 stdfix =
831 sp->ttis[i].tt_gmtoff + stdoffset;
832 if (sawstd && (oldfix != stdfix))
833 return -1;
834 sp->ttis[i].tt_gmtoff = -stdoffset;
835 sp->ttis[i].tt_abbrind = 0;
836 sawstd = TRUE;
837 }
838 }
839 /*
840 ** Make sure we have both standard and summer time.
841 */
842 if (!sawdst || !sawstd)
843 return -1;
844 /*
845 ** Now correct the transition times by shifting
846 ** them by the difference between the real and
847 ** prototype offsets. Note that this difference
848 ** can be different in standard and summer time;
849 ** the prototype probably has a 1-hour difference
850 ** between standard and summer time, but a different
851 ** difference can be specified in TZ.
852 */
853 isdst = FALSE; /* we start in standard time */
854 for (i = 0; i < sp->timecnt; ++i)
855 {
856 const struct ttinfo * ttisp;
857
858 /*
859 ** If summer time is in effect, and the
860 ** transition time was not specified as
861 ** standard time, add the summer time
862 ** offset to the transition time;
863 ** otherwise, add the standard time offset
864 ** to the transition time.
865 */
866 ttisp = &sp->ttis[sp->types[i]];
867 sp->ats[i] +=
868 (isdst && !ttisp->tt_ttisstd) ?
869 dstfix : stdfix;
870 isdst = ttisp->tt_isdst;
871 }
872 }
873 }
874 else
875 {
876 dstlen = 0;
877 sp->typecnt = 1; /* only standard time */
878 sp->timecnt = 0;
879 sp->ttis[0].tt_gmtoff = -stdoffset;
880 sp->ttis[0].tt_isdst = 0;
881 sp->ttis[0].tt_abbrind = 0;
882 }
883 sp->charcnt = stdlen + 1;
884 if (dstlen != 0)
885 sp->charcnt += dstlen + 1;
886 if (sp->charcnt > sizeof sp->chars)
887 return -1;
888 cp = sp->chars;
889 (void) strncpy(cp, stdname, stdlen);
890 cp += stdlen;
891 *cp++ = '\0';
892 if (dstlen != 0)
893 {
894 (void) strncpy(cp, dstname, dstlen);
895 *(cp + dstlen) = '\0';
896 }
897 return 0;
898 }
899
900 static void
901 gmtload(struct state * CPP_CONST sp)
902 {
903 if (tzload(GMT, sp) != 0)
904 (void) tzparse(GMT, sp, TRUE);
905 }
906
907 void
908 _tzset(void)
909 {
910 const char * name;
911
912 name = getenv("TZ");
913 if (name == NULL)
914 {
915 tzsetwall();
916 return;
917 }
918 lcl_is_set = TRUE;
919 #ifdef ALL_STATE
920 if (lclptr == NULL)
921 {
922 lclptr = (struct state *) malloc(sizeof *lclptr);
923 if (lclptr == NULL)
924 {
925 settzname(); /* all we can do */
926 return;
927 }
928 }
929 #endif /* defined ALL_STATE */
930 if (*name == '\0')
931 {
932 /*
933 ** User wants it fast rather than right.
934 */
935 lclptr->leapcnt = 0; /* so, we're off a little */
936 lclptr->timecnt = 0;
937 lclptr->ttis[0].tt_gmtoff = 0;
938 lclptr->ttis[0].tt_abbrind = 0;
939 (void) strcpy(lclptr->chars, GMT);
940 }
941 else if (tzload(name, lclptr) != 0)
942 if (name[0] == ':' || tzparse(name, lclptr, FALSE) != 0)
943 gmtload(lclptr);
944 settzname();
945 }
946
947 void
948 tzsetwall(void)
949 {
950 lcl_is_set = TRUE;
951 #ifdef ALL_STATE
952 if (lclptr == NULL)
953 {
954 lclptr = (struct state *) malloc(sizeof *lclptr);
955 if (lclptr == NULL)
956 {
957 settzname(); /* all we can do */
958 return;
959 }
960 }
961 #endif /* defined ALL_STATE */
962 if (tzload((char *) NULL, lclptr) != 0)
963 gmtload(lclptr);
964 settzname();
965 }
966
967 /*
968 ** The easy way to behave "as if no library function calls" localtime
969 ** is to not call it--so we drop its guts into "localsub", which can be
970 ** freely called. (And no, the PANS doesn't require the above behavior--
971 ** but it *is* desirable.)
972 **
973 ** The unused offset argument is for the benefit of mktime variants.
974 */
975
976 /*ARGSUSED*/
977 static void
978 localsub(const time_t * CPP_CONST timep, const long offset, struct tm * CPP_CONST tmp)
979 {
980 const struct state * sp;
981 const struct ttinfo * ttisp;
982 int i;
983 const time_t t = *timep;
984
985 if (!lcl_is_set)
986 _tzset();
987 sp = lclptr;
988 #ifdef ALL_STATE
989 if (sp == NULL)
990 {
991 gmtsub(timep, offset, tmp);
992 return;
993 }
994 #endif /* defined ALL_STATE */
995 if (sp->timecnt == 0 || t < sp->ats[0])
996 {
997 i = 0;
998 while (sp->ttis[i].tt_isdst)
999 if (++i >= sp->typecnt)
1000 {
1001 i = 0;
1002 break;
1003 }
1004 }
1005 else
1006 {
1007 for (i = 1; i < sp->timecnt; ++i)
1008 if (t < sp->ats[i])
1009 break;
1010 i = sp->types[i - 1];
1011 }
1012 ttisp = &sp->ttis[i];
1013 /*
1014 ** To get (wrong) behavior that's compatible with System V Release 2.0
1015 ** you'd replace the statement below with
1016 ** t += ttisp->tt_gmtoff;
1017 ** timesub(&t, 0L, sp, tmp);
1018 */
1019 timesub(&t, ttisp->tt_gmtoff, sp, tmp);
1020 tmp->tm_isdst = ttisp->tt_isdst;
1021 _tzname[tmp->tm_isdst] = (char *)&sp->chars[ttisp->tt_abbrind];
1022 tmp->tm_zone = (char *)&sp->chars[ttisp->tt_abbrind];
1023 }
1024
1025 struct tm *
1026 localtime(const time_t * CPP_CONST timep)
1027 {
1028 static struct tm tm;
1029
1030 localsub(timep, 0L, &tm);
1031 return &tm;
1032 }
1033
1034 /*
1035 ** gmtsub is to gmtime as localsub is to localtime.
1036 */
1037
1038 static void
1039 gmtsub(const time_t * CPP_CONST timep, const long offset, struct tm * CPP_CONST tmp)
1040 {
1041 if (!gmt_is_set)
1042 {
1043 gmt_is_set = TRUE;
1044 #ifdef ALL_STATE
1045 gmtptr = (struct state *) malloc(sizeof *gmtptr);
1046 if (gmtptr != NULL)
1047 #endif /* defined ALL_STATE */
1048 gmtload(gmtptr);
1049 }
1050 timesub(timep, offset, gmtptr, tmp);
1051 /*
1052 ** Could get fancy here and deliver something such as
1053 ** "GMT+xxxx" or "GMT-xxxx" if offset is non-zero,
1054 ** but this is no time for a treasure hunt.
1055 */
1056 if (offset != 0)
1057 tmp->tm_zone = WILDABBR;
1058 else
1059 {
1060 #ifdef ALL_STATE
1061 if (gmtptr == NULL)
1062 tmp->TM_ZONE = GMT;
1063 else
1064 tmp->TM_ZONE = gmtptr->chars;
1065 #endif /* defined ALL_STATE */
1066 #ifndef ALL_STATE
1067 tmp->tm_zone = gmtptr->chars;
1068 #endif /* State Farm */
1069 }
1070 }
1071
1072 struct tm *
1073 gmtime(const time_t * CPP_CONST timep)
1074 {
1075 static struct tm tm;
1076
1077 gmtsub(timep, 0L, &tm);
1078 return &tm;
1079 }
1080
1081 static void
1082 timesub(const time_t * CPP_CONST timep, const long offset, const struct state * CPP_CONST sp, struct tm * CPP_CONST tmp)
1083 {
1084 const struct lsinfo * lp;
1085 long days;
1086 long rem;
1087 int y;
1088 int yleap;
1089 const int * ip;
1090 long corr;
1091 int hit;
1092 int i;
1093
1094 corr = 0;
1095 hit = FALSE;
1096 #ifdef ALL_STATE
1097 i = (sp == NULL) ? 0 : sp->leapcnt;
1098 #endif /* defined ALL_STATE */
1099 #ifndef ALL_STATE
1100 i = sp->leapcnt;
1101 #endif /* State Farm */
1102 while (--i >= 0)
1103 {
1104 lp = &sp->lsis[i];
1105 if (*timep >= lp->ls_trans)
1106 {
1107 if (*timep == lp->ls_trans)
1108 hit = ((i == 0 && lp->ls_corr > 0) ||
1109 lp->ls_corr > sp->lsis[i - 1].ls_corr);
1110 corr = lp->ls_corr;
1111 break;
1112 }
1113 }
1114 days = *timep / SECSPERDAY;
1115 rem = *timep % SECSPERDAY;
1116 #ifdef mc68k
1117 if (*timep == 0x80000000)
1118 {
1119 /*
1120 ** A 3B1 muffs the division on the most negative number.
1121 */
1122 days = -24855;
1123 rem = -11648;
1124 }
1125 #endif /* mc68k */
1126 rem += (offset - corr);
1127 while (rem < 0)
1128 {
1129 rem += SECSPERDAY;
1130 --days;
1131 }
1132 while (rem >= SECSPERDAY)
1133 {
1134 rem -= SECSPERDAY;
1135 ++days;
1136 }
1137 tmp->tm_hour = (int) (rem / SECSPERHOUR);
1138 rem = rem % SECSPERHOUR;
1139 tmp->tm_min = (int) (rem / SECSPERMIN);
1140 tmp->tm_sec = (int) (rem % SECSPERMIN);
1141 if (hit)
1142 /*
1143 ** A positive leap second requires a special
1144 ** representation. This uses "... ??:59:60".
1145 */
1146 ++(tmp->tm_sec);
1147 tmp->tm_wday = (int) ((EPOCH_WDAY + days) % DAYSPERWEEK);
1148 if (tmp->tm_wday < 0)
1149 tmp->tm_wday += DAYSPERWEEK;
1150 y = EPOCH_YEAR;
1151 if (days >= 0)
1152 for ( ; ; )
1153 {
1154 yleap = isleap(y);
1155 if (days < (long) year_lengths[yleap])
1156 break;
1157 ++y;
1158 days = days - (long) year_lengths[yleap];
1159 }
1160 else
1161 do {
1162 --y;
1163 yleap = isleap(y);
1164 days = days + (long) year_lengths[yleap];
1165 } while (days < 0);
1166 tmp->tm_year = y - TM_YEAR_BASE;
1167 tmp->tm_yday = (int) days;
1168 ip = mon_lengths[yleap];
1169 for (tmp->tm_mon = 0; days >= (long) ip[tmp->tm_mon]; ++(tmp->tm_mon))
1170 days = days - (long) ip[tmp->tm_mon];
1171 tmp->tm_mday = (int) (days + 1);
1172 tmp->tm_isdst = 0;
1173 tmp->tm_gmtoff = offset;
1174 }
1175
1176 /*
1177 ** A la X3J11
1178 */
1179
1180 char *
1181 asctime(const struct tm *timeptr)
1182 {
1183 static const char wday_name[DAYSPERWEEK][3] = {
1184 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
1185 };
1186 static const char mon_name[MONSPERYEAR][3] = {
1187 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
1188 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
1189 };
1190 static char result[26];
1191
1192 (void) sprintf(result, "%.3s %.3s%3d %02d:%02d:%02d %d\n",
1193 wday_name[timeptr->tm_wday],
1194 mon_name[timeptr->tm_mon],
1195 timeptr->tm_mday, timeptr->tm_hour,
1196 timeptr->tm_min, timeptr->tm_sec,
1197 TM_YEAR_BASE + timeptr->tm_year);
1198 return result;
1199 }
1200
1201 char *
1202 ctime(const time_t * CPP_CONST timep)
1203 {
1204 return asctime(localtime(timep));
1205 }
1206
1207 /*
1208 ** Adapted from code provided by Robert Elz, who writes:
1209 ** The "best" way to do mktime I think is based on an idea of Bob
1210 ** Kridle's (so its said...) from a long time ago. (mtxinu!kridle now).
1211 ** It does a binary search of the time_t space. Since time_t's are
1212 ** just 32 bits, its a max of 32 iterations (even at 64 bits it
1213 ** would still be very reasonable).
1214 */
1215
1216 #ifndef WRONG
1217 #define WRONG (-1)
1218 #endif /* !defined WRONG */
1219
1220 static void
1221 normalize(int * CPP_CONST tensptr, int * CPP_CONST unitsptr, const int base)
1222 {
1223 if (*unitsptr >= base)
1224 {
1225 *tensptr += *unitsptr / base;
1226 *unitsptr %= base;
1227 }
1228 else if (*unitsptr < 0)
1229 {
1230 --*tensptr;
1231 *unitsptr += base;
1232 if (*unitsptr < 0)
1233 {
1234 *tensptr -= 1 + (-*unitsptr) / base;
1235 *unitsptr = base - (-*unitsptr) % base;
1236 }
1237 }
1238 }
1239
1240 static int
1241 tmcomp(const struct tm * CPP_CONST atmp, const struct tm * CPP_CONST btmp)
1242 {
1243 int result;
1244
1245 if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
1246 (result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
1247 (result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
1248 (result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
1249 (result = (atmp->tm_min - btmp->tm_min)) == 0)
1250 result = atmp->tm_sec - btmp->tm_sec;
1251 return result;
1252 }
1253
1254 static time_t
1255 time2(struct tm *tmp, void (*const funcp)(const time_t * CPP_CONST, const long, struct tm *), const long offset, int * CPP_CONST okayp)
1256 {
1257 const struct state * sp;
1258 int dir;
1259 int bits;
1260 int i, j ;
1261 int saved_seconds;
1262 time_t newt;
1263 time_t t;
1264 struct tm yourtm, mytm;
1265
1266 *okayp = FALSE;
1267 yourtm = *tmp;
1268 if (yourtm.tm_sec >= SECSPERMIN + 2 || yourtm.tm_sec < 0)
1269 normalize(&yourtm.tm_min, &yourtm.tm_sec, SECSPERMIN);
1270 normalize(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR);
1271 normalize(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY);
1272 normalize(&yourtm.tm_year, &yourtm.tm_mon, MONSPERYEAR);
1273 while (yourtm.tm_mday <= 0)
1274 {
1275 --yourtm.tm_year;
1276 yourtm.tm_mday +=
1277 year_lengths[isleap(yourtm.tm_year + TM_YEAR_BASE)];
1278 }
1279 for ( ; ; )
1280 {
1281 i = mon_lengths[isleap(yourtm.tm_year +
1282 TM_YEAR_BASE)][yourtm.tm_mon];
1283 if (yourtm.tm_mday <= i)
1284 break;
1285 yourtm.tm_mday -= i;
1286 if (++yourtm.tm_mon >= MONSPERYEAR)
1287 {
1288 yourtm.tm_mon = 0;
1289 ++yourtm.tm_year;
1290 }
1291 }
1292 saved_seconds = yourtm.tm_sec;
1293 yourtm.tm_sec = 0;
1294 /*
1295 ** Calculate the number of magnitude bits in a time_t
1296 ** (this works regardless of whether time_t is
1297 ** signed or unsigned, though lint complains if unsigned).
1298 */
1299 for (bits = 0, t = 1; t > 0; ++bits, t <<= 1)
1300 ;
1301 /*
1302 ** If time_t is signed, then 0 is the median value,
1303 ** if time_t is unsigned, then 1 << bits is median.
1304 */
1305 #ifdef _MSVCRT_LIB_
1306 t = (time_t) ((1 << bits) - 1);
1307 #else // TODO: FIXME: review which is correct
1308 t = (time_t) 1 << bits;
1309 #endif /*_MSVCRT_LIB_*/
1310
1311 for ( ; ; )
1312 {
1313 (*funcp)(&t, offset, &mytm);
1314 dir = tmcomp(&mytm, &yourtm);
1315 if (dir != 0)
1316 {
1317 if (bits-- < 0)
1318 return WRONG;
1319 if (bits < 0)
1320 --t;
1321 else if (dir > 0)
1322 t -= (time_t) 1 << bits;
1323 else t += (time_t) 1 << bits;
1324 continue;
1325 }
1326 if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
1327 break;
1328 /*
1329 ** Right time, wrong type.
1330 ** Hunt for right time, right type.
1331 ** It's okay to guess wrong since the guess
1332 ** gets checked.
1333 */
1334 sp = (const struct state *)
1335 ((funcp == localsub) ? lclptr : gmtptr);
1336 #ifdef ALL_STATE
1337 if (sp == NULL)
1338 return WRONG;
1339 #endif /* defined ALL_STATE */
1340 for (i = 0; i < sp->typecnt; ++i)
1341 {
1342 if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
1343 continue;
1344 for (j = 0; j < sp->typecnt; ++j)
1345 {
1346 if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
1347 continue;
1348 newt = t + sp->ttis[j].tt_gmtoff -
1349 sp->ttis[i].tt_gmtoff;
1350 (*funcp)(&newt, offset, &mytm);
1351 if (tmcomp(&mytm, &yourtm) != 0)
1352 continue;
1353 if (mytm.tm_isdst != yourtm.tm_isdst)
1354 continue;
1355 /*
1356 ** We have a match.
1357 */
1358 t = newt;
1359 goto label;
1360 }
1361 }
1362 return WRONG;
1363 }
1364 label:
1365 t += saved_seconds;
1366 (*funcp)(&t, offset, tmp);
1367 *okayp = TRUE;
1368 return t;
1369 }
1370
1371 static time_t
1372 time1(struct tm * CPP_CONST tmp, void (*const funcp)(const time_t * CPP_CONST, const long, struct tm *), const long offset)
1373 {
1374 time_t t;
1375 const struct state * sp;
1376 int samei, otheri;
1377 int okay;
1378
1379 if (tmp->tm_isdst > 1)
1380 tmp->tm_isdst = 1;
1381 t = time2(tmp, funcp, offset, &okay);
1382 if (okay || tmp->tm_isdst < 0)
1383 return t;
1384 /*
1385 ** We're supposed to assume that somebody took a time of one type
1386 ** and did some math on it that yielded a "struct tm" that's bad.
1387 ** We try to divine the type they started from and adjust to the
1388 ** type they need.
1389 */
1390 sp = (const struct state *) ((funcp == localsub) ? lclptr : gmtptr);
1391 #ifdef ALL_STATE
1392 if (sp == NULL)
1393 return WRONG;
1394 #endif /* defined ALL_STATE */
1395 for (samei = 0; samei < sp->typecnt; ++samei)
1396 {
1397 if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
1398 continue;
1399 for (otheri = 0; otheri < sp->typecnt; ++otheri)
1400 {
1401 if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
1402 continue;
1403 tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
1404 sp->ttis[samei].tt_gmtoff;
1405 tmp->tm_isdst = !tmp->tm_isdst;
1406 t = time2(tmp, funcp, offset, &okay);
1407 if (okay)
1408 return t;
1409 tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff -
1410 sp->ttis[samei].tt_gmtoff;
1411 tmp->tm_isdst = !tmp->tm_isdst;
1412 }
1413 }
1414 return WRONG;
1415 }
1416
1417 time_t
1418 mktime(struct tm * tmp)
1419 {
1420 return time1(tmp, localsub, 0L);
1421 }