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