/usr/src/lib/libc/time/localtime.c

Bug Summary

File:	src/lib/libc/time/localtime.c
Warning:	line 227, column 20 The result of the left shift is undefined because the left operand is negative
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name localtime.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/lib/libc/obj -resource-dir /usr/local/llvm16/lib/clang/16 -include namespace.h -I /usr/src/lib/libc/include -I /usr/src/lib/libc/hidden -D __LIBC__ -D APIWARN -D YP -I /usr/src/lib/libc/yp -I /usr/src/lib/libc -I /usr/src/lib/libc/gdtoa -I /usr/src/lib/libc/arch/amd64/gdtoa -D INFNAN_CHECK -D MULTIPLE_THREADS -D NO_FENV_H -D USE_LOCALE -I /usr/src/lib/libc -I /usr/src/lib/libc/citrus -D RESOLVSORT -D FLOATING_POINT -D PRINTF_WIDE_CHAR -D SCANF_WIDE_CHAR -D FUTEX -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/lib/libc/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/lib/libc/time/localtime.c
1/*	$OpenBSD: localtime.c,v 1.65 2022/10/03 15:34:39 millert Exp $ */
2/*
3** This file is in the public domain, so clarified as of
4** 1996-06-05 by Arthur David Olson.
5*/

7/*
8** Leap second handling from Bradley White.
9** POSIX-style TZ environment variable handling from Guy Harris.
10*/

12#include <ctype.h>
13#include <errno(*__errno()).h>
14#include <fcntl.h>
15#include <stdint.h>
16#include <stdlib.h>
17#include <string.h>
18#include <unistd.h>

20#include "private.h"
21#include "tzfile.h"
22#include "thread_private.h"

24#ifndef TZ_ABBR_MAX_LEN16
25#define TZ_ABBR_MAX_LEN16	16
26#endif /* !defined TZ_ABBR_MAX_LEN */

28#ifndef TZ_ABBR_CHAR_SET"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"
29#define TZ_ABBR_CHAR_SET"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._" \
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"
31#endif /* !defined TZ_ABBR_CHAR_SET */

33#ifndef TZ_ABBR_ERR_CHAR'_'
34#define TZ_ABBR_ERR_CHAR'_'	'_'
35#endif /* !defined TZ_ABBR_ERR_CHAR */

37#ifndef WILDABBR"   "
38/*
39** Someone might make incorrect use of a time zone abbreviation:
40**	1.	They might reference tzname[0] before calling tzset (explicitly
41**		or implicitly).
42**	2.	They might reference tzname[1] before calling tzset (explicitly
43**		or implicitly).
44**	3.	They might reference tzname[1] after setting to a time zone
45**		in which Daylight Saving Time is never observed.
46**	4.	They might reference tzname[0] after setting to a time zone
47**		in which Standard Time is never observed.
48**	5.	They might reference tm.tm_zone after calling offtime.
49** What's best to do in the above cases is open to debate;
50** for now, we just set things up so that in any of the five cases
51** WILDABBR is used. Another possibility: initialize tzname[0] to the
52** string "tzname[0] used before set", and similarly for the other cases.
53** And another: initialize tzname[0] to "ERA", with an explanation in the
54** manual page of what this "time zone abbreviation" means (doing this so
55** that tzname[0] has the "normal" length of three characters).
56*/
57#define WILDABBR"   "	"   "
58#endif /* !defined WILDABBR */

60static char		wildabbr[] = WILDABBR"   ";

62static const char	gmt[] = "GMT";

64/*
65** The DST rules to use if TZ has no rules and we can't load TZDEFRULES.
66** We default to US rules as of 1999-08-17.
67** POSIX 1003.1 section 8.1.1 says that the default DST rules are
68** implementation dependent; for historical reasons, US rules are a
69** common default.
70*/
71#ifndef TZDEFRULESTRING",M4.1.0,M10.5.0"
72#define TZDEFRULESTRING",M4.1.0,M10.5.0" ",M4.1.0,M10.5.0"
73#endif /* !defined TZDEFDST */

75struct ttinfo {				/* time type information */
long		tt_gmtoff;	/* UTC offset in seconds */
int		tt_isdst;	/* used to set tm_isdst */
int		tt_abbrind;	/* abbreviation list index */
int		tt_ttisstd;	/* TRUE if transition is std time */
int		tt_ttisgmt;	/* TRUE if transition is UTC */
81};

83struct lsinfo {				/* leap second information */
time_t		ls_trans;	/* transition time */
long		ls_corr;	/* correction to apply */
86};

88#define BIGGEST(a, b)(((a) > (b)) ? (a) : (b))	(((a) > (b)) ? (a) : (b))

90#ifdef TZNAME_MAX
91#define MY_TZNAME_MAX255	TZNAME_MAX
92#endif /* defined TZNAME_MAX */
93#ifndef TZNAME_MAX
94#define MY_TZNAME_MAX255	255
95#endif /* !defined TZNAME_MAX */

97struct state {
int		leapcnt;
int		timecnt;
int		typecnt;
int		charcnt;
int		goback;
int		goahead;
time_t		ats[TZ_MAX_TIMES1200];
unsigned char	types[TZ_MAX_TIMES1200];
struct ttinfo	ttis[TZ_MAX_TYPES256];
char		chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt),((((((50 + 1) > (sizeof gmt)) ? (50 + 1) : (sizeof gmt))) >
 ((2 * (255 + 1)))) ? ((((50 + 1) > (sizeof gmt)) ? (50 + 1
) : (sizeof gmt))) : ((2 * (255 + 1))))
	    (2 * (MY_TZNAME_MAX + 1)))((((((50 + 1) > (sizeof gmt)) ? (50 + 1) : (sizeof gmt))) >
 ((2 * (255 + 1)))) ? ((((50 + 1) > (sizeof gmt)) ? (50 + 1
) : (sizeof gmt))) : ((2 * (255 + 1))))];
struct lsinfo	lsis[TZ_MAX_LEAPS50];
110};

112struct rule {
int		r_type;		/* type of rule--see below */
int		r_day;		/* day number of rule */
int		r_week;		/* week number of rule */
int		r_mon;		/* month number of rule */
long		r_time;		/* transition time of rule */
118};

120#define JULIAN_DAY0		0	/* Jn - Julian day */
121#define DAY_OF_YEAR1		1	/* n - day of year */
122#define MONTH_NTH_DAY_OF_WEEK2	2	/* Mm.n.d - month, week, day of week */

124/*
125** Prototypes for static functions.
126*/

128static long		detzcode(const char * codep);
129static time_t		detzcode64(const char * codep);
130static int		differ_by_repeat(time_t t1, time_t t0);
131static const char *	getzname(const char * strp);
132static const char *	getqzname(const char * strp, const int delim);
133static const char *	getnum(const char * strp, int * nump, int min,
		int max);
135static const char *	getsecs(const char * strp, long * secsp);
136static const char *	getoffset(const char * strp, long * offsetp);
137static const char *	getrule(const char * strp, struct rule * rulep);
138static void		gmtload(struct state * sp);
139static struct tm *	gmtsub(const time_t * timep, long offset,
		struct tm * tmp);
141static struct tm *	localsub(const time_t * timep, long offset,
		struct tm * tmp);
143static int		increment_overflow(int * number, int delta);
144static int		leaps_thru_end_of(int y);
145static int		long_increment_overflow(long * number, int delta);
146static int		long_normalize_overflow(long * tensptr,
		int * unitsptr, int base);
148static int		normalize_overflow(int * tensptr, int * unitsptr,
		int base);
150static void		settzname(void);
151static time_t		time1(struct tm * tmp,
		struct tm * (*funcp)(const time_t *,
		long, struct tm *),
		long offset);
155static time_t		time2(struct tm *tmp,
		struct tm * (*funcp)(const time_t *,
		long, struct tm*),
		long offset, int * okayp);
159static time_t		time2sub(struct tm *tmp,
		struct tm * (*funcp)(const time_t *,
		long, struct tm*),
		long offset, int * okayp, int do_norm_secs);
163static struct tm *	timesub(const time_t * timep, long offset,
		const struct state * sp, struct tm * tmp);
165static int		tmcomp(const struct tm * atmp,
		const struct tm * btmp);
167static time_t		transtime(time_t janfirst, int year,
		const struct rule * rulep, long offset);
169static int		typesequiv(const struct state * sp, int a, int b);
170static int		tzload(const char * name, struct state * sp,
		int doextend);
172static int		tzparse(const char * name, struct state * sp,
		int lastditch);

