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

Bug Summary

File:	src/lib/libc/time/localtime.c
Warning:	line 1486, column 30 The right operand of '>=' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name localtime.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -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/lib/clang/13.0.0 -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 -D PIC -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/lib/libc/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -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/vmm/scan-build/2022-01-12-194120-40624-1 -x c /usr/src/lib/libc/time/localtime.c
1/*	$OpenBSD: localtime.c,v 1.61 2019/06/28 13:32:42 deraadt 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 <float.h>	/* for FLT_MAX and DBL_MAX */
16#include <stdint.h>
17#include <stdlib.h>
18#include <string.h>
19#include <unistd.h>

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

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

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

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

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

61static char		wildabbr[] = WILDABBR"   ";

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

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

76struct 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 */
82};

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

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

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

98struct 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];
111};

113struct 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 */
119};

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

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

129static long		detzcode(const char * codep);
130static time_t		detzcode64(const char * codep);
131static int		differ_by_repeat(time_t t1, time_t t0);
132static const char *	getzname(const char * strp);
133static const char *	getqzname(const char * strp, const int delim);
134static const char *	getnum(const char * strp, int * nump, int min,
		int max);
136static const char *	getsecs(const char * strp, long * secsp);
137static const char *	getoffset(const char * strp, long * offsetp);
138static const char *	getrule(const char * strp, struct rule * rulep);
139static void		gmtload(struct state * sp);
140static struct tm *	gmtsub(const time_t * timep, long offset,
		struct tm * tmp);
142static struct tm *	localsub(const time_t * timep, long offset,
		struct tm * tmp);
144static int		increment_overflow(int * number, int delta);
145static int		leaps_thru_end_of(int y);
146static int		long_increment_overflow(long * number, int delta);
147static int		long_normalize_overflow(long * tensptr,
		int * unitsptr, int base);
149static int		normalize_overflow(int * tensptr, int * unitsptr,
		int base);
151static void		settzname(void);
152static time_t		time1(struct tm * tmp,
		struct tm * (*funcp)(const time_t *,
		long, struct tm *),
		long offset);
156static time_t		time2(struct tm *tmp,
		struct tm * (*funcp)(const time_t *,
		long, struct tm*),
		long offset, int * okayp);
160static time_t		time2sub(struct tm *tmp,
		struct tm * (*funcp)(const time_t *,
		long, struct tm*),
		long offset, int * okayp, int do_norm_secs);
164static struct tm *	timesub(const time_t * timep, long offset,
		const struct state * sp, struct tm * tmp);
166static int		tmcomp(const struct tm * atmp,
		const struct tm * btmp);
168static time_t		transtime(time_t janfirst, int year,
		const struct rule * rulep, long offset);
170static int		typesequiv(const struct state * sp, int a, int b);
171static int		tzload(const char * name, struct state * sp,
		int doextend);
173static int		tzparse(const char * name, struct state * sp,
		int lastditch);

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

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


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

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

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

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

215static struct tm	tm;

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

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

result = (codep[0] & 0x80) ? ~0L : 0;
for (i = 0; i < 4; ++i)
result = (result << 8) | (codep[i] & 0xff);
return result;
230}

232static time_t
233detzcode64(const char *codep)
234{
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;
242}

244static void
245settzname(void)
246{
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';
}
289}

291static int
292differ_by_repeat(time_t t1, time_t t0)
293{
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);
297}

299static int
300tzload(const char *name, struct state *sp, int doextend)
301{
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;
char			fullname[PATH_MAX1024];

up = calloc(1, sizeof *up);
if (up == NULL((void *)0))
return -1;

sp->goback = sp->goahead = FALSE0;
if (name != NULL((void *)0) && issetugid() != 0) {
if ((name[0] == ':' && (strchr(name, '/') || strstr(name, ".."))) ||
    name[0] == '/' || strchr(name, '.'))
	name = NULL((void *)0);
}
if (name == NULL((void *)0) && (name = TZDEFAULT"/etc/localtime") == NULL((void *)0))
goto oops;

if (name[0] == ':')
++name;
if (name[0] != '/') {
if ((p = TZDIR"/usr/share/zoneinfo") == NULL((void *)0))
	goto oops;
if ((strlen(p) + strlen(name) + 1) >= sizeof fullname)
	goto oops;
strlcpy(fullname, p, sizeof fullname);
strlcat(fullname, "/", sizeof fullname);
strlcat(fullname, name, sizeof fullname);
name = fullname;
}
if ((fid = open(name, O_RDONLY0x0000)) == -1)
goto oops;

nread = read(fid, up->buf, sizeof up->buf);
if (close(fid) == -1 || nread <= 0)
goto oops;
for (stored = 4; stored <= 8; stored *= 2) {
int		ttisstdcnt;
int		ttisgmtcnt;

ttisstdcnt = (int) detzcode(up->tzhead.tzh_ttisstdcnt);
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;
520oops:
free(up);
return -1;
523}

525static int
526typesequiv(const struct state *sp, int a, int b)
527{
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;
545}

547static 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 }
550};

