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