/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2010 Nexenta Systems, Inc.  All rights reserved.

 */

/*

 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1988 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 * A part of this file comes from public domain source, so

 * clarified as of June 5, 1996 by Arthur David Olson

 * ([email protected]).

 */

/*

 * localtime.c

 *

 * This file contains routines to convert struct tm to time_t and

 * back as well as adjust time values based on their timezone, which

 * is a local offset from GMT (Greenwich Mean Time).

 *

 * Many timezones actually consist of more than one offset from GMT.

 * The GMT offset that is considered the normal offset is referred

 * to as standard time.  The other offset is referred to as alternate

 * time, but is better known as daylight savings time or summer time.

 *

 * The current timezone for an application is derived from the TZ

 * environment variable either as defined in the environment or in

 * /etc/default/init.  As defined by IEEE 1003.1-1990 (POSIX), the

 * TZ variable can either be:

 *    :<characters>

 * or

 *    <std><offset1>[<dst>[<offset2>]][,<start>[/<time>],<end>[/<time>]

 *

 * <characters> is an implementation-defined string that somehow describes

 * a timezone.  The implementation-defined description of a timezone used

 * in Solaris is based on the public domain zoneinfo code available from

 * elsie.nci.nih.gov and a timezone that is specified in this way is

 * referred to as a zoneinfo timezone.  An example of this is ":US/Pacific".

 *

 * The precise definition of the second format can be found in POSIX,

 * but, basically, <std> is the abbreviation for the timezone in standard

 * (not daylight savings time), <offset1> is the standard offset from GMT,

 * <dst> is the abbreviation for the timezone in daylight savings time and

 * <offset2> is the daylight savings time offset from GMT.  The remainder

 * specifies when daylight savings time begins and ends.  A timezone

 * specified in this way is referred to as a POSIX timezone.  An example

 * of this is "PST7PDT".

 *

 * In Solaris, there is an extension to this.  If the timezone is not

 * preceded by a ":" and it does not parse as a POSIX timezone, then it

 * will be treated as a zoneinfo timezone.  Much usage of zoneinfo

 * timezones in Solaris is done without the leading ":".

 *

 * A zoneinfo timezone is a reference to a file that contains a set of

 * rules that describe the timezone.  In Solaris, the file is in

 * /usr/share/lib/zoneinfo.  The file is generated by zic(1M), based

 * on zoneinfo rules "source" files.  This is all described on the zic(1M)

 * man page.

 */

/*

 * Functions that are common to ctime(3C) and cftime(3C)

 */

#pragma weak _tzset = tzset

#include "lint.h"

#include "libc.h"

#include "tsd.h"

#include <stdarg.h>

#include <mtlib.h>

#include <sys/types.h>

#include <ctype.h>

#include <stdio.h>

#include <limits.h>

#include <sys/param.h>

#include <time.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

#include <tzfile.h>

#include <thread.h>

#include <synch.h>

#include <fcntl.h>

#include <errno.h>

#include <deflt.h>

#include <sys/stat.h>

#include <sys/mman.h>

/* JAN_01_1902 cast to (int) - negative number of seconds from 1970 */

#define	JAN_01_1902		(int)0x8017E880

#define	LEN_TZDIR		(sizeof (TZDIR) - 1)

#define	TIMEZONE		"/etc/default/init"

#define	TZSTRING		"TZ="

#define	HASHTABLE		31

#define	LEAPS_THRU_END_OF(y)	((y) / 4 - (y) / 100 + (y) / 400)

/* Days since 1/1/70 to 12/31/(1900 + Y - 1) */

#define	DAYS_SINCE_70(Y) (YR((Y)-1L) - YR(70-1))

#define	YR(X) /* Calc # days since 0 A.D. X = curr. yr - 1900 */ \

	((1900L + (X)) * 365L + (1900L + (X)) / 4L - \

	(1900L + (X)) / 100L + ((1900L + (X)) - 1600L) / 400L)

/*

 * The following macros are replacements for detzcode(), which has

 * been in the public domain versions of the localtime.c code for

 * a long time. The primatives supporting the CVTZCODE macro are

 * implemented differently for different endianness (ie. little

 * vs. big endian) out of necessity, to account for the different

 * byte ordering of the quantities being fetched.  Both versions

 * are substantially faster than the detzcode() macro.  The big

 * endian version is approx. 6.8x faster than detzcode(), the

 * little endian version is approximately 3x faster, due to the

 * extra shifting requiring to change byte order.  The micro

 * benchmarks used to compare were based on the SUNWSpro SC6.1

 * (and later) compilers.

 */