552static const int	year_lengths[2] = {
DAYSPERNYEAR365, DAYSPERLYEAR366
554};

556/*
557** Given a pointer into a time zone string, scan until a character that is not
558** a valid character in a zone name is found. Return a pointer to that
559** character.
560*/

562static const char *
563getzname(const char *strp)
564{
char	c;

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

573/*
574** Given a pointer into an extended time zone string, scan until the ending
575** delimiter of the zone name is located. Return a pointer to the delimiter.
576**
577** As with getzname above, the legal character set is actually quite
578** restricted, with other characters producing undefined results.
579** We don't do any checking here; checking is done later in common-case code.
580*/

582static const char *
583getqzname(const char *strp, const int delim)
584{
int	c;

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

592/*
593** Given a pointer into a time zone string, extract a number from that string.
594** Check that the number is within a specified range; if it is not, return
595** NULL.
596** Otherwise, return a pointer to the first character not part of the number.
597*/

599static const char *
600getnum(const char *strp, int *nump, int min, int max)
601{
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;
618}

620/*
621** Given a pointer into a time zone string, extract a number of seconds,
622** in hh[:mm[:ss]] form, from the string.
623** If any error occurs, return NULL.
624** Otherwise, return a pointer to the first character not part of the number
625** of seconds.
626*/

628static const char *
629getsecs(const char *strp, long *secsp)
630{
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;
659}

661/*
662** Given a pointer into a time zone string, extract an offset, in
663** [+-]hh[:mm[:ss]] form, from the string.
664** If any error occurs, return NULL.
665** Otherwise, return a pointer to the first character not part of the time.
666*/

668static const char *
669getoffset(const char *strp, long *offsetp)
670{
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;
684}

686/*
687** Given a pointer into a time zone string, extract a rule in the form
688** date[/time]. See POSIX section 8 for the format of "date" and "time".
689** If a valid rule is not found, return NULL.
690** Otherwise, return a pointer to the first character not part of the rule.
691*/

693static const char *
694getrule(const char *strp, struct rule *rulep)
695{
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;
739}

741/*
742** Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the
743** year, a rule, and the offset from UTC at the time that rule takes effect,
744** calculate the Epoch-relative time that rule takes effect.
745*/

747static time_t
748transtime(time_t janfirst, int year, const struct rule *rulep, long offset)
749{
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;
831}

833/*
834** Given a POSIX section 8-style TZ string, fill in the rule tables as
835** appropriate.
836*/

838static int
839tzparse(const char *name, struct state *sp, int lastditch)
840{
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;
1071}

1073static void
1074gmtload(struct state *sp)
1075{
if (tzload(gmt, sp, TRUE1) != 0)
(void) tzparse(gmt, sp, TRUE1);
1078}

1080static void
1081tzsetwall_basic(void)
1082{
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();
1097}

1099#ifndef STD_INSPIRED1
1100/*
1101** A non-static declaration of tzsetwall in a system header file
1102** may cause a warning about this upcoming static declaration...
1103*/
1104static
1105#endif /* !defined STD_INSPIRED */
1106void
1107tzsetwall(void)
1108{
_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);
1112}

1114static void
1115tzset_basic(void)
1116{
const char *	name;

name = getenv("TZ");
if (name == 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();
1154}

1156void
1157tzset(void)
1158{
_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);
1162}
1163DEF_WEAK(tzset)__asm__(".weak " "tzset" " ; " "tzset" " = " "_libc_tzset");

1165/*
1166** The easy way to behave "as if no library function calls" localtime
1167** is to not call it--so we drop its guts into "localsub", which can be
1168** freely called. (And no, the PANS doesn't require the above behavior--
1169** but it *is* desirable.)
1170**
1171** The unused offset argument is for the benefit of mktime variants.
1172*/

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

sp = lclptr;
if (sp == NULL((void *)0))
6
←
Assuming 'sp' is equal to NULL→
7
←
Taking true branch→
return gmtsub(timep, offset, tmp);
8
←
Calling 'gmtsub'→
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;
1262}

1264/*
1265** Re-entrant version of localtime.
1266*/