175#ifdef STD_INSPIRED1
176struct tm	*offtime(const time_t *, long);
177time_t		time2posix(time_t);
178time_t		posix2time(time_t);
179PROTO_DEPRECATED(offtime)typeof(offtime) offtime __attribute__((deprecated, weak));
180PROTO_DEPRECATED(time2posix)typeof(time2posix) time2posix __attribute__((deprecated, weak
));
181PROTO_DEPRECATED(posix2time)typeof(posix2time) posix2time __attribute__((deprecated, weak
));
182#endif

184static struct state *	lclptr;
185static struct state *	gmtptr;


188#ifndef TZ_STRLEN_MAX255
189#define TZ_STRLEN_MAX255 255
190#endif /* !defined TZ_STRLEN_MAX */

192static char		lcl_TZname[TZ_STRLEN_MAX255 + 1];
193static int		lcl_is_set;
194static int		gmt_is_set;
195_THREAD_PRIVATE_MUTEX(lcl)static void *_thread_tagname_lcl;
196_THREAD_PRIVATE_MUTEX(gmt)static void *_thread_tagname_gmt;

198char *			tzname[2] = {
wildabbr,
wildabbr
201};
202#if 0
203DEF_WEAK(tzname)__asm__(".weak " "tzname" " ; " "tzname" " = " "_libc_tzname"
);
204#endif

206/*
207** Section 4.12.3 of X3.159-1989 requires that
208**	Except for the strftime function, these functions [asctime,
209**	ctime, gmtime, localtime] return values in one of two static
210**	objects: a broken-down time structure and an array of char.
211** Thanks to Paul Eggert for noting this.
212*/

214static struct tm	tm;

216long			timezone = 0;
217int			daylight = 0;

219static long
220detzcode(const char *codep)
221{
long	result;
int	i;

result = (codep[0] & 0x80) ? ~0L : 0;
10
←
Assuming the condition is true→
11
←
'?' condition is true→
12
←
The value -1 is assigned to 'result'→
for (i = 0; i < 4; ++i)
13
←
Loop condition is true.  Entering loop body→
result = (result << 8) | (codep[i] & 0xff);
14
←
The result of the left shift is undefined because the left operand is negative
return result;
229}

231static time_t
232detzcode64(const char *codep)
233{
time_t	result;
int	i;

result = (codep[0] & 0x80) ?  (~(int_fast64_t) 0) : 0;
for (i = 0; i < 8; ++i)
result = result * 256 + (codep[i] & 0xff);
return result;
241}

243static void
244settzname(void)
245{
struct state * const	sp = lclptr;
int			i;

tzname[0] = wildabbr;
tzname[1] = wildabbr;
daylight = 0;
timezone = 0;
if (sp == NULL((void *)0)) {
tzname[0] = tzname[1] = (char *)gmt;
return;
}
/*
** And to get the latest zone names into tzname. . .
*/
for (i = 0; i < sp->timecnt; ++i) {
const struct ttinfo *ttisp = &sp->ttis[sp->types[i]];

tzname[ttisp->tt_isdst] = &sp->chars[ttisp->tt_abbrind];
if (ttisp->tt_isdst)
	daylight = 1;
if (!ttisp->tt_isdst)
	timezone = -(ttisp->tt_gmtoff);
}
/*
** Finally, scrub the abbreviations.
** First, replace bogus characters.
*/
for (i = 0; i < sp->charcnt; ++i) {
if (strchr(TZ_ABBR_CHAR_SET"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._", sp->chars[i]) == NULL((void *)0))
	sp->chars[i] = TZ_ABBR_ERR_CHAR'_';
}
/*
** Second, truncate long abbreviations.
*/
for (i = 0; i < sp->typecnt; ++i) {
const struct ttinfo *ttisp = &sp->ttis[i];
char *cp = &sp->chars[ttisp->tt_abbrind];

if (strlen(cp) > TZ_ABBR_MAX_LEN16 &&
    strcmp(cp, GRANDPARENTED"Local time zone must be set--see zic manual page") != 0)
	*(cp + TZ_ABBR_MAX_LEN16) = '\0';
}
288}

290static int
291differ_by_repeat(time_t t1, time_t t0)
292{
if (TYPE_BIT(time_t)(sizeof (time_t) * 8) - 1 < SECSPERREPEAT_BITS34)
return 0;
return (int64_t)t1 - t0 == SECSPERREPEAT((int_fast64_t) 400 * (int_fast64_t) 31556952L);
296}

298static int
299tzpath_ok(const char *name)
300{
/* Reject absolute paths that don't start with TZDIR.  */
if (name[0] == '/' && (strncmp(name, TZDIR"/usr/share/zoneinfo", sizeof(TZDIR"/usr/share/zoneinfo") - 1) != 0 ||
   name[sizeof(TZDIR"/usr/share/zoneinfo") - 1] != '/'))
return 0;

/* Reject paths that contain "../". */
if (strstr(name, "../") != NULL((void *)0))
return 0;

return 1;
311}

313static int
314open_tzfile(const char *name)
315{
char fullname[PATH_MAX1024];
int i;

if (name != NULL((void *)0)) {
/*
 * POSIX section 8 says that names starting with a ':' are
 * "implementation-defined".  We treat them as timezone paths.
 */
if (name[0] == ':')
	name++;

/*
 * Ignore absolute paths that don't start with TZDIR
 * or that contain "../".
 */
if (!tzpath_ok(name))
	name = NULL((void *)0);
}

if (name == NULL((void *)0)) {
name = TZDEFAULT"/etc/localtime";
} else if (name[0] != '/') {
/* Time zone data path is relative to TZDIR. */
i = snprintf(fullname, sizeof(fullname), "%s/%s", TZDIR"/usr/share/zoneinfo", name);
if (i < 0 || i >= sizeof(fullname)) {
	errno(*__errno()) = ENAMETOOLONG63;
	return -1;
}
name = fullname;
}

return open(name, O_RDONLY0x0000);
348}

