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