/*	$OpenBSD: localtime.c,v 1.59 2016/09/19 12:48:21 millert Exp $ */

/*

** This file is in the public domain, so clarified as of

** 1996-06-05 by Arthur David Olson.

*/

/*

** Leap second handling from Bradley White.

** POSIX-style TZ environment variable handling from Guy Harris.

*/

#include <ctype.h>

#include <errno.h>

#include <fcntl.h>

#include <float.h>	/* for FLT_MAX and DBL_MAX */

#include <stdint.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "private.h"

#include "tzfile.h"

#include "thread_private.h"

#ifndef TZ_ABBR_MAX_LEN

#define TZ_ABBR_MAX_LEN	16

#endif /* !defined TZ_ABBR_MAX_LEN */

#ifndef TZ_ABBR_CHAR_SET

#define TZ_ABBR_CHAR_SET \

	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 :+-._"

#endif /* !defined TZ_ABBR_CHAR_SET */

#ifndef TZ_ABBR_ERR_CHAR

#define TZ_ABBR_ERR_CHAR	'_'

#endif /* !defined TZ_ABBR_ERR_CHAR */

#ifndef WILDABBR

/*

** Someone might make incorrect use of a time zone abbreviation:

**	1.	They might reference tzname[0] before calling tzset (explicitly

**		or implicitly).

**	2.	They might reference tzname[1] before calling tzset (explicitly

**		or implicitly).

**	3.	They might reference tzname[1] after setting to a time zone

**		in which Daylight Saving Time is never observed.

**	4.	They might reference tzname[0] after setting to a time zone

**		in which Standard Time is never observed.

**	5.	They might reference tm.TM_ZONE after calling offtime.

** What's best to do in the above cases is open to debate;

** for now, we just set things up so that in any of the five cases

** WILDABBR is used. Another possibility: initialize tzname[0] to the

** string "tzname[0] used before set", and similarly for the other cases.

** And another: initialize tzname[0] to "ERA", with an explanation in the

** manual page of what this "time zone abbreviation" means (doing this so

** that tzname[0] has the "normal" length of three characters).

*/

#define WILDABBR	"   "

#endif /* !defined WILDABBR */

static char		wildabbr[] = WILDABBR;

static const char	gmt[] = "GMT";

/*

** The DST rules to use if TZ has no rules and we can't load TZDEFRULES.

** We default to US rules as of 1999-08-17.

** POSIX 1003.1 section 8.1.1 says that the default DST rules are

** implementation dependent; for historical reasons, US rules are a

** common default.

*/

#ifndef TZDEFRULESTRING

#define TZDEFRULESTRING ",M4.1.0,M10.5.0"

#endif /* !defined TZDEFDST */

struct 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 */

};

struct lsinfo {				/* leap second information */

	time_t		ls_trans;	/* transition time */

	long		ls_corr;	/* correction to apply */

};

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

#ifdef TZNAME_MAX

#define MY_TZNAME_MAX	TZNAME_MAX

#endif /* defined TZNAME_MAX */

#ifndef TZNAME_MAX

#define MY_TZNAME_MAX	255

#endif /* !defined TZNAME_MAX */

struct state {

	int		leapcnt;

	int		timecnt;

	int		typecnt;

	int		charcnt;

	int		goback;

	int		goahead;

	time_t		ats[TZ_MAX_TIMES];

	unsigned char	types[TZ_MAX_TIMES];

	struct ttinfo	ttis[TZ_MAX_TYPES];

	char		chars[BIGGEST(BIGGEST(TZ_MAX_CHARS + 1, sizeof gmt),

			    (2 * (MY_TZNAME_MAX + 1)))];

	struct lsinfo	lsis[TZ_MAX_LEAPS];

};

struct 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 */

};

#define JULIAN_DAY		0	/* Jn - Julian day */

#define DAY_OF_YEAR		1	/* n - day of year */

#define MONTH_NTH_DAY_OF_WEEK	2	/* Mm.n.d - month, week, day of week */

/*

** Prototypes for static functions.

*/

static long		detzcode(const char * codep);

static time_t		detzcode64(const char * codep);

static int		differ_by_repeat(time_t t1, time_t t0);

static const char *	getzname(const char * strp);

static const char *	getqzname(const char * strp, const int delim);

static const char *	getnum(const char * strp, int * nump, int min,

				int max);

static const char *	getsecs(const char * strp, long * secsp);

static const char *	getoffset(const char * strp, long * offsetp);

static const char *	getrule(const char * strp, struct rule * rulep);

static void		gmtload(struct state * sp);

static struct tm *	gmtsub(const time_t * timep, long offset,

				struct tm * tmp);

static struct tm *	localsub(const time_t * timep, long offset,

				struct tm * tmp);

static int		increment_overflow(int * number, int delta);