350static int
351tzload(const char *name, struct state *sp, int doextend)
352{
const char *		p;
int			i;
int			fid;
int			stored;
int			nread;
typedef union {
struct tzhead	tzhead;
char		buf[2 * sizeof(struct tzhead) +
		    2 * sizeof *sp +
		    4 * TZ_MAX_TIMES1200];
} u_t;
u_t *			up;

up = calloc(1, sizeof *up);
if (up == NULL((void *)0))
1
Assuming 'up' is not equal to NULL→
2
←
Taking false branch→
return -1;

sp->goback = sp->goahead = FALSE0;

if ((fid = open_tzfile(name)) == -1) {
3
←
Assuming the condition is false→
4
←
Taking false branch→
/* Could be a POSIX section 8-style TZ string. */
goto oops;
}

nread = read(fid, up->buf, sizeof up->buf);
if (close(fid) == -1 || nread <= 0)
5
←
Assuming the condition is false→
6
←
Assuming 'nread' is > 0→
7
←
Taking false branch→
goto oops;
for (stored = 4; stored <= 8; stored *= 2) {
8
←
Loop condition is true.  Entering loop body→
int		ttisstdcnt;
int		ttisgmtcnt;

ttisstdcnt = (int) detzcode(up->tzhead.tzh_ttisstdcnt);
9
←
Calling 'detzcode'→
ttisgmtcnt = (int) detzcode(up->tzhead.tzh_ttisgmtcnt);
sp->leapcnt = (int) detzcode(up->tzhead.tzh_leapcnt);
sp->timecnt = (int) detzcode(up->tzhead.tzh_timecnt);
sp->typecnt = (int) detzcode(up->tzhead.tzh_typecnt);
sp->charcnt = (int) detzcode(up->tzhead.tzh_charcnt);
p = up->tzhead.tzh_charcnt + sizeof up->tzhead.tzh_charcnt;
if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS50 ||
    sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES256 ||
    sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES1200 ||
    sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS50 ||
    (ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||
    (ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))
	goto oops;
if (nread - (p - up->buf) <
    sp->timecnt * stored +		/* ats */
    sp->timecnt +			/* types */
    sp->typecnt * 6 +		/* ttinfos */
    sp->charcnt +			/* chars */
    sp->leapcnt * (stored + 4) +	/* lsinfos */
    ttisstdcnt +			/* ttisstds */
    ttisgmtcnt)			/* ttisgmts */
	goto oops;
for (i = 0; i < sp->timecnt; ++i) {
	sp->ats[i] = (stored == 4) ?
	    detzcode(p) : detzcode64(p);
	p += stored;
}
for (i = 0; i < sp->timecnt; ++i) {
	sp->types[i] = (unsigned char) *p++;
	if (sp->types[i] >= sp->typecnt)
		goto oops;
}
for (i = 0; i < sp->typecnt; ++i) {
	struct ttinfo *	ttisp;

	ttisp = &sp->ttis[i];
	ttisp->tt_gmtoff = detzcode(p);
	p += 4;
	ttisp->tt_isdst = (unsigned char) *p++;
	if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)
		goto oops;
	ttisp->tt_abbrind = (unsigned char) *p++;
	if (ttisp->tt_abbrind < 0 ||
	    ttisp->tt_abbrind > sp->charcnt)
		goto oops;
}
for (i = 0; i < sp->charcnt; ++i)
	sp->chars[i] = *p++;
sp->chars[i] = '\0';	/* ensure '\0' at end */
for (i = 0; i < sp->leapcnt; ++i) {
	struct lsinfo *	lsisp;

	lsisp = &sp->lsis[i];
	lsisp->ls_trans = (stored == 4) ?
	    detzcode(p) : detzcode64(p);
	p += stored;
	lsisp->ls_corr = detzcode(p);
	p += 4;
}
for (i = 0; i < sp->typecnt; ++i) {
	struct ttinfo *	ttisp;

	ttisp = &sp->ttis[i];
	if (ttisstdcnt == 0)
		ttisp->tt_ttisstd = FALSE0;
	else {
		ttisp->tt_ttisstd = *p++;
		if (ttisp->tt_ttisstd != TRUE1 &&
		    ttisp->tt_ttisstd != FALSE0)
			goto oops;
	}
}
for (i = 0; i < sp->typecnt; ++i) {
	struct ttinfo *	ttisp;

	ttisp = &sp->ttis[i];
	if (ttisgmtcnt == 0)
		ttisp->tt_ttisgmt = FALSE0;
	else {
		ttisp->tt_ttisgmt = *p++;
		if (ttisp->tt_ttisgmt != TRUE1 &&
		    ttisp->tt_ttisgmt != FALSE0)
			goto oops;
	}
}
/*
** Out-of-sort ats should mean we're running on a
** signed time_t system but using a data file with
** unsigned values (or vice versa).
*/
for (i = 0; i < sp->timecnt - 2; ++i)
	if (sp->ats[i] > sp->ats[i + 1]) {
		++i;
		/*
		** Ignore the end (easy).
		*/
		sp->timecnt = i;
		break;
	}
/*
** If this is an old file, we're done.
*/
if (up->tzhead.tzh_version[0] == '\0')
	break;
nread -= p - up->buf;
for (i = 0; i < nread; ++i)
	up->buf[i] = p[i];
/*
** If this is a narrow integer time_t system, we're done.
*/
if (stored >= sizeof(time_t))
	break;
}
if (doextend && nread > 2 &&
   up->buf[0] == '\n' && up->buf[nread - 1] == '\n' &&
   sp->typecnt + 2 <= TZ_MAX_TYPES256) {
struct state	ts;
int	result;

up->buf[nread - 1] = '\0';
result = tzparse(&up->buf[1], &ts, FALSE0);
if (result == 0 && ts.typecnt == 2 &&
    sp->charcnt + ts.charcnt <= TZ_MAX_CHARS50) {
	for (i = 0; i < 2; ++i)
		ts.ttis[i].tt_abbrind +=
		    sp->charcnt;
	for (i = 0; i < ts.charcnt; ++i)
		sp->chars[sp->charcnt++] =
		    ts.chars[i];
	i = 0;
	while (i < ts.timecnt &&
	    ts.ats[i] <=
	    sp->ats[sp->timecnt - 1])
		++i;
	while (i < ts.timecnt &&
	    sp->timecnt < TZ_MAX_TIMES1200) {
		sp->ats[sp->timecnt] =
		    ts.ats[i];
		sp->types[sp->timecnt] =
		    sp->typecnt +
		    ts.types[i];
		++sp->timecnt;
		++i;
	}
	sp->ttis[sp->typecnt++] = ts.ttis[0];
	sp->ttis[sp->typecnt++] = ts.ttis[1];
}
}
if (sp->timecnt > 1) {
for (i = 1; i < sp->timecnt; ++i) {
	if (typesequiv(sp, sp->types[i], sp->types[0]) &&
	    differ_by_repeat(sp->ats[i], sp->ats[0])) {
		sp->goback = TRUE1;
		break;
	}
}
for (i = sp->timecnt - 2; i >= 0; --i) {
	if (typesequiv(sp, sp->types[sp->timecnt - 1],
	    sp->types[i]) &&
	    differ_by_repeat(sp->ats[sp->timecnt - 1],
	    sp->ats[i])) {
		sp->goahead = TRUE1;
		break;
	}
}
}
free(up);
return 0;
553oops:
free(up);
return -1;
556}

558static int
559typesequiv(const struct state *sp, int a, int b)
560{
int	result;

if (sp == NULL((void *)0) ||
   a < 0 || a >= sp->typecnt ||
   b < 0 || b >= sp->typecnt)
result = FALSE0;
else {
const struct ttinfo *	ap = &sp->ttis[a];
const struct ttinfo *	bp = &sp->ttis[b];
result = ap->tt_gmtoff == bp->tt_gmtoff &&
    ap->tt_isdst == bp->tt_isdst &&
    ap->tt_ttisstd == bp->tt_ttisstd &&
    ap->tt_ttisgmt == bp->tt_ttisgmt &&
    strcmp(&sp->chars[ap->tt_abbrind],
    &sp->chars[bp->tt_abbrind]) == 0;
}
return result;
578}

580static const int	mon_lengths[2][MONSPERYEAR12] = {
{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
583};

585static const int	year_lengths[2] = {
DAYSPERNYEAR365, DAYSPERLYEAR366
587};

589/*
590** Given a pointer into a time zone string, scan until a character that is not
591** a valid character in a zone name is found. Return a pointer to that
592** character.
593*/

595static const char *
596getzname(const char *strp)
597{
char	c;

while ((c = *strp) != '\0' && !isdigit((unsigned char)c) && c != ',' && c != '-' &&
   c != '+')
++strp;
return strp;
604}

606/*
607** Given a pointer into an extended time zone string, scan until the ending
608** delimiter of the zone name is located. Return a pointer to the delimiter.
609**
610** As with getzname above, the legal character set is actually quite
611** restricted, with other characters producing undefined results.
612** We don't do any checking here; checking is done later in common-case code.
613*/

615static const char *
616getqzname(const char *strp, const int delim)
617{
int	c;

while ((c = *strp) != '\0' && c != delim)
++strp;
return strp;
623}

625/*
626** Given a pointer into a time zone string, extract a number from that string.
627** Check that the number is within a specified range; if it is not, return
628** NULL.
629** Otherwise, return a pointer to the first character not part of the number.
630*/

632static const char *
633getnum(const char *strp, int *nump, int min, int max)
634{
char	c;
int	num;

if (strp == NULL((void *)0) || !isdigit((unsigned char)(c = *strp)))
return NULL((void *)0);
num = 0;
do {
num = num * 10 + (c - '0');
if (num > max)
	return NULL((void *)0);	/* illegal value */
c = *++strp;
} while (isdigit((unsigned char)c));
if (num < min)
return NULL((void *)0);		/* illegal value */
*nump = num;
return strp;
651}

653/*
654** Given a pointer into a time zone string, extract a number of seconds,
655** in hh[:mm[:ss]] form, from the string.
656** If any error occurs, return NULL.
657** Otherwise, return a pointer to the first character not part of the number
658** of seconds.
659*/

661static const char *
662getsecs(const char *strp, long *secsp)
663{
int	num;

/*
** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like
** "M10.4.6/26", which does not conform to Posix,
** but which specifies the equivalent of
** ``02:00 on the first Sunday on or after 23 Oct''.
*/
strp = getnum(strp, &num, 0, HOURSPERDAY24 * DAYSPERWEEK7 - 1);
if (strp == NULL((void *)0))
return NULL((void *)0);
*secsp = num * (long) SECSPERHOUR(60 * 60);
if (*strp == ':') {
++strp;
strp = getnum(strp, &num, 0, MINSPERHOUR60 - 1);
if (strp == NULL((void *)0))
	return NULL((void *)0);
*secsp += num * SECSPERMIN60;
if (*strp == ':') {
	++strp;
	/* `SECSPERMIN' allows for leap seconds. */
	strp = getnum(strp, &num, 0, SECSPERMIN60);
	if (strp == NULL((void *)0))
		return NULL((void *)0);
	*secsp += num;
}
}
return strp;
692}

694/*
695** Given a pointer into a time zone string, extract an offset, in
696** [+-]hh[:mm[:ss]] form, from the string.
697** If any error occurs, return NULL.
698** Otherwise, return a pointer to the first character not part of the time.
699*/

701static const char *
702getoffset(const char *strp, long *offsetp)
703{
int	neg = 0;

if (*strp == '-') {
neg = 1;
++strp;
} else if (*strp == '+')
++strp;
strp = getsecs(strp, offsetp);
if (strp == NULL((void *)0))
return NULL((void *)0);		/* illegal time */
if (neg)
*offsetp = -*offsetp;
return strp;
717}

719/*
720** Given a pointer into a time zone string, extract a rule in the form
721** date[/time]. See POSIX section 8 for the format of "date" and "time".
722** If a valid rule is not found, return NULL.
723** Otherwise, return a pointer to the first character not part of the rule.
724*/

726static const char *
727getrule(const char *strp, struct rule *rulep)
728{
if (*strp == 'J') {
/*
** Julian day.
*/
rulep->r_type = JULIAN_DAY0;
++strp;
strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR365);
} else if (*strp == 'M') {
/*
** Month, week, day.
*/
rulep->r_type = MONTH_NTH_DAY_OF_WEEK2;
++strp;
strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR12);
if (strp == NULL((void *)0))
	return NULL((void *)0);
if (*strp++ != '.')
	return NULL((void *)0);
strp = getnum(strp, &rulep->r_week, 1, 5);
if (strp == NULL((void *)0))
	return NULL((void *)0);
if (*strp++ != '.')
	return NULL((void *)0);
strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK7 - 1);
} else if (isdigit((unsigned char)*strp)) {
/*
** Day of year.
*/
rulep->r_type = DAY_OF_YEAR1;
strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR366 - 1);
} else
return NULL((void *)0);		/* invalid format */
if (strp == NULL((void *)0))
return NULL((void *)0);
if (*strp == '/') {
/*
** Time specified.
*/
++strp;
strp = getsecs(strp, &rulep->r_time);
} else
rulep->r_time = 2 * SECSPERHOUR(60 * 60);	/* default = 2:00:00 */
return strp;
772}