#if defined(__sparc) || defined(__sparcv9)  /* big endian */

#define	GET_LONG(p) \

	    *(uint_t *)(p)

#define	GET_SHORTS(p) \

	    *(ushort_t *)(p) << 16 |\

	    *(ushort_t *)((p) + 2)

#define	GET_CHARS(p) \

	    *(uchar_t *)(p) << 24 |\

	    *(uchar_t *)((p) + 1) << 16 |\

	    *(uchar_t *)((p) + 2) << 8  |\

	    *(uchar_t *)((p) + 3)

#else /* little endian */

#define	GET_BYTE(x) \

	    ((x) & 0xff)

#define	SWAP_BYTES(x) ((\

	    GET_BYTE(x) << 8) |\

	    GET_BYTE((x) >> 8))

#define	SWAP_WORDS(x) ((\

	    SWAP_BYTES(x) << 16) |\

	    SWAP_BYTES((x) >> 16))

#define	GET_LONG(p) \

	    SWAP_WORDS(*(uint_t *)(p))

#define	GET_SHORTS(p) \

	    SWAP_BYTES(*(ushort_t *)(p)) << 16 |\

	    SWAP_BYTES(*(ushort_t *)((p) + 2))

#define	GET_CHARS(p) \

	    GET_BYTE(*(uchar_t *)(p)) << 24 |\

	    GET_BYTE(*(uchar_t *)((p) + 1)) << 16 |\

	    GET_BYTE(*(uchar_t *)((p) + 2)) << 8 |\

	    GET_BYTE(*(uchar_t *)((p) + 3))

#endif

#define	IF_ALIGNED(ptr, byte_alignment) \

			!((uintptr_t)(ptr) & (byte_alignment - 1))

#define	CVTZCODE(p) (int)(\

	    IF_ALIGNED(p, 4) ? GET_LONG(p) :\

	    IF_ALIGNED(p, 2) ? GET_SHORTS(p) : GET_CHARS(p));\

	    p += 4;

#ifndef	FALSE

#define	FALSE	(0)

#endif

#ifndef	TRUE

#define	TRUE	(1)

#endif

extern	mutex_t		_time_lock;

extern const int	__lyday_to_month[];

extern const int	__yday_to_month[];

extern const int	__mon_lengths[2][MONS_PER_YEAR];

extern const int	__year_lengths[2];

const char	_tz_gmt[4] = "GMT";	/* "GMT"  */

const char	_tz_spaces[4] = "   ";	/* "   "  */

static const char	_posix_gmt0[5] = "GMT0";	/* "GMT0" */

typedef struct ttinfo {			/* Time type information */

	long		tt_gmtoff;	/* GMT offset in seconds */

	int		tt_isdst;	/* used to set tm_isdst */

	int		tt_abbrind;	/* abbreviation list index */

	int		tt_ttisstd;	/* TRUE if trans is std time */

	int		tt_ttisgmt;	/* TRUE if transition is GMT */

} ttinfo_t;

typedef struct lsinfo {			/* Leap second information */

	time_t		ls_trans;	/* transition time */

	long		ls_corr;	/* correction to apply */

} lsinfo_t;

typedef struct previnfo {		/* Info about *prev* trans */

	ttinfo_t	*std;		/* Most recent std type */

	ttinfo_t	*alt;		/* Most recent alt type */

} prev_t;

typedef enum {

	MON_WEEK_DOW,		/* Mm.n.d - month, week, day of week */

	JULIAN_DAY,		/* Jn - Julian day */

	DAY_OF_YEAR		/* n - day of year */

} posrule_type_t;

typedef struct {

	posrule_type_t	r_type;		/* type of rule */

	int		r_day;		/* day number of rule */

	int		r_week;		/* week number of rule */

	int		r_mon;		/* month number of rule */

	long		r_time;		/* transition time of rule */

} rule_t;

typedef struct {

	rule_t		*rules[2];

	long		offset[2];

	long long	rtime[2];

} posix_daylight_t;

/*

 * Note: ZONERULES_INVALID used for global curr_zonerules variable, but not

 * for zonerules field of state_t.

 */