static int		leaps_thru_end_of(int y);

static int		long_increment_overflow(long * number, int delta);

static int		long_normalize_overflow(long * tensptr,

				int * unitsptr, int base);

static int		normalize_overflow(int * tensptr, int * unitsptr,

				int base);

static void		settzname(void);

static time_t		time1(struct tm * tmp,

				struct tm * (*funcp)(const time_t *,

				long, struct tm *),

				long offset);

static time_t		time2(struct tm *tmp,

				struct tm * (*funcp)(const time_t *,

				long, struct tm*),

				long offset, int * okayp);

static time_t		time2sub(struct tm *tmp,

				struct tm * (*funcp)(const time_t *,

				long, struct tm*),

				long offset, int * okayp, int do_norm_secs);

static struct tm *	timesub(const time_t * timep, long offset,

				const struct state * sp, struct tm * tmp);

static int		tmcomp(const struct tm * atmp,

				const struct tm * btmp);

static time_t		transtime(time_t janfirst, int year,

				const struct rule * rulep, long offset);

static int		typesequiv(const struct state * sp, int a, int b);

static int		tzload(const char * name, struct state * sp,

				int doextend);

static int		tzparse(const char * name, struct state * sp,

				int lastditch);

#ifdef STD_INSPIRED

struct tm	*offtime(const time_t *, long);

time_t		time2posix(time_t);

time_t		posix2time(time_t);

PROTO_DEPRECATED(offtime);

PROTO_DEPRECATED(time2posix);

PROTO_DEPRECATED(posix2time);

#endif

static struct state *	lclptr;

static struct state *	gmtptr;

#ifndef TZ_STRLEN_MAX

#define TZ_STRLEN_MAX 255

#endif /* !defined TZ_STRLEN_MAX */

static char		lcl_TZname[TZ_STRLEN_MAX + 1];

static int		lcl_is_set;

static int		gmt_is_set;

_THREAD_PRIVATE_MUTEX(lcl);

_THREAD_PRIVATE_MUTEX(gmt);

char *			tzname[2] = {

	wildabbr,

	wildabbr

};

#if 0

DEF_WEAK(tzname);

#endif

/*

** Section 4.12.3 of X3.159-1989 requires that

**	Except for the strftime function, these functions [asctime,

**	ctime, gmtime, localtime] return values in one of two static

**	objects: a broken-down time structure and an array of char.

** Thanks to Paul Eggert for noting this.

*/

static struct tm	tm;

#ifdef USG_COMPAT

long			timezone = 0;

int			daylight = 0;

#endif /* defined USG_COMPAT */

#ifdef ALTZONE

time_t			altzone = 0;

#endif /* defined ALTZONE */

static long

detzcode(const char *codep)

{

	long	result;

	int	i;

}

static time_t

detzcode64(const char *codep)

{

	time_t	result;

	int	i;

}

static void

settzname(void)

{

	int			i;

#ifdef USG_COMPAT

#endif /* defined USG_COMPAT */

#ifdef ALTZONE

	altzone = 0;

#endif /* defined ALTZONE */

	}

	/*

	** And to get the latest zone names into tzname. . .

	*/

#ifdef USG_COMPAT

#endif /* defined USG_COMPAT */

#ifdef ALTZONE

		if (ttisp->tt_isdst)

			altzone = -(ttisp->tt_gmtoff);

#endif /* defined ALTZONE */

	}

	/*

	** Finally, scrub the abbreviations.

	** First, replace bogus characters.

	*/

	}

	/*

	** Second, truncate long abbreviations.

	*/

	}

}

static int

differ_by_repeat(time_t t1, time_t t0)

{

	if (TYPE_BIT(time_t) - 1 < SECSPERREPEAT_BITS)

		return 0;

}

static int

tzload(const char *name, struct state *sp, int doextend)

{

	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_TIMES];

	} u_t;

	u_t *			up;

	}

		goto oops;

		if ((p = TZDIR) == NULL)

			goto oops;

			goto oops;

		name = fullname;

	}

		goto oops;

		goto oops;

		int		ttisstdcnt;

		int		ttisgmtcnt;

		    ttisgmtcnt)			/* ttisgmts */

		}

		}

			struct ttinfo *	ttisp;

		}

			struct lsinfo *	lsisp;

		}

			struct ttinfo *	ttisp;

			else {

			}

		}

			struct ttinfo *	ttisp;

			else {

			}

		}

		/*

		** 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).

		*/

				++i;

				/*

				** Ignore the end (easy).

				*/

			}

		/*

		** If this is an old file, we're done.

		*/

		/*

		** If this is a narrow integer time_t system, we're done.

		*/

	}

		int	result;

			i = 0;

			}

		}

	}

			}

		}

			}

		}

	}

oops:

}