774/*
775** Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the
776** year, a rule, and the offset from UTC at the time that rule takes effect,
777** calculate the Epoch-relative time that rule takes effect.
778*/

780static time_t
781transtime(time_t janfirst, int year, const struct rule *rulep, long offset)
782{
int	leapyear;
time_t	value;
int	i;
int		d, m1, yy0, yy1, yy2, dow;

value = 0;
leapyear = isleap(year)(((year) % 4) == 0 && (((year) % 100) != 0 || ((year)
 % 400) == 0));
switch (rulep->r_type) {

case JULIAN_DAY0:
/*
** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap
** years.
** In non-leap years, or if the day number is 59 or less, just
** add SECSPERDAY times the day number-1 to the time of
** January 1, midnight, to get the day.
*/
value = janfirst + (rulep->r_day - 1) * SECSPERDAY((long) (60 * 60) * 24);
if (leapyear && rulep->r_day >= 60)
	value += SECSPERDAY((long) (60 * 60) * 24);
break;

case DAY_OF_YEAR1:
/*
** n - day of year.
** Just add SECSPERDAY times the day number to the time of
** January 1, midnight, to get the day.
*/
value = janfirst + rulep->r_day * SECSPERDAY((long) (60 * 60) * 24);
break;

case MONTH_NTH_DAY_OF_WEEK2:
/*
** Mm.n.d - nth "dth day" of month m.
*/
value = janfirst;
for (i = 0; i < rulep->r_mon - 1; ++i)
	value += mon_lengths[leapyear][i] * SECSPERDAY((long) (60 * 60) * 24);

/*
** Use Zeller's Congruence to get day-of-week of first day of
** month.
*/
m1 = (rulep->r_mon + 9) % 12 + 1;
yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;
yy1 = yy0 / 100;
yy2 = yy0 % 100;
dow = ((26 * m1 - 2) / 10 +
    1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
if (dow < 0)
	dow += DAYSPERWEEK7;

/*
** "dow" is the day-of-week of the first day of the month. Get
** the day-of-month (zero-origin) of the first "dow" day of the
** month.
*/
d = rulep->r_day - dow;
if (d < 0)
	d += DAYSPERWEEK7;
for (i = 1; i < rulep->r_week; ++i) {
	if (d + DAYSPERWEEK7 >=
	    mon_lengths[leapyear][rulep->r_mon - 1])
		break;
	d += DAYSPERWEEK7;
}

/*
** "d" is the day-of-month (zero-origin) of the day we want.
*/
value += d * SECSPERDAY((long) (60 * 60) * 24);
break;
}

/*
** "value" is the Epoch-relative time of 00:00:00 UTC on the day in
** question. To get the Epoch-relative time of the specified local
** time on that day, add the transition time and the current offset
** from UTC.
*/
return value + rulep->r_time + offset;
864}

866/*
867** Given a POSIX section 8-style TZ string, fill in the rule tables as
868** appropriate.
869*/

871static int
872tzparse(const char *name, struct state *sp, int lastditch)
873{
const char *			stdname;
const char *			dstname;
size_t				stdlen;
size_t				dstlen;
long				stdoffset;
long				dstoffset;
time_t *		atp;
unsigned char *	typep;
char *			cp;
int			load_result;
static struct ttinfo		zttinfo;

dstname = NULL((void *)0);
stdname = name;
if (lastditch) {
stdlen = strlen(name);	/* length of standard zone name */
name += stdlen;
if (stdlen >= sizeof sp->chars)
	stdlen = (sizeof sp->chars) - 1;
stdoffset = 0;
} else {
if (*name == '<') {
	name++;
	stdname = name;
	name = getqzname(name, '>');
	if (*name != '>')
		return (-1);
	stdlen = name - stdname;
	name++;
} else {
	name = getzname(name);
	stdlen = name - stdname;
}
if (*name == '\0')
	return -1;
name = getoffset(name, &stdoffset);
if (name == NULL((void *)0))
	return -1;
}
load_result = tzload(TZDEFRULES"posixrules", sp, FALSE0);
if (load_result != 0)
sp->leapcnt = 0;		/* so, we're off a little */
if (*name != '\0') {
if (*name == '<') {
	dstname = ++name;
	name = getqzname(name, '>');
	if (*name != '>')
		return -1;
	dstlen = name - dstname;
	name++;
} else {
	dstname = name;
	name = getzname(name);
	dstlen = name - dstname; /* length of DST zone name */
}
if (*name != '\0' && *name != ',' && *name != ';') {
	name = getoffset(name, &dstoffset);
	if (name == NULL((void *)0))
		return -1;
} else
	dstoffset = stdoffset - SECSPERHOUR(60 * 60);
if (*name == '\0' && load_result != 0)
	name = TZDEFRULESTRING",M4.1.0,M10.5.0";
if (*name == ',' || *name == ';') {
	struct rule	start;
	struct rule	end;
	int		year;
	time_t		janfirst;
	time_t		starttime;
	time_t		endtime;

	++name;
	if ((name = getrule(name, &start)) == NULL((void *)0))
		return -1;
	if (*name++ != ',')
		return -1;
	if ((name = getrule(name, &end)) == NULL((void *)0))
		return -1;
	if (*name != '\0')
		return -1;
	sp->typecnt = 2;	/* standard time and DST */
	/*
	** Two transitions per year, from EPOCH_YEAR forward.
	*/
	sp->ttis[0] = sp->ttis[1] = zttinfo;
	sp->ttis[0].tt_gmtoff = -dstoffset;
	sp->ttis[0].tt_isdst = 1;
	sp->ttis[0].tt_abbrind = stdlen + 1;
	sp->ttis[1].tt_gmtoff = -stdoffset;
	sp->ttis[1].tt_isdst = 0;
	sp->ttis[1].tt_abbrind = 0;
	atp = sp->ats;
	typep = sp->types;
	janfirst = 0;
	sp->timecnt = 0;
	for (year = EPOCH_YEAR1970;
	    sp->timecnt + 2 <= TZ_MAX_TIMES1200;
	    ++year) {
	    	time_t	newfirst;

		starttime = transtime(janfirst, year, &start,
		    stdoffset);
		endtime = transtime(janfirst, year, &end,
		    dstoffset);
		if (starttime > endtime) {
			*atp++ = endtime;
			*typep++ = 1;	/* DST ends */
			*atp++ = starttime;
			*typep++ = 0;	/* DST begins */
		} else {
			*atp++ = starttime;
			*typep++ = 0;	/* DST begins */
			*atp++ = endtime;
			*typep++ = 1;	/* DST ends */
		}
		sp->timecnt += 2;
		newfirst = janfirst;
		newfirst += year_lengths[isleap(year)(((year) % 4) == 0 && (((year) % 100) != 0 || ((year)
 % 400) == 0))] *
		    SECSPERDAY((long) (60 * 60) * 24);
		if (newfirst <= janfirst)
			break;
		janfirst = newfirst;
	}
} else {
	long	theirstdoffset;
	long	theirdstoffset;
	long	theiroffset;
	int	isdst;
	int	i;
	int	j;

	if (*name != '\0')
		return -1;
	/*
	** Initial values of theirstdoffset and theirdstoffset.
	*/
	theirstdoffset = 0;
	for (i = 0; i < sp->timecnt; ++i) {
		j = sp->types[i];
		if (!sp->ttis[j].tt_isdst) {
			theirstdoffset =
				-sp->ttis[j].tt_gmtoff;
			break;
		}
	}
	theirdstoffset = 0;
	for (i = 0; i < sp->timecnt; ++i) {
		j = sp->types[i];
		if (sp->ttis[j].tt_isdst) {
			theirdstoffset =
				-sp->ttis[j].tt_gmtoff;
			break;
		}
	}
	/*
	** Initially we're assumed to be in standard time.
	*/
	isdst = FALSE0;
	theiroffset = theirstdoffset;
	/*
	** Now juggle transition times and types
	** tracking offsets as you do.
	*/
	for (i = 0; i < sp->timecnt; ++i) {
		j = sp->types[i];
		sp->types[i] = sp->ttis[j].tt_isdst;
		if (sp->ttis[j].tt_ttisgmt) {
			/* No adjustment to transition time */
		} else {
			/*
			** If summer time is in effect, and the
			** transition time was not specified as
			** standard time, add the summer time
			** offset to the transition time;
			** otherwise, add the standard time
			** offset to the transition time.
			*/
			/*
			** Transitions from DST to DDST
			** will effectively disappear since
			** POSIX provides for only one DST
			** offset.
			*/
			if (isdst && !sp->ttis[j].tt_ttisstd) {
				sp->ats[i] += dstoffset -
				    theirdstoffset;
			} else {
				sp->ats[i] += stdoffset -
				    theirstdoffset;
			}
		}
		theiroffset = -sp->ttis[j].tt_gmtoff;
		if (sp->ttis[j].tt_isdst)
			theirdstoffset = theiroffset;
		else
			theirstdoffset = theiroffset;
	}
	/*
	** Finally, fill in ttis.
	*/
	sp->ttis[0] = sp->ttis[1] = zttinfo;
	sp->ttis[0].tt_gmtoff = -stdoffset;
	sp->ttis[0].tt_isdst = FALSE0;
	sp->ttis[0].tt_abbrind = 0;
	sp->ttis[1].tt_gmtoff = -dstoffset;
	sp->ttis[1].tt_isdst = TRUE1;
	sp->ttis[1].tt_abbrind = stdlen + 1;
	sp->typecnt = 2;
}
} else {
dstlen = 0;
sp->typecnt = 1;		/* only standard time */
sp->timecnt = 0;
sp->ttis[0] = zttinfo;
sp->ttis[0].tt_gmtoff = -stdoffset;
sp->ttis[0].tt_isdst = 0;
sp->ttis[0].tt_abbrind = 0;
}
sp->charcnt = stdlen + 1;
if (dstlen != 0)
sp->charcnt += dstlen + 1;
if ((size_t) sp->charcnt > sizeof sp->chars)
return -1;
cp = sp->chars;
strlcpy(cp, stdname, stdlen + 1);
cp += stdlen + 1;
if (dstlen != 0) {
strlcpy(cp, dstname, dstlen + 1);
}
return 0;
1104}

1106static void
1107gmtload(struct state *sp)
1108{
if (tzload(gmt, sp, TRUE1) != 0)
(void) tzparse(gmt, sp, TRUE1);
1111}

1113static void
1114tzsetwall_basic(void)
1115{
if (lcl_is_set < 0)
return;
lcl_is_set = -1;

if (lclptr == NULL((void *)0)) {
lclptr = calloc(1, sizeof *lclptr);
if (lclptr == NULL((void *)0)) {
	settzname();	/* all we can do */
	return;
}
}
if (tzload(NULL((void *)0), lclptr, TRUE1) != 0)
gmtload(lclptr);
settzname();
1130}

1132#ifndef STD_INSPIRED1
1133/*
1134** A non-static declaration of tzsetwall in a system header file
1135** may cause a warning about this upcoming static declaration...
1136*/
1137static
1138#endif /* !defined STD_INSPIRED */
1139void
1140tzsetwall(void)
1141{
_THREAD_PRIVATE_MUTEX_LOCK(lcl)do { if (_thread_cb.tc_tag_lock != ((void *)0)) _thread_cb.tc_tag_lock
(&(_thread_tagname_lcl)); } while (0);
tzsetwall_basic();
_THREAD_PRIVATE_MUTEX_UNLOCK(lcl)do { if (_thread_cb.tc_tag_unlock != ((void *)0)) _thread_cb.
tc_tag_unlock(&(_thread_tagname_lcl)); } while (0);
1145}

1147static void
1148tzset_basic(void)
1149{
const char *	name;

if (issetugid() || (name = getenv("TZ")) == NULL((void *)0)) {
tzsetwall_basic();
return;
}

if (lcl_is_set > 0 && strcmp(lcl_TZname, name) == 0)
return;
lcl_is_set = strlen(name) < sizeof lcl_TZname;
if (lcl_is_set)
strlcpy(lcl_TZname, name, sizeof lcl_TZname);

if (lclptr == NULL((void *)0)) {
lclptr = calloc(1, sizeof *lclptr);
if (lclptr == NULL((void *)0)) {
	settzname();	/* all we can do */
	return;
}
}
if (*name == '\0') {
/*
** User wants it fast rather than right.
*/
lclptr->leapcnt = 0;		/* so, we're off a little */
lclptr->timecnt = 0;
lclptr->typecnt = 0;
lclptr->ttis[0].tt_isdst = 0;
lclptr->ttis[0].tt_gmtoff = 0;
lclptr->ttis[0].tt_abbrind = 0;
strlcpy(lclptr->chars, gmt, sizeof lclptr->chars);
} else if (tzload(name, lclptr, TRUE1) != 0) {
if (name[0] == ':' || tzparse(name, lclptr, FALSE0) != 0)
	gmtload(lclptr);
}
settzname();
1186}

1188void
1189tzset(void)
1190{
_THREAD_PRIVATE_MUTEX_LOCK(lcl)do { if (_thread_cb.tc_tag_lock != ((void *)0)) _thread_cb.tc_tag_lock
(&(_thread_tagname_lcl)); } while (0);
tzset_basic();
_THREAD_PRIVATE_MUTEX_UNLOCK(lcl)do { if (_thread_cb.tc_tag_unlock != ((void *)0)) _thread_cb.
tc_tag_unlock(&(_thread_tagname_lcl)); } while (0);
1194}
1195DEF_WEAK(tzset)__asm__(".weak " "tzset" " ; " "tzset" " = " "_libc_tzset");

1197/*
1198** The easy way to behave "as if no library function calls" localtime
1199** is to not call it--so we drop its guts into "localsub", which can be
1200** freely called. (And no, the PANS doesn't require the above behavior--
1201** but it *is* desirable.)
1202**
1203** The unused offset argument is for the benefit of mktime variants.
1204*/

1206static struct tm *
1207localsub(const time_t *timep, long offset, struct tm *tmp)
1208{
struct state *		sp;
const struct ttinfo *	ttisp;
int			i;
struct tm *		result;
const time_t			t = *timep;

sp = lclptr;
if (sp == NULL((void *)0))
return gmtsub(timep, offset, tmp);
if ((sp->goback && t < sp->ats[0]) ||
   (sp->goahead && t > sp->ats[sp->timecnt - 1])) {
time_t			newt = t;
time_t		seconds;
time_t		tcycles;
int_fast64_t	icycles;

if (t < sp->ats[0])
	seconds = sp->ats[0] - t;
else
	seconds = t - sp->ats[sp->timecnt - 1];
--seconds;
tcycles = seconds / YEARSPERREPEAT400 / AVGSECSPERYEAR31556952L;
++tcycles;
icycles = tcycles;
if (tcycles - icycles >= 1 || icycles - tcycles >= 1)
	return NULL((void *)0);
seconds = icycles;
seconds *= YEARSPERREPEAT400;
seconds *= AVGSECSPERYEAR31556952L;
if (t < sp->ats[0])
	newt += seconds;
else
	newt -= seconds;
if (newt < sp->ats[0] ||
    newt > sp->ats[sp->timecnt - 1])
	return NULL((void *)0);	/* "cannot happen" */
result = localsub(&newt, offset, tmp);
if (result == tmp) {
	time_t	newy;

	newy = tmp->tm_year;
	if (t < sp->ats[0])
		newy -= icycles * YEARSPERREPEAT400;
	else
		newy += icycles * YEARSPERREPEAT400;
	tmp->tm_year = newy;
	if (tmp->tm_year != newy)
		return NULL((void *)0);
}
return result;
}
if (sp->timecnt == 0 || t < sp->ats[0]) {
i = 0;
while (sp->ttis[i].tt_isdst) {
	if (++i >= sp->typecnt) {
		i = 0;
		break;
	}
}
} else {
int	lo = 1;
int	hi = sp->timecnt;

while (lo < hi) {
	int	mid = (lo + hi) >> 1;

	if (t < sp->ats[mid])
		hi = mid;
	else
		lo = mid + 1;
}
i = (int) sp->types[lo - 1];
}
ttisp = &sp->ttis[i];
/*
** To get (wrong) behavior that's compatible with System V Release 2.0
** you'd replace the statement below with
**	t += ttisp->tt_gmtoff;
**	timesub(&t, 0L, sp, tmp);
*/
result = timesub(&t, ttisp->tt_gmtoff, sp, tmp);
tmp->tm_isdst = ttisp->tt_isdst;
tzname[tmp->tm_isdst] = &sp->chars[ttisp->tt_abbrind];
tmp->tm_zone = &sp->chars[ttisp->tt_abbrind];
return result;
1294}

1296/*
1297** Re-entrant version of localtime.
1298*/

1300struct tm *
1301localtime_r(const time_t *timep, struct tm *p_tm)
1302{
_THREAD_PRIVATE_MUTEX_LOCK(lcl)do { if (_thread_cb.tc_tag_lock != ((void *)0)) _thread_cb.tc_tag_lock
(&(_thread_tagname_lcl)); } while (0);
tzset_basic();
p_tm = localsub(timep, 0L, p_tm);
_THREAD_PRIVATE_MUTEX_UNLOCK(lcl)do { if (_thread_cb.tc_tag_unlock != ((void *)0)) _thread_cb.
tc_tag_unlock(&(_thread_tagname_lcl)); } while (0);
return p_tm;
1308}
1309DEF_WEAK(localtime_r)__asm__(".weak " "localtime_r" " ; " "localtime_r" " = " "_libc_localtime_r"
);

1311struct tm *
1312localtime(const time_t *timep)
1313{
_THREAD_PRIVATE_KEY(localtime)static void *_thread_tagname_localtime;
struct tm * p_tm = (struct tm*)_THREAD_PRIVATE(localtime, tm, NULL)(_thread_cb.tc_tag_storage == ((void *)0) ? &(tm) : _thread_cb
.tc_tag_storage(&(_thread_tagname_localtime), &(tm), sizeof
(tm), ((void *)0), (((void *)0))));

if (p_tm == NULL((void *)0))
return NULL((void *)0);
return localtime_r(timep, p_tm);
1320}
1321DEF_STRONG(localtime)__asm__(".global " "localtime" " ; " "localtime" " = " "_libc_localtime"
);

1323/*
1324** gmtsub is to gmtime as localsub is to localtime.
1325*/

1327static struct tm *
1328gmtsub(const time_t *timep, long offset, struct tm *tmp)
1329{
struct tm *	result;

_THREAD_PRIVATE_MUTEX_LOCK(gmt)do { if (_thread_cb.tc_tag_lock != ((void *)0)) _thread_cb.tc_tag_lock
(&(_thread_tagname_gmt)); } while (0);
if (!gmt_is_set) {
gmt_is_set = TRUE1;
gmtptr = calloc(1, sizeof(*gmtptr));
if (gmtptr != NULL((void *)0))
	gmtload(gmtptr);
}
_THREAD_PRIVATE_MUTEX_UNLOCK(gmt)do { if (_thread_cb.tc_tag_unlock != ((void *)0)) _thread_cb.
tc_tag_unlock(&(_thread_tagname_gmt)); } while (0);
result = timesub(timep, offset, gmtptr, tmp);
/*
** Could get fancy here and deliver something such as
** "UTC+xxxx" or "UTC-xxxx" if offset is non-zero,
** but this is no time for a treasure hunt.
*/
if (offset != 0)
tmp->tm_zone = wildabbr;
else {
if (gmtptr == NULL((void *)0))
	tmp->tm_zone = (char *)gmt;
else
	tmp->tm_zone = gmtptr->chars;
}
return result;
1355}

1357/*
1358** Re-entrant version of gmtime.
1359*/

1361struct tm *
1362gmtime_r(const time_t *timep, struct tm *p_tm)
1363{
return gmtsub(timep, 0L, p_tm);
1365}
1366DEF_WEAK(gmtime_r)__asm__(".weak " "gmtime_r" " ; " "gmtime_r" " = " "_libc_gmtime_r"
);

1368struct tm *
1369gmtime(const time_t *timep)
1370{
_THREAD_PRIVATE_KEY(gmtime)static void *_thread_tagname_gmtime;
struct tm * p_tm = (struct tm*) _THREAD_PRIVATE(gmtime, tm, NULL)(_thread_cb.tc_tag_storage == ((void *)0) ? &(tm) : _thread_cb
.tc_tag_storage(&(_thread_tagname_gmtime), &(tm), sizeof
(tm), ((void *)0), (((void *)0))));

if (p_tm == NULL((void *)0))
return NULL((void *)0);
return gmtime_r(timep, p_tm);

1378}
1379DEF_WEAK(gmtime)__asm__(".weak " "gmtime" " ; " "gmtime" " = " "_libc_gmtime"
);

1381#ifdef STD_INSPIRED1

1383struct tm *
1384offtime(const time_t *timep, long offset)
1385{
return gmtsub(timep, offset, &tm);
1387}

1389#endif /* defined STD_INSPIRED */

1391/*
1392** Return the number of leap years through the end of the given year
1393** where, to make the math easy, the answer for year zero is defined as zero.
1394*/

1396static int
1397leaps_thru_end_of(int y)
1398{
return (y >= 0) ? (y / 4 - y / 100 + y / 400) :
-(leaps_thru_end_of(-(y + 1)) + 1);
1401}

1403static struct tm *
1404timesub(const time_t *timep, long offset, const struct state *sp, struct tm *tmp)
1405{
const struct lsinfo *	lp;
time_t			tdays;
int			idays;	/* unsigned would be so 2003 */
long			rem;
int			y;
const int *		ip;
long			corr;
int			hit;
int			i;
long			seconds;

corr = 0;
hit = 0;
i = (sp == NULL((void *)0)) ? 0 : sp->leapcnt;
while (--i >= 0) {
lp = &sp->lsis[i];
if (*timep >= lp->ls_trans) {
	if (*timep == lp->ls_trans) {
		hit = ((i == 0 && lp->ls_corr > 0) ||
		    lp->ls_corr > sp->lsis[i - 1].ls_corr);
		if (hit) {
			while (i > 0 &&
			    sp->lsis[i].ls_trans ==
			    sp->lsis[i - 1].ls_trans + 1 &&
			    sp->lsis[i].ls_corr ==
			    sp->lsis[i - 1].ls_corr + 1) {
				++hit;
				--i;
			}
		}
	}
	corr = lp->ls_corr;
	break;
}
}
y = EPOCH_YEAR1970;
tdays = *timep / SECSPERDAY((long) (60 * 60) * 24);
rem = *timep - tdays * SECSPERDAY((long) (60 * 60) * 24);
while (tdays < 0 || tdays >= year_lengths[isleap(y)(((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) ==
 0))]) {
int		newy;
time_t	tdelta;
int	idelta;
int	leapdays;

tdelta = tdays / DAYSPERLYEAR366;
idelta = tdelta;
if (tdelta - idelta >= 1 || idelta - tdelta >= 1)
	return NULL((void *)0);
if (idelta == 0)
	idelta = (tdays < 0) ? -1 : 1;
newy = y;
if (increment_overflow(&newy, idelta))
	return NULL((void *)0);
leapdays = leaps_thru_end_of(newy - 1) -
	leaps_thru_end_of(y - 1);
tdays -= ((time_t) newy - y) * DAYSPERNYEAR365;
tdays -= leapdays;
y = newy;
}

seconds = tdays * SECSPERDAY((long) (60 * 60) * 24) + 0.5;
tdays = seconds / SECSPERDAY((long) (60 * 60) * 24);
rem += seconds - tdays * SECSPERDAY((long) (60 * 60) * 24);

/*
** Given the range, we can now fearlessly cast...
*/
idays = tdays;
rem += offset - corr;
while (rem < 0) {
rem += SECSPERDAY((long) (60 * 60) * 24);
--idays;
}
while (rem >= SECSPERDAY((long) (60 * 60) * 24)) {
rem -= SECSPERDAY((long) (60 * 60) * 24);
++idays;
}
while (idays < 0) {
if (increment_overflow(&y, -1))
	return NULL((void *)0);
idays += year_lengths[isleap(y)(((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) ==
 0))];
}
while (idays >= year_lengths[isleap(y)(((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) ==
 0))]) {
idays -= year_lengths[isleap(y)(((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) ==
 0))];
if (increment_overflow(&y, 1))
	return NULL((void *)0);
}
tmp->tm_year = y;
if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE1900))
return NULL((void *)0);
tmp->tm_yday = idays;
/*
** The "extra" mods below avoid overflow problems.
*/
tmp->tm_wday = EPOCH_WDAY4 +
   ((y - EPOCH_YEAR1970) % DAYSPERWEEK7) *
   (DAYSPERNYEAR365 % DAYSPERWEEK7) +
   leaps_thru_end_of(y - 1) -
   leaps_thru_end_of(EPOCH_YEAR1970 - 1) +
   idays;