1268struct tm *
1269localtime_r(const time_t *timep, struct tm *p_tm)
1270{
_THREAD_PRIVATE_MUTEX_LOCK(lcl)do { if (_thread_cb.tc_tag_lock != ((void *)0)) _thread_cb.tc_tag_lock
(&(_thread_tagname_lcl)); } while (0);
2
←
Assuming field 'tc_tag_lock' is equal to null→
3
←
Taking false branch→
4
←
Loop condition is false.  Exiting loop→
tzset_basic();
p_tm = localsub(timep, 0L, p_tm);
5
←
Calling 'localsub'→
_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;
1276}
1277DEF_WEAK(localtime_r)__asm__(".weak " "localtime_r" " ; " "localtime_r" " = " "_libc_localtime_r"
);

1279struct tm *
1280localtime(const time_t *timep)
1281{
_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);
1288}
1289DEF_STRONG(localtime)__asm__(".global " "localtime" " ; " "localtime" " = " "_libc_localtime"
);

1291/*
1292** gmtsub is to gmtime as localsub is to localtime.
1293*/

1295static struct tm *
1296gmtsub(const time_t *timep, long offset, struct tm *tmp)
1297{
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);
9
←
Assuming field 'tc_tag_lock' is equal to null→
10
←
Taking false branch→
11
←
Loop condition is false.  Exiting loop→
if (!gmt_is_set) {
12
←
Assuming 'gmt_is_set' is not equal to 0→
13
←
Taking false branch→
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);
14
←
Assuming field 'tc_tag_unlock' is equal to null→
15
←
Taking false branch→
16
←
Loop condition is false.  Exiting loop→
result = timesub(timep, offset, gmtptr, tmp);
17
←
Calling 'timesub'→
/*
** 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;
1323}

1325/*
1326** Re-entrant version of gmtime.
1327*/

1329struct tm *
1330gmtime_r(const time_t *timep, struct tm *p_tm)
1331{
return gmtsub(timep, 0L, p_tm);
1333}
1334DEF_WEAK(gmtime_r)__asm__(".weak " "gmtime_r" " ; " "gmtime_r" " = " "_libc_gmtime_r"
);

1336struct tm *
1337gmtime(const time_t *timep)
1338{
_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);

1346}
1347DEF_WEAK(gmtime)__asm__(".weak " "gmtime" " ; " "gmtime" " = " "_libc_gmtime"
);

1349#ifdef STD_INSPIRED1

1351struct tm *
1352offtime(const time_t *timep, long offset)
1353{
return gmtsub(timep, offset, &tm);
1355}

1357#endif /* defined STD_INSPIRED */

1359/*
1360** Return the number of leap years through the end of the given year
1361** where, to make the math easy, the answer for year zero is defined as zero.
1362*/

1364static int
1365leaps_thru_end_of(int y)
1366{
return (y >= 0) ? (y / 4 - y / 100 + y / 400) :
-(leaps_thru_end_of(-(y + 1)) + 1);
1369}

1371static struct tm *
1372timesub(const time_t *timep, long offset, const struct state *sp, struct tm *tmp)
1373{
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;
18
←
Assuming 'sp' is not equal to NULL→
19
←
'?' condition is false→
while (--i >= 0) {
20
←
Assuming the condition is false→
21
←
Loop condition is false. Execution continues on line 1409→
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))]) {
22
←
Assuming 'tdays' is >= 0→
23
←
Assuming the condition is false→
24
←
Loop condition is false. Execution continues on line 1434→
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) {
25
←
Assuming 'rem' is >= 0→
26
←
Loop condition is false. Execution continues on line 1447→
rem += SECSPERDAY((long) (60 * 60) * 24);
--idays;
}
while (rem >= SECSPERDAY((long) (60 * 60) * 24)) {
27
←
Assuming the condition is false→
28
←
Loop condition is false. Execution continues on line 1451→
rem -= SECSPERDAY((long) (60 * 60) * 24);
++idays;
}
while (idays < 0) {
29
←
Assuming 'idays' is >= 0→
30
←
Loop condition is false. Execution continues on line 1456→
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))]) {
31
←
Assuming the condition is false→
32
←
Loop condition is false. Execution continues on line 1461→
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))
33
←
Calling 'increment_overflow'→
37
←
Returning from 'increment_overflow'→
38
←
Taking false branch→
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)
39
←
Assuming field 'tm_wday' is >= 0→
40
←
Taking false branch→
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))
41
←
Assuming the condition is true→
42
←
Loop condition is true.  Entering loop body→
43
←
Assuming the condition is true→
44
←
Loop condition is true.  Entering loop body→
45
←
The value 2 is assigned to 'mytm.tm_mon'→
46
←
The right operand of '>=' is a garbage value
idays -= ip[tmp->tm_mon];
tmp->tm_mday = (int) (idays + 1);
tmp->tm_isdst = 0;
tmp->tm_gmtoff = offset;
return tmp;
1492}