typedef enum {

	ZONERULES_INVALID, POSIX, POSIX_USA, ZONEINFO

} zone_rules_t;

/*

 * The following members are allocated from the libc-internal malloc:

 *

 *	zonename

 *	chars

 */

typedef struct state {

	const char	*zonename;		/* Timezone */

	struct state	*next;			/* next state */

	zone_rules_t	zonerules;		/* Type of zone */

	int		daylight;		/* daylight global */

	long		default_timezone;	/* Def. timezone val */

	long		default_altzone;	/* Def. altzone val */

	const char	*default_tzname0;	/* Def tz..[0] val */

	const char	*default_tzname1;	/* Def tz..[1] val  */

	int		leapcnt;		/* # leap sec trans */

	int		timecnt;		/* # transitions */

	int		typecnt;		/* # zone types */

	int		charcnt;		/* # zone abbv. chars */

	char		*chars;			/* Zone abbv. chars */

	size_t		charsbuf_size;		/* malloc'ed buflen */

	prev_t		prev[TZ_MAX_TIMES];	/* Pv. trans info */

	time_t		ats[TZ_MAX_TIMES];	/* Trans.  times */

	uchar_t		types[TZ_MAX_TIMES];	/* Type indices */

	ttinfo_t	ttis[TZ_MAX_TYPES];	/* Zone types */

	lsinfo_t	lsis[TZ_MAX_LEAPS];	/* Leap sec trans */

	int		last_ats_idx;		/* last ats index */

	rule_t		start_rule;		/* For POSIX w/rules */

	rule_t		end_rule;		/* For POSIX w/rules */

} state_t;

typedef struct tznmlist {

	struct tznmlist *link;

	char	name[1];

} tznmlist_t;

static const char	*systemTZ;

static tznmlist_t	*systemTZrec;

static const char	*namecache;

static state_t		*tzcache[HASHTABLE];

#define	TZNMC_SZ	43

static tznmlist_t	*tznmhash[TZNMC_SZ];

static const char	*last_tzname[2];

static state_t		*lclzonep;

static struct tm	tm;		/* For non-reentrant use */

static int		is_in_dst;	/* Set if t is in DST */

static zone_rules_t	curr_zonerules = ZONERULES_INVALID;

static int		cached_year;	/* mktime() perf. enhancement */

static long long	cached_secs_since_1970;	/* mktime() perf. */

static int		year_is_cached = FALSE;	/* mktime() perf. */

#define	TZSYNC_FILE	"/var/run/tzsync"

static uint32_t		zoneinfo_seqno;

static uint32_t		zoneinfo_seqno_init = 1;

static uint32_t		*zoneinfo_seqadr = &zoneinfo_seqno_init;

#define	RELOAD_INFO()	(zoneinfo_seqno != *zoneinfo_seqadr)

#define	_2AM		(2 * SECS_PER_HOUR)

#define	FIRSTWEEK	1

#define	LASTWEEK	5

enum wks {

	_1st_week = 1,

	_2nd_week,

	_3rd_week,

	_4th_week,

	_Last_week

};

enum dwk {

	Sun,

	Mon,

	Tue,

	Wed,

	Thu,

	Fri,

	Sat

};

enum mth {

	Jan = 1,

	Feb,

	Mar,

	Apr,

	May,

	Jun,

	Jul,

	Aug,

	Sep,

	Oct,

	Nov,

	Dec

};

/*

 * The following table defines standard USA DST transitions

 * as they have been declared throughout history, disregarding

 * the legally sanctioned local variants.

 *

 * Note:  At some point, this table may be supplanted by

 * more popular 'posixrules' logic.

 */

typedef struct {

	int	s_year;

	int	e_year;

	rule_t	start;

	rule_t	end;

} __usa_rules_t;