tmp->tm_wday %= DAYSPERWEEK7;
if (tmp->tm_wday < 0)
tmp->tm_wday += DAYSPERWEEK7;
tmp->tm_hour = (int) (rem / SECSPERHOUR(60 * 60));
rem %= SECSPERHOUR(60 * 60);
tmp->tm_min = (int) (rem / SECSPERMIN60);
/*
** A positive leap second requires a special
** representation. This uses "... ??:59:60" et seq.
*/
tmp->tm_sec = (int) (rem % SECSPERMIN60) + hit;
ip = mon_lengths[isleap(y)(((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) ==
 0))];
for (tmp->tm_mon = 0; idays >= ip[tmp->tm_mon]; ++(tmp->tm_mon))
idays -= ip[tmp->tm_mon];
tmp->tm_mday = (int) (idays + 1);
tmp->tm_isdst = 0;
tmp->tm_gmtoff = offset;
return tmp;
1524}

1526char *
1527ctime(const time_t *timep)
1528{
1529/*
1530** Section 4.12.3.2 of X3.159-1989 requires that
1531**	The ctime function converts the calendar time pointed to by timer
1532**	to local time in the form of a string. It is equivalent to
1533**		asctime(localtime(timer))
1534*/
return asctime(localtime(timep));
1536}