static int

typesequiv(const struct state *sp, int a, int b)

{

	int	result;

	else {

	}

}

static const int	mon_lengths[2][MONSPERYEAR] = {

	{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },

	{ 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

};

static const int	year_lengths[2] = {

	DAYSPERNYEAR, DAYSPERLYEAR

};

/*

** Given a pointer into a time zone string, scan until a character that is not

** a valid character in a zone name is found. Return a pointer to that

** character.

*/

static const char *

getzname(const char *strp)

{

	char	c;

}

/*

** Given a pointer into an extended time zone string, scan until the ending

** delimiter of the zone name is located. Return a pointer to the delimiter.

**

** As with getzname above, the legal character set is actually quite

** restricted, with other characters producing undefined results.

** We don't do any checking here; checking is done later in common-case code.

*/

static const char *

getqzname(const char *strp, const int delim)

{

	int	c;

}

/*

** Given a pointer into a time zone string, extract a number from that string.

** Check that the number is within a specified range; if it is not, return

** NULL.

** Otherwise, return a pointer to the first character not part of the number.

*/

static const char *

getnum(const char *strp, int *nump, int min, int max)

{

	char	c;

	int	num;

	num = 0;

}

/*

** Given a pointer into a time zone string, extract a number of seconds,

** in hh[:mm[:ss]] form, from the string.

** If any error occurs, return NULL.

** Otherwise, return a pointer to the first character not part of the number

** of seconds.

*/

static const char *

getsecs(const char *strp, long *secsp)

{

	/*

	** `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''.

	*/

			/* `SECSPERMIN' allows for leap seconds. */

		}

	}

}

/*

** Given a pointer into a time zone string, extract an offset, in

** [+-]hh[:mm[:ss]] form, from the string.

** If any error occurs, return NULL.

** Otherwise, return a pointer to the first character not part of the time.

*/

static const char *

getoffset(const char *strp, long *offsetp)

{

	int	neg = 0;

		neg = 1;

}

/*

** Given a pointer into a time zone string, extract a rule in the form

** date[/time]. See POSIX section 8 for the format of "date" and "time".

** If a valid rule is not found, return NULL.

** Otherwise, return a pointer to the first character not part of the rule.

*/

static const char *

getrule(const char *strp, struct rule *rulep)

{

		/*

		** Julian day.

		*/

		/*

		** Month, week, day.

		*/

		/*

		** Day of year.

		*/

	} else

		/*

		** Time specified.

		*/

}

/*

** Given the Epoch-relative time of January 1, 00:00:00 UTC, in a year, the

** year, a rule, and the offset from UTC at the time that rule takes effect,

** calculate the Epoch-relative time that rule takes effect.

*/

static time_t

transtime(time_t janfirst, int year, const struct rule *rulep, long offset)

{

	int	leapyear;

	time_t	value;

	int	i;

	int		d, m1, yy0, yy1, yy2, dow;

	value = 0;

	case JULIAN_DAY:

		/*

		** 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.

		*/

		break;

	case DAY_OF_YEAR:

		/*

		** n - day of year.

		** Just add SECSPERDAY times the day number to the time of

		** January 1, midnight, to get the day.

		*/

	case MONTH_NTH_DAY_OF_WEEK:

		/*

		** Mm.n.d - nth "dth day" of month m.

		*/

		value = janfirst;

		/*

		** Use Zeller's Congruence to get day-of-week of first day of

		** month.

		*/

		/*

		** "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.

		*/

				break;

			d += DAYSPERWEEK;

		}

		/*

		** "d" is the day-of-month (zero-origin) of the day we want.

		*/

	}

	/*

	** "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.

	*/

}

/*

** Given a POSIX section 8-style TZ string, fill in the rule tables as

** appropriate.

*/

static int

tzparse(const char *name, struct state *sp, int lastditch)

{

	const char *			stdname;

	const char *			dstname;

	size_t				stdlen;

	size_t				dstlen;

	time_t *		atp;

	unsigned char *	typep;

	char *			cp;

	int			load_result;

	static struct ttinfo		zttinfo;

	dstname = NULL;

	stdname = name;

			stdname = name;

		}

	}

			dstname = name;

		}

		} else

			int		year;

			time_t		janfirst;

			time_t		starttime;

			time_t		endtime;

			/*

			** Two transitions per year, from EPOCH_YEAR forward.

			*/

			janfirst = 0;

			    	time_t	newfirst;

				}

				newfirst = janfirst;

				    SECSPERDAY;

				janfirst = newfirst;

			}

			long	theirstdoffset;

			long	theirdstoffset;

			long	theiroffset;

			int	isdst;

			int	i;

			int	j;

			/*

			** Initial values of theirstdoffset and theirdstoffset.

			*/

			theirstdoffset = 0;