1494char *
1495ctime(const time_t *timep)
1496{
1497/*
1498** Section 4.12.3.2 of X3.159-1989 requires that
1499**	The ctime function converts the calendar time pointed to by timer
1500**	to local time in the form of a string. It is equivalent to
1501**		asctime(localtime(timer))
1502*/
return asctime(localtime(timep));
1504}

1506char *
1507ctime_r(const time_t *timep, char *buf)
1508{
struct tm	mytm;

return asctime_r(localtime_r(timep, &mytm), buf);
1
Calling 'localtime_r'→
1512}

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

1523#ifndef WRONG(-1)
1524#define WRONG(-1)	(-1)
1525#endif /* !defined WRONG */

1527/*
1528** Normalize logic courtesy Paul Eggert.
1529*/

1531static int
1532increment_overflow(int *ip, int j)
1533{
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 ((i33.1
'i' is >= 0
 >= 0) ? (j > INT_MAX2147483647 - i) : (j < INT_MIN(-2147483647 -1) - i))
34
←
'?' condition is true→
35
←
Taking false branch→
return TRUE1;
*ip += j;
return FALSE0;
36
←
Returning zero, which participates in a condition later→
1546}

1548static int
1549long_increment_overflow(long *lp, int m)
1550{
long const	l = *lp;

if ((l >= 0) ? (m > LONG_MAX9223372036854775807L - l) : (m < LONG_MIN(-9223372036854775807L -1L) - l))
return TRUE1;
*lp += m;
return FALSE0;
1557}

1559static int
1560normalize_overflow(int *tensptr, int *unitsptr, int base)
1561{
int	tensdelta;

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

1571static int
1572long_normalize_overflow(long *tensptr, int *unitsptr, int base)
1573{
int	tensdelta;

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

1583static int
1584tmcomp(const struct tm *atmp, const struct tm *btmp)
1585{
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;
1595}

1597static time_t
1598time2sub(struct tm *tmp, struct tm *(*funcp)(const time_t *, long, struct tm *),
  long offset, int *okayp, int do_norm_secs)
1600{
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);
}
1757label:
newt = t + saved_seconds;
if ((newt < t) != (saved_seconds < 0))
return WRONG(-1);
t = newt;
if ((*funcp)(&t, offset, tmp))
*okayp = TRUE1;
return t;
1765}

1767static time_t
1768time2(struct tm *tmp, struct tm * (*funcp)(const time_t *, long, struct tm *),
  long offset, int *okayp)
1770{
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);
1780}

1782static time_t
1783time1(struct tm *tmp, struct tm * (*funcp)(const time_t *, long, struct tm *),
  long offset)
1785{
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);
1803#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 */
1811#endif /* defined PCTS */
1812#ifndef PCTS1
if (okay || tmp->tm_isdst < 0)
return t;
1815#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);
1854}

1856time_t
1857mktime(struct tm *tmp)
1858{
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;
1866}
1867DEF_STRONG(mktime)__asm__(".global " "mktime" " ; " "mktime" " = " "_libc_mktime"
);

1869#ifdef STD_INSPIRED1

1871time_t
1872timelocal(struct tm *tmp)
1873{
if (tmp != NULL((void *)0))
tmp->tm_isdst = -1;	/* in case it wasn't initialized */
return mktime(tmp);
1877}

1879time_t
1880timegm(struct tm *tmp)
1881{
if (tmp != NULL((void *)0))
tmp->tm_isdst = 0;
return time1(tmp, gmtsub, 0L);
1885}

1887time_t
1888timeoff(struct tm *tmp, long offset)
1889{
if (tmp != NULL((void *)0))
tmp->tm_isdst = 0;
return time1(tmp, gmtsub, offset);
1893}

1895#endif /* defined STD_INSPIRED */

1897/*
1898** XXX--is the below the right way to conditionalize??
1899*/

1901#ifdef STD_INSPIRED1

1903/*
1904** IEEE Std 1003.1-1988 (POSIX) legislates that 536457599
1905** shall correspond to "Wed Dec 31 23:59:59 UTC 1986", which
1906** is not the case if we are accounting for leap seconds.
1907** So, we provide the following conversion routines for use
1908** when exchanging timestamps with POSIX conforming systems.
1909*/

1911static long
1912leapcorr(time_t *timep)
1913{
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;
1926}

1928time_t
1929time2posix(time_t t)
1930{
tzset();
return t - leapcorr(&t);
1933}

1935time_t
1936posix2time(time_t t)
1937{
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;
1966}

1968#endif /* defined STD_INSPIRED */