1538char *
1539ctime_r(const time_t *timep, char *buf)
1540{
struct tm	mytm;

return asctime_r(localtime_r(timep, &mytm), buf);
1544}

1546/*
1547** Adapted from code provided by Robert Elz, who writes:
1548**	The "best" way to do mktime I think is based on an idea of Bob
1549**	Kridle's (so its said...) from a long time ago.
1550**	It does a binary search of the time_t space. Since time_t's are
1551**	just 32 bits, its a max of 32 iterations (even at 64 bits it
1552**	would still be very reasonable).
1553*/

1555#ifndef WRONG(-1)
1556#define WRONG(-1)	(-1)
1557#endif /* !defined WRONG */

1559/*
1560** Normalize logic courtesy Paul Eggert.
1561*/

1563static int
1564increment_overflow(int *ip, int j)
1565{
int const	i = *ip;

/*
** If i >= 0 there can only be overflow if i + j > INT_MAX
** or if j > INT_MAX - i; given i >= 0, INT_MAX - i cannot overflow.
** If i < 0 there can only be overflow if i + j < INT_MIN
** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow.
*/
if ((i >= 0) ? (j > INT_MAX0x7fffffff - i) : (j < INT_MIN(-0x7fffffff-1) - i))
return TRUE1;
*ip += j;
return FALSE0;
1578}