static const __usa_rules_t	__usa_rules[] = {

	{

		2007, 2037,

		{ MON_WEEK_DOW, Sun, _2nd_week, Mar, _2AM },

		{ MON_WEEK_DOW, Sun, _1st_week, Nov, _2AM },

	},

	{

		1987, 2006,

		{ MON_WEEK_DOW, Sun, _1st_week,  Apr, _2AM },

		{ MON_WEEK_DOW, Sun, _Last_week, Oct, _2AM },

	},

	{

		1976, 1986,

		{ MON_WEEK_DOW, Sun, _Last_week, Apr, _2AM },

		{ MON_WEEK_DOW, Sun, _Last_week, Oct, _2AM },

	},

	{

		1975, 1975,

		{ MON_WEEK_DOW, Sun, _Last_week, Feb, _2AM },

		{ MON_WEEK_DOW, Sun, _Last_week, Oct, _2AM },

	},

	{

		1974, 1974,

		{ MON_WEEK_DOW, Sun, _1st_week,  Jan, _2AM },

		{ MON_WEEK_DOW, Sun, _Last_week, Nov, _2AM },

	},

	/*

	 * The entry below combines two previously separate entries for

	 * 1969-1973 and 1902-1968

	 */

	{

		1902, 1973,

		{ MON_WEEK_DOW, Sun, _Last_week, Apr, _2AM },

		{ MON_WEEK_DOW, Sun, _Last_week, Oct, _2AM },

	}

};

#define	MAX_RULE_TABLE	(sizeof (__usa_rules) / sizeof (__usa_rules_t) - 1)

/*

 * Prototypes for static functions.

 */

static const char *getsystemTZ(void);

static const char *getzname(const char *, int);

static const char *getnum(const char *, int *, int, int);

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

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

static const char *getrule(const char *, rule_t *, int);

static int	load_posixinfo(const char *, state_t *);

static int	load_zoneinfo(const char *, state_t *);

static void	load_posix_transitions(state_t *, long, long, zone_rules_t);

static void	adjust_posix_default(state_t *, long, long);

static void	*ltzset_u(time_t);

static struct tm *offtime_u(time_t, long, struct tm *);

static int	posix_check_dst(long long, state_t *);

static int	posix_daylight(long long *, int, posix_daylight_t *);

static void	set_zone_context(time_t);

static void	reload_counter(void);

static void	purge_zone_cache(void);

static void	set_tzname(const char **);

/*

 * definition of difftime

 *

 * This code assumes time_t is type long.  Note the difference of two

 * longs in absolute value is representable as an unsigned long.  So,

 * compute the absolute value of the difference, cast the result to

 * double and attach the sign back on.

 *

 * Note this code assumes 2's complement arithmetic.  The subtraction

 * operation may overflow when using signed operands, but when the

 * result is cast to unsigned long, it yields the desired value

 * (ie, the absolute value of the difference).  The cast to unsigned

 * long is done using pointers to avoid undefined behavior if casting

 * a negative value to unsigned.

 */

double

difftime(time_t time1, time_t time0)

{

	if (time1 < time0) {

		time0 -= time1;

		return (-(double)*(unsigned long *) &time0);

	} else {

		time1 -= time0;

		return ((double)*(unsigned long *) &time1);

	}

}

/*

 * Accepts a time_t, returns a tm struct based on it, with

 * no local timezone adjustment.

 *

 * This routine is the thread-safe variant of gmtime(), and

 * requires that the call provide the address of their own tm

 * struct.

 *

 * Locking is not done here because set_zone_context()

 * is not called, thus timezone, altzone, and tzname[] are not

 * accessed, no memory is allocated, and no common dynamic

 * data is accessed.

 *

 * See ctime(3C)

 */

struct tm *

gmtime_r(const time_t *timep, struct tm *p_tm)

{

	return (offtime_u((time_t)*timep, 0L, p_tm));

}

/*

 * Accepts a time_t, returns a tm struct based on it, with

 * no local timezone adjustment.

 *

 * This function is explicitly NOT THREAD-SAFE.  The standards

 * indicate it should provide its results in its own statically

 * allocated tm struct that gets overwritten. The thread-safe

 * variant is gmtime_r().  We make it mostly thread-safe by

 * allocating its buffer in thread-specific data.

 *

 * See ctime(3C)

 */

struct tm *

gmtime(const time_t *timep)

{

	struct tm *p_tm = tsdalloc(_T_STRUCT_TM, sizeof (struct tm), NULL);

	if (p_tm == NULL)	/* memory allocation failure */

		p_tm = &tm;	/* use static buffer and hope for the best */

	return (gmtime_r(timep, p_tm));

}

/*

 * This is the hashing function, based on the input timezone name.

 */

static int

get_hashid(const char *id)

{

	unsigned char	c;

	unsigned int	h;

	h = *id++;

	while ((c = *id++) != '\0')

		h += c;

	return ((int)(h % HASHTABLE));

}