1580static int
1581long_increment_overflow(long *lp, int m)
1582{
long const	l = *lp;

if ((l >= 0) ? (m > LONG_MAX0x7fffffffffffffffL - l) : (m < LONG_MIN(-0x7fffffffffffffffL-1) - l))
return TRUE1;
*lp += m;
return FALSE0;
1589}

1591static int
1592normalize_overflow(int *tensptr, int *unitsptr, int base)
1593{
int	tensdelta;

tensdelta = (*unitsptr >= 0) ?
   (*unitsptr / base) :
   (-1 - (-1 - *unitsptr) / base);
*unitsptr -= tensdelta * base;
return increment_overflow(tensptr, tensdelta);
1601}

1603static int
1604long_normalize_overflow(long *tensptr, int *unitsptr, int base)
1605{
int	tensdelta;

tensdelta = (*unitsptr >= 0) ?
   (*unitsptr / base) :
   (-1 - (-1 - *unitsptr) / base);
*unitsptr -= tensdelta * base;
return long_increment_overflow(tensptr, tensdelta);
1613}

1615static int
1616tmcomp(const struct tm *atmp, const struct tm *btmp)
1617{
int	result;

if ((result = (atmp->tm_year - btmp->tm_year)) == 0 &&
   (result = (atmp->tm_mon - btmp->tm_mon)) == 0 &&
   (result = (atmp->tm_mday - btmp->tm_mday)) == 0 &&
   (result = (atmp->tm_hour - btmp->tm_hour)) == 0 &&
   (result = (atmp->tm_min - btmp->tm_min)) == 0)
result = atmp->tm_sec - btmp->tm_sec;
return result;
1627}

1629static time_t
1630time2sub(struct tm *tmp, struct tm *(*funcp)(const time_t *, long, struct tm *),
  long offset, int *okayp, int do_norm_secs)
1632{
const struct state *	sp;
int			dir;
int			i, j;
int			saved_seconds;
long			li;
time_t			lo;
time_t			hi;
long			y;
time_t			newt;
time_t			t;
struct tm		yourtm, mytm;

*okayp = FALSE0;
yourtm = *tmp;
if (do_norm_secs) {
if (normalize_overflow(&yourtm.tm_min, &yourtm.tm_sec,
	SECSPERMIN60))
		return WRONG(-1);
}
if (normalize_overflow(&yourtm.tm_hour, &yourtm.tm_min, MINSPERHOUR60))
return WRONG(-1);
if (normalize_overflow(&yourtm.tm_mday, &yourtm.tm_hour, HOURSPERDAY24))
return WRONG(-1);
y = yourtm.tm_year;
if (long_normalize_overflow(&y, &yourtm.tm_mon, MONSPERYEAR12))
return WRONG(-1);
/*
** Turn y into an actual year number for now.
** It is converted back to an offset from TM_YEAR_BASE later.
*/
if (long_increment_overflow(&y, TM_YEAR_BASE1900))
return WRONG(-1);
while (yourtm.tm_mday <= 0) {
if (long_increment_overflow(&y, -1))
	return WRONG(-1);
li = y + (1 < yourtm.tm_mon);
yourtm.tm_mday += year_lengths[isleap(li)(((li) % 4) == 0 && (((li) % 100) != 0 || ((li) % 400
) == 0))];
}
while (yourtm.tm_mday > DAYSPERLYEAR366) {
li = y + (1 < yourtm.tm_mon);
yourtm.tm_mday -= year_lengths[isleap(li)(((li) % 4) == 0 && (((li) % 100) != 0 || ((li) % 400
) == 0))];
if (long_increment_overflow(&y, 1))
	return WRONG(-1);
}
for ( ; ; ) {
i = mon_lengths[isleap(y)(((y) % 4) == 0 && (((y) % 100) != 0 || ((y) % 400) ==
 0))][yourtm.tm_mon];
if (yourtm.tm_mday <= i)
	break;
yourtm.tm_mday -= i;
if (++yourtm.tm_mon >= MONSPERYEAR12) {
	yourtm.tm_mon = 0;
	if (long_increment_overflow(&y, 1))
		return WRONG(-1);
}
}
if (long_increment_overflow(&y, -TM_YEAR_BASE1900))
return WRONG(-1);
yourtm.tm_year = y;
if (yourtm.tm_year != y)
return WRONG(-1);
if (yourtm.tm_sec >= 0 && yourtm.tm_sec < SECSPERMIN60)
saved_seconds = 0;
else if (y + TM_YEAR_BASE1900 < EPOCH_YEAR1970) {
/*
** We can't set tm_sec to 0, because that might push the
** time below the minimum representable time.
** Set tm_sec to 59 instead.
** This assumes that the minimum representable time is
** not in the same minute that a leap second was deleted from,
** which is a safer assumption than using 58 would be.
*/
if (increment_overflow(&yourtm.tm_sec, 1 - SECSPERMIN60))
	return WRONG(-1);
saved_seconds = yourtm.tm_sec;
yourtm.tm_sec = SECSPERMIN60 - 1;
} else {
saved_seconds = yourtm.tm_sec;
yourtm.tm_sec = 0;
}
/*
** Do a binary search (this works whatever time_t's type is).
*/
lo = 1;
for (i = 0; i < (int) TYPE_BIT(time_t)(sizeof (time_t) * 8) - 1; ++i)
lo *= 2;
hi = -(lo + 1);
for ( ; ; ) {
t = lo / 2 + hi / 2;
if (t < lo)
	t = lo;
else if (t > hi)
	t = hi;
if ((*funcp)(&t, offset, &mytm) == NULL((void *)0)) {
	/*
	** Assume that t is too extreme to be represented in
	** a struct tm; arrange things so that it is less
	** extreme on the next pass.
	*/
	dir = (t > 0) ? 1 : -1;
} else
	dir = tmcomp(&mytm, &yourtm);
if (dir != 0) {
	if (t == lo) {
		++t;
		if (t <= lo)
			return WRONG(-1);
		++lo;
	} else if (t == hi) {
		--t;
		if (t >= hi)
			return WRONG(-1);
		--hi;
	}
	if (lo > hi)
		return WRONG(-1);
	if (dir > 0)
		hi = t;
	else
		lo = t;
	continue;
}
if (yourtm.tm_isdst < 0 || mytm.tm_isdst == yourtm.tm_isdst)
	break;
/*
** Right time, wrong type.
** Hunt for right time, right type.
** It's okay to guess wrong since the guess
** gets checked.
*/
sp = (const struct state *)
    ((funcp == localsub) ? lclptr : gmtptr);
if (sp == NULL((void *)0))
	return WRONG(-1);
for (i = sp->typecnt - 1; i >= 0; --i) {
	if (sp->ttis[i].tt_isdst != yourtm.tm_isdst)
		continue;
	for (j = sp->typecnt - 1; j >= 0; --j) {
		if (sp->ttis[j].tt_isdst == yourtm.tm_isdst)
			continue;
		newt = t + sp->ttis[j].tt_gmtoff -
			sp->ttis[i].tt_gmtoff;
		if ((*funcp)(&newt, offset, &mytm) == NULL((void *)0))
			continue;
		if (tmcomp(&mytm, &yourtm) != 0)
			continue;
		if (mytm.tm_isdst != yourtm.tm_isdst)
			continue;
		/*
		** We have a match.
		*/
		t = newt;
		goto label;
	}
}
return WRONG(-1);
}
1789label:
newt = t + saved_seconds;
if ((newt < t) != (saved_seconds < 0))
return WRONG(-1);
t = newt;
if ((*funcp)(&t, offset, tmp))
*okayp = TRUE1;
return t;
1797}

1799static time_t
1800time2(struct tm *tmp, struct tm * (*funcp)(const time_t *, long, struct tm *),
  long offset, int *okayp)
1802{
time_t	t;

/*
** First try without normalization of seconds
** (in case tm_sec contains a value associated with a leap second).
** If that fails, try with normalization of seconds.
*/
t = time2sub(tmp, funcp, offset, okayp, FALSE0);
return *okayp ? t : time2sub(tmp, funcp, offset, okayp, TRUE1);
1812}

1814static time_t
1815time1(struct tm *tmp, struct tm * (*funcp)(const time_t *, long, struct tm *),
  long offset)
1817{
time_t			t;
const struct state *	sp;
int			samei, otheri;
int			sameind, otherind;
int			i;
int			nseen;
int			seen[TZ_MAX_TYPES256];
int			types[TZ_MAX_TYPES256];
int			okay;

if (tmp == NULL((void *)0)) {
errno(*__errno()) = EINVAL22;
return WRONG(-1);
}
if (tmp->tm_isdst > 1)
tmp->tm_isdst = 1;
t = time2(tmp, funcp, offset, &okay);
1835#ifdef PCTS1
/*
** PCTS code courtesy Grant Sullivan.
*/
if (okay)
return t;
if (tmp->tm_isdst < 0)
tmp->tm_isdst = 0;	/* reset to std and try again */
1843#endif /* defined PCTS */
1844#ifndef PCTS1
if (okay || tmp->tm_isdst < 0)
return t;
1847#endif /* !defined PCTS */
/*
** We're supposed to assume that somebody took a time of one type
** and did some math on it that yielded a "struct tm" that's bad.
** We try to divine the type they started from and adjust to the
** type they need.
*/
sp = (const struct state *) ((funcp == localsub) ?  lclptr : gmtptr);
if (sp == NULL((void *)0))
return WRONG(-1);
for (i = 0; i < sp->typecnt; ++i)
seen[i] = FALSE0;
nseen = 0;
for (i = sp->timecnt - 1; i >= 0; --i) {
if (!seen[sp->types[i]]) {
	seen[sp->types[i]] = TRUE1;
	types[nseen++] = sp->types[i];
}
}
for (sameind = 0; sameind < nseen; ++sameind) {
samei = types[sameind];
if (sp->ttis[samei].tt_isdst != tmp->tm_isdst)
	continue;
for (otherind = 0; otherind < nseen; ++otherind) {
	otheri = types[otherind];
	if (sp->ttis[otheri].tt_isdst == tmp->tm_isdst)
		continue;
	tmp->tm_sec += sp->ttis[otheri].tt_gmtoff -
	    sp->ttis[samei].tt_gmtoff;
	tmp->tm_isdst = !tmp->tm_isdst;
	t = time2(tmp, funcp, offset, &okay);
	if (okay)
		return t;
	tmp->tm_sec -= sp->ttis[otheri].tt_gmtoff -
	    sp->ttis[samei].tt_gmtoff;
	tmp->tm_isdst = !tmp->tm_isdst;
}
}
return WRONG(-1);
1886}

1888time_t
1889mktime(struct tm *tmp)
1890{
time_t ret;

_THREAD_PRIVATE_MUTEX_LOCK(lcl)do { if (_thread_cb.tc_tag_lock != ((void *)0)) _thread_cb.tc_tag_lock
(&(_thread_tagname_lcl)); } while (0);
tzset_basic();
ret = time1(tmp, localsub, 0L);
_THREAD_PRIVATE_MUTEX_UNLOCK(lcl)do { if (_thread_cb.tc_tag_unlock != ((void *)0)) _thread_cb.
tc_tag_unlock(&(_thread_tagname_lcl)); } while (0);
return ret;
1898}
1899DEF_STRONG(mktime)__asm__(".global " "mktime" " ; " "mktime" " = " "_libc_mktime"
);

1901#ifdef STD_INSPIRED1

1903time_t
1904timelocal(struct tm *tmp)
1905{
if (tmp != NULL((void *)0))
tmp->tm_isdst = -1;	/* in case it wasn't initialized */
return mktime(tmp);
1909}

1911time_t
1912timegm(struct tm *tmp)
1913{
if (tmp != NULL((void *)0))
tmp->tm_isdst = 0;
return time1(tmp, gmtsub, 0L);
1917}

1919time_t
1920timeoff(struct tm *tmp, long offset)
1921{
if (tmp != NULL((void *)0))
tmp->tm_isdst = 0;
return time1(tmp, gmtsub, offset);
1925}

1927#endif /* defined STD_INSPIRED */

1929/*
1930** XXX--is the below the right way to conditionalize??
1931*/

1933#ifdef STD_INSPIRED1

1935/*
1936** IEEE Std 1003.1-1988 (POSIX) legislates that 536457599
1937** shall correspond to "Wed Dec 31 23:59:59 UTC 1986", which
1938** is not the case if we are accounting for leap seconds.
1939** So, we provide the following conversion routines for use
1940** when exchanging timestamps with POSIX conforming systems.
1941*/

1943static long
1944leapcorr(time_t *timep)
1945{
struct state *		sp;
struct lsinfo *	lp;
int			i;

sp = lclptr;
i = sp->leapcnt;
while (--i >= 0) {
lp = &sp->lsis[i];
if (*timep >= lp->ls_trans)
	return lp->ls_corr;
}
return 0;
1958}

1960time_t
1961time2posix(time_t t)
1962{
tzset();
return t - leapcorr(&t);
1965}

1967time_t
1968posix2time(time_t t)
1969{
time_t	x;
time_t	y;

tzset();
/*
** For a positive leap second hit, the result
** is not unique. For a negative leap second
** hit, the corresponding time doesn't exist,
** so we return an adjacent second.
*/
x = t + leapcorr(&t);
y = x - leapcorr(&x);
if (y < t) {
do {
	x++;
	y = x - leapcorr(&x);
} while (y < t);
if (t != y)
	return x - 1;
} else if (y > t) {
do {
	--x;
	y = x - leapcorr(&x);
} while (y > t);
if (t != y)
	return x + 1;
}
return x;
1998}

2000#endif /* defined STD_INSPIRED */