1 /*

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

     3 ** 1996-06-05 by Arthur David Olson (arthur_david_olson@nih.gov).

     4 

     5 ** © Portions Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. 

     6 */

     7 

     8 #include <sys/cdefs.h>

     9 #ifndef lint

    10 #ifndef NOID

    11 static char	elsieid[] __unused = "@(#)localtime.c	7.78";

    12 #endif /* !defined NOID */

    13 #endif /* !defined lint */

    14 __FBSDID("$FreeBSD: src/lib/libc/stdtime/localtime.c,v 1.40 2004/08/24 00:15:37 peter Exp $");

    15 

    16 /*

    17 ** Leap second handling from Bradley White (bww@k.gp.cs.cmu.edu).

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

    19 ** (guy@auspex.com).

    20 */

    21 #include <time.h>

    22 

    23 /*LINTLIBRARY*/

    24 #include <unistd.h>

    25 #include "namespace.h"

    26 #include <sys/types.h>  

    27 #include <pthread.h>

    28 #include "private.h"

    29 #include "un-namespace.h"

    30 #include "tzfile.h"

    31 #include <fcntl.h>

    32 #include <sys/stat.h>

    33 #include "libc_private.h"

    34 #include "common_def.h"

    35 #include <wchar.h>

    36 #include "timefuncs.h"

    37 

    38 #if (defined(__SYMBIAN32__) && (defined(__WINSCW__) || defined(__WINS__)))

    39 #include "libc_wsd_defs.h"

    40 #endif

    41 

    42 #define	_MUTEX_LOCK(x)		if (__isthreaded) _pthread_mutex_lock(x)

    43 #define	_MUTEX_UNLOCK(x)	if (__isthreaded) _pthread_mutex_unlock(x)

    44 

    45 /*

    46 ** SunOS 4.1.1 headers lack O_BINARY.

    47 */

    48 

    49 #ifdef O_BINARY

    50 #define OPEN_MODE	(O_RDONLY | O_BINARY)

    51 #endif /* defined O_BINARY */

    52 #ifndef O_BINARY

    53 #define OPEN_MODE	O_RDONLY

    54 #endif /* !defined O_BINARY */

    55 

    56 #ifndef WILDABBR

    57 /*

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

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

    60 **		or implicitly).

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

    62 **		or implicitly).

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

    64 **		in which Daylight Saving Time is never observed.

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

    66 **		in which Standard Time is never observed.

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

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

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

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

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

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

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

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

    75 */

    76 #define WILDABBR	"   "

    77 #endif /* !defined WILDABBR */

    78 

    79 #ifdef __SYMBIAN32__

    80 extern int GetStdOffset(void);

    81 extern int GetIsDst(void);

    82 #endif //__SYMBIAN32__

    83 

    84 #ifdef __SYMBIAN32__

    85 #ifndef EMULATOR

    86 

    87 static char		wildabbr[] = "WILDABBR";

    88 #else //EMULATOR

    89 

    90 GET_STATIC_ARRAY_FROM_TLS(wildabbr, char)

    91 #define wildabbr (GET_WSD_VAR_NAME(wildabbr, s)())

    92 #endif //EMULATOR

    93 #else

    94 static char		wildabbr[] = "WILDABBR";

    95 #endif //__SYMBIAN32__

    96 

    97 /*

    98  * In June 2004 it was decided UTC was a more appropriate default time

    99  * zone than GMT.

   100  */

   101 

   102 #ifdef __SYMBIAN32__

   103 #if !(defined(EMULATOR))

   104 static const char	gmt[] = "UTC";

   105 #endif //EMULATOR

   106 #else

   107 static const char	gmt[] = "UTC";

   108 #endif //__SYMBIAN32__

   109 

   110 /*

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

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

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

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

   115 ** common default.

   116 */

   117 #ifndef TZDEFRULESTRING

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

   119 #endif /* !defined TZDEFDST */

   120 

   121 #ifdef __SYMBIAN32__

   122 #ifndef EMULATOR

   123 struct ttinfo {				/* time type information */

   124 	long		tt_gmtoff;	/* UTC offset in seconds */

   125 	int		tt_isdst;	/* used to set tm_isdst */

   126 	int		tt_abbrind;	/* abbreviation list index */

   127 	int		tt_ttisstd;	/* TRUE if transition is std time */

   128 	int		tt_ttisgmt;	/* TRUE if transition is UTC */

   129 };

   130 

   131 struct lsinfo {				/* leap second information */

   132 	time_t		ls_trans;	/* transition time */

   133 	long		ls_corr;	/* correction to apply */

   134 };

   135 #endif //EMULATOR

   136 #else

   137 struct ttinfo {				/* time type information */

   138 	long		tt_gmtoff;	/* UTC offset in seconds */

   139 	int		tt_isdst;	/* used to set tm_isdst */

   140 	int		tt_abbrind;	/* abbreviation list index */

   141 	int		tt_ttisstd;	/* TRUE if transition is std time */

   142 	int		tt_ttisgmt;	/* TRUE if transition is UTC */

   143 };

   144 

   145 struct lsinfo {				/* leap second information */

   146 	time_t		ls_trans;	/* transition time */

   147 	long		ls_corr;	/* correction to apply */

   148 };

   149 #endif //__SYMBIAN32__

   150 

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

   152 

   153 #ifdef TZNAME_MAX

   154 #define MY_TZNAME_MAX	TZNAME_MAX

   155 #endif /* defined TZNAME_MAX */

   156 #ifndef TZNAME_MAX

   157 #define MY_TZNAME_MAX	255

   158 #endif /* !defined TZNAME_MAX */

   159 

   160 #ifdef __SYMBIAN32__

   161 #ifndef EMULATOR

   162 struct state {

   163 	int		leapcnt;

   164 	int		timecnt;

   165 	int		typecnt;

   166 	int		charcnt;

   167 	time_t		ats[TZ_MAX_TIMES];

   168 	unsigned char	types[TZ_MAX_TIMES];

   169 	struct ttinfo	ttis[TZ_MAX_TYPES];

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

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

   172 	struct lsinfo	lsis[TZ_MAX_LEAPS];

   173 };

   174 #endif //EMULATOR

   175 #else

   176 struct state {

   177 	int		leapcnt;

   178 	int		timecnt;

   179 	int		typecnt;

   180 	int		charcnt;

   181 	time_t		ats[TZ_MAX_TIMES];

   182 	unsigned char	types[TZ_MAX_TIMES];

   183 	struct ttinfo	ttis[TZ_MAX_TYPES];

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

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

   186 	struct lsinfo	lsis[TZ_MAX_LEAPS];

   187 };

   188 #endif //__SYMBIAN32__

   189 

   190 struct rule {

   191 	int		r_type;		/* type of rule--see below */

   192 	int		r_day;		/* day number of rule */

   193 	int		r_week;		/* week number of rule */

   194 	int		r_mon;		/* month number of rule */

   195 	long		r_time;		/* transition time of rule */

   196 };

   197 

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

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

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

   201 

   202 /*

   203 ** Prototypes for static functions.

   204 */

   205 

   206 #ifndef __SYMBIAN32__

   207 static long		detzcode(const char * codep);

   208 #endif //__SYMBIAN32__

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

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

   211 				int max);

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

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

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

   215 static void		gmtload(struct state * sp);

   216 static void		gmtsub(const time_t * timep, long offset,

   217 				struct tm * tmp);

   218 static void		localsub(const time_t * timep, long offset,

   219 				struct tm * tmp);

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

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

   222 				int base);

   223 static void		settzname(void);

   224 static time_t		time1(struct tm * tmp,

   225 				void(*funcp) (const time_t *,

   226 				long, struct tm *),

   227 				long offset);

   228 static time_t		time2(struct tm *tmp,

   229 				void(*funcp) (const time_t *,

   230 				long, struct tm*),

   231 				long offset, int * okayp);

   232 static time_t		time2sub(struct tm *tmp,

   233 				void(*funcp) (const time_t *,

   234 				long, struct tm*),

   235 				long offset, int * okayp, int do_norm_secs);

   236 static void		timesub(const time_t * timep, long offset,

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

   238 static int		tmcomp(const struct tm * atmp,

   239 				const struct tm * btmp);

   240 static time_t		transtime(time_t janfirst, int year,

   241 				const struct rule * rulep, long offset);

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

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

   244 				int lastditch);

   245 

   246 #ifdef ALL_STATE

   247 

   248 #ifdef __SYMBIAN32__

   249 #ifndef EMULATOR

   250 

   251 static struct state *	lclptr;

   252 static struct state *	gmtptr;

   253 #else //EMULATOR

   254 

   255 GET_STATIC_VAR_FROM_TLS(lclptr, state *)

   256 GET_STATIC_VAR_FROM_TLS(gmtptr, state *)

   257 

   258 #define lclptr (*GET_WSD_VAR_NAME(lclptr, s)())

   259 #define gmtptr (*GET_WSD_VAR_NAME(gmtptr, s)())

   260 #endif //EMULATOR

   261 #else //__SYMBIAN32__

   262 static struct state *	lclptr;

   263 static struct state *	gmtptr;

   264 #endif //__SYMBIAN32__

   265 

   266 #endif /* defined ALL_STATE */

   267 

   268 #ifndef ALL_STATE

   269 

   270 #ifdef __SYMBIAN32__

   271 #ifndef EMULATOR

   272 

   273 static struct state	lclmem;

   274 static struct state	gmtmem;

   275 #else //EMULATOR

   276 

   277 GET_STATIC_VAR_FROM_TLS(lclmem, struct state)

   278 GET_STATIC_VAR_FROM_TLS(gmtmem, struct state)

   279 #define lclmem (*GET_WSD_VAR_NAME(lclmem, s)())

   280 #define gmtmem (*GET_WSD_VAR_NAME(gmtmem, s)())

   281 #endif //EMULATOR

   282 #else //__SYMBIAN32__

   283 static struct state	lclmem;

   284 static struct state	gmtmem;

   285 #endif //__SYMBIAN32__

   286 

   287 #define lclptr		(&lclmem)

   288 #define gmtptr		(&gmtmem)

   289 #endif /* State Farm */

   290 

   291 #ifndef TZ_STRLEN_MAX

   292 #define TZ_STRLEN_MAX 255

   293 #endif /* !defined TZ_STRLEN_MAX */

   294 

   295 #ifdef __SYMBIAN32__

   296 #ifndef EMULATOR

   297 

   298 static char		lcl_TZname[TZ_STRLEN_MAX + 1];

   299 static int		lcl_is_set;

   300 static int		gmt_is_set;

   301 static pthread_mutex_t	lcl_mutex = PTHREAD_MUTEX_INITIALIZER;

   302 static pthread_mutex_t	gmt_mutex = PTHREAD_MUTEX_INITIALIZER;

   303 

   304 char **_tzname = NULL;

   305 #else //EMULATOR

   306 

   307 GET_STATIC_ARRAY_FROM_TLS(lcl_TZname, char)

   308 GET_STATIC_VAR_FROM_TLS(lcl_is_set, int)

   309 GET_STATIC_VAR_FROM_TLS(gmt_is_set, int)

   310 GET_STATIC_VAR_FROM_TLS(lcl_mutex, pthread_mutex_t)

   311 GET_STATIC_VAR_FROM_TLS(gmt_mutex, pthread_mutex_t)

   312 

   313 

   314 #define lcl_TZname (GET_WSD_VAR_NAME(lcl_TZname, s)())

   315 #define lcl_is_set	    (*GET_WSD_VAR_NAME(lcl_is_set, s)())

   316 #define gmt_is_set  (*GET_WSD_VAR_NAME(gmt_is_set, s)())

   317 #define lcl_mutex    (*GET_WSD_VAR_NAME(lcl_mutex, s)())

   318 #define gmt_mutex  (*GET_WSD_VAR_NAME(gmt_mutex, s)())

   319 

   320 #endif //EMULATOR

   321 #else //__SYMBIAN32__

   322 

   323 static char		lcl_TZname[TZ_STRLEN_MAX + 1];

   324 static int		lcl_is_set;

   325 static int		gmt_is_set;

   326 static pthread_mutex_t	lcl_mutex = PTHREAD_MUTEX_INITIALIZER;

   327 static pthread_mutex_t	gmt_mutex = PTHREAD_MUTEX_INITIALIZER;

   328 

   329 char *			tzname[2] = {

   330 	wildabbr,

   331 	wildabbr

   332 };

   333 #endif //__SYMBIAN32__

   334 

   335 /*

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

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

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

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

   340 ** Thanks to Paul Eggert (eggert@twinsun.com) for noting this.

   341 */

   342 #ifdef __SYMBIAN32__

   343 #ifndef EMULATOR

   344 

   345 struct tm	stm;

   346 #else //EMULATOR

   347 

   348 GET_GLOBAL_VAR_FROM_TLS(stm, struct tm)

   349 #define stm (*GET_WSD_VAR_NAME(stm, g)())

   350 #endif //EMULATOR

   351 #else //__SYMBIAN32__

   352 static struct tm	tm;

   353 #endif //__SYMBIAN32__

   354 

   355 #ifdef USG_COMPAT

   356 

   357 #ifdef __SYMBIAN32__

   358 #ifndef EMULATOR

   359 

   360 time_t			timezone = 0;

   361 int			daylight = 0;

   362 #else //EMULATOR

   363 

   364 GET_GLOBAL_VAR_FROM_TLS(timezone, time_t)

   365 GET_GLOBAL_VAR_FROM_TLS(daylight, int)

   366 

   367 #define timezone (*GET_WSD_VAR_NAME(timezone, g)())

   368 #define daylight  (*GET_WSD_VAR_NAME(daylight, g)())

   369 #endif //EMULATOR

   370 #else //__SYMBIAN32__

   371 time_t			timezone = 0;

   372 int			daylight = 0;

   373 #endif //__SYMBIAN32__

   374 

   375 #endif /* defined USG_COMPAT */

   376 

   377 #ifdef ALTZONE

   378 

   379 #ifdef __SYMBIAN32__

   380 #ifndef EMULATOR

   381 

   382 time_t			altzone = 0;

   383 #else //EMULATOR

   384 

   385 GET_GLOBAL_VAR_FROM_TLS(altzone, time_t)

   386 #define altzone (*GET_WSD_VAR_NAME(altzone, g)())

   387 #endif //EMULATOR

   388 #else  //__SYMBIAN32__

   389 time_t			altzone = 0;

   390 #endif //__SYMBIAN32__

   391 

   392 #endif /* defined ALTZONE */

   393 

   394 #ifdef __SYMBIAN32__

   395 #ifdef EMULATOR

   396 

   397 GET_STATIC_VAR_FROM_TLS(localtime_key, pthread_key_t)

   398 GET_STATIC_VAR_FROM_TLS(localtime_mutex, pthread_mutex_t)

   399 GET_STATIC_VAR_FROM_TLS(gmtime_key, pthread_key_t)

   400 GET_STATIC_VAR_FROM_TLS(gmtime_mutex, pthread_mutex_t)

   401 

   402 #define localtime_mutex (*GET_WSD_VAR_NAME(localtime_mutex, s)())

   403 #define localtime_key (*GET_WSD_VAR_NAME(localtime_key, s)())

   404 #define gmtime_mutex (*GET_WSD_VAR_NAME(gmtime_mutex, s)())

   405 #define gmtime_key (*GET_WSD_VAR_NAME(gmtime_key, s)())

   406 

   407 #endif //EMULATOR

   408 #endif //__SYMBIAN32__

   409 

   410 #if !defined(__SYMBIAN32__) || defined(__SYMBIAN_COMPILE_UNUSED__)

   411 static long

   412 detzcode(codep)

   413 const char * const	codep;

   414 {

   415 	long	result;

   416 	int	i;

   417 

   418 	result = (codep[0] & 0x80) ? ~0L : 0L;

   419 	for (i = 0; i < 4; ++i)

   420 		result = (result << 8) | (codep[i] & 0xff);

   421 	return result;

   422 }

   423 #endif //if defined(__SYMBIAN32__) || defined (__SYMBIAN_COMPILE_UNUSED__)

   424 

   425 static void

   426 settzname(void)

   427 {

   428 	struct state * 	sp = lclptr;

   429 	int			i;

   430 

   431 	tzname[0] = wildabbr;

   432 	tzname[1] = wildabbr;

   433 #ifdef USG_COMPAT

   434 	daylight = 0;

   435 	timezone = 0;

   436 #endif /* defined USG_COMPAT */

   437 #ifdef ALTZONE

   438 	altzone = 0;

   439 #endif /* defined ALTZONE */

   440 #ifdef ALL_STATE

   441 	if (sp == NULL) {

   442 		tzname[0] = tzname[1] = gmt;

   443 		return;

   444 	}

   445 #endif /* defined ALL_STATE */

   446 	for (i = 0; i < sp->typecnt; ++i) {

   447 		const struct ttinfo * const	ttisp = &sp->ttis[i];

   448 

   449 		tzname[ttisp->tt_isdst] =

   450 			&sp->chars[ttisp->tt_abbrind];

   451 #ifdef USG_COMPAT

   452 		if (ttisp->tt_isdst)

   453 			daylight = 1;

   454 		if (i == 0 || !ttisp->tt_isdst)

   455 			timezone = -(ttisp->tt_gmtoff);

   456 #endif /* defined USG_COMPAT */

   457 #ifdef ALTZONE

   458 		if (i == 0 || ttisp->tt_isdst)

   459 			altzone = -(ttisp->tt_gmtoff);

   460 #endif /* defined ALTZONE */

   461 	}

   462 	/*

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

   464 	*/

   465 	for (i = 0; i < sp->timecnt; ++i) {

   466 		const struct ttinfo * const	ttisp =

   467 							&sp->ttis[

   468 								sp->types[i]];

   469 

   470 		tzname[ttisp->tt_isdst] =

   471 			&sp->chars[ttisp->tt_abbrind];

   472 	}

   473 }

   474 

   475 static int

   476 tzload(name, sp)

   477 const char *		name;

   478 struct state * const	sp;

   479 {

   480 #ifndef __SYMBIAN32__

   481 	const char *	p;

   482 	int		i;

   483 	int		fid;

   484 #else//__SYMBIAN32__	

   485 	if(sp) { }//dummy implementation

   486 #endif//__SYMBIAN32__

   487 	/* XXX The following is from OpenBSD, and I'm not sure it is correct */

   488 	if (name != NULL && issetugid() != 0)

   489 		if ((name[0] == ':' && name[1] == '/') || 

   490 		    name[0] == '/' || strchr(name, '.'))

   491 			name = NULL;

   492 	if (name == NULL && (name = TZDEFAULT) == NULL)

   493 		return -1;

   494 	

   495 	#ifdef __SYMBIAN32__

   496 		return -1; //We are doing this for the simple reason that these files

   497 				   //do not exist in the Symbian environment and we really dont

   498 				   //need to try accessing them

   499 	#else //__SYMBIAN32__

   500 	

   501 	{

   502 		int	doaccess;

   503 		struct stat	stab;

   504 		/*

   505 		** Section 4.9.1 of the C standard says that

   506 		** "FILENAME_MAX expands to an integral constant expression

   507 		** that is the size needed for an array of char large enough

   508 		** to hold the longest file name string that the implementation

   509 		** guarantees can be opened."

   510 		*/

   511 		char		fullname[FILENAME_MAX + 1];

   512 

   513 		if (name[0] == ':')

   514 			++name;

   515 		doaccess = name[0] == '/';

   516 		if (!doaccess) {

   517 			if ((p = TZDIR) == NULL)

   518 				return -1;

   519 			if ((strlen(p) + 1 + strlen(name) + 1) >= sizeof fullname)

   520 				return -1;

   521 			(void) strcpy(fullname, p);

   522 			(void) strcat(fullname, "/");

   523 			(void) strcat(fullname, name);

   524 			/*

   525 			** Set doaccess if '.' (as in "../") shows up in name.

   526 			*/

   527 			if (strchr(name, '.') != NULL)

   528 				doaccess = TRUE;

   529 			name = fullname;

   530 		}

   531 		if (doaccess && access(name, R_OK) != 0)

   532 		     	return -1;

   533 		if ((fid = _open(name, OPEN_MODE)) == -1)

   534 			return -1;

   535 		if ((_fstat(fid, &stab) < 0) || !S_ISREG(stab.st_mode)) {

   536 			_close(fid);

   537 			return -1;

   538 		}

   539 	}

   540 	{

   541 		struct tzhead *	tzhp;

   542 		union {

   543 			struct tzhead	tzhead;

   544 			char		buf[sizeof *sp + sizeof *tzhp];

   545 		} u;

   546 		int		ttisstdcnt;

   547 		int		ttisgmtcnt;

   548 

   549 		i = _read(fid, u.buf, sizeof u.buf);

   550 		if (_close(fid) != 0)

   551 			return -1;

   552 		ttisstdcnt = (int) detzcode(u.tzhead.tzh_ttisstdcnt);

   553 		ttisgmtcnt = (int) detzcode(u.tzhead.tzh_ttisgmtcnt);

   554 		sp->leapcnt = (int) detzcode(u.tzhead.tzh_leapcnt);

   555 		sp->timecnt = (int) detzcode(u.tzhead.tzh_timecnt);

   556 		sp->typecnt = (int) detzcode(u.tzhead.tzh_typecnt);

   557 		sp->charcnt = (int) detzcode(u.tzhead.tzh_charcnt);

   558 		p = u.tzhead.tzh_charcnt + sizeof u.tzhead.tzh_charcnt;

   559 		if (sp->leapcnt < 0 || sp->leapcnt > TZ_MAX_LEAPS ||

   560 			sp->typecnt <= 0 || sp->typecnt > TZ_MAX_TYPES ||

   561 			sp->timecnt < 0 || sp->timecnt > TZ_MAX_TIMES ||

   562 			sp->charcnt < 0 || sp->charcnt > TZ_MAX_CHARS ||

   563 			(ttisstdcnt != sp->typecnt && ttisstdcnt != 0) ||

   564 			(ttisgmtcnt != sp->typecnt && ttisgmtcnt != 0))

   565 				return -1;

   566 		if (i - (p - u.buf) < sp->timecnt * 4 +	/* ats */

   567 			sp->timecnt +			/* types */

   568 			sp->typecnt * (4 + 2) +		/* ttinfos */

   569 			sp->charcnt +			/* chars */

   570 			sp->leapcnt * (4 + 4) +		/* lsinfos */

   571 			ttisstdcnt +			/* ttisstds */

   572 			ttisgmtcnt)			/* ttisgmts */

   573 				return -1;

   574 		for (i = 0; i < sp->timecnt; ++i) {

   575 			sp->ats[i] = detzcode(p);

   576 			p += 4;

   577 		}

   578 		for (i = 0; i < sp->timecnt; ++i) {

   579 			sp->types[i] = (unsigned char) *p++;

   580 			if (sp->types[i] >= sp->typecnt)

   581 				return -1;

   582 		}

   583 		for (i = 0; i < sp->typecnt; ++i) {

   584 			struct ttinfo *	ttisp;

   585 

   586 			ttisp = &sp->ttis[i];

   587 			ttisp->tt_gmtoff = detzcode(p);

   588 			p += 4;

   589 			ttisp->tt_isdst = (unsigned char) *p++;

   590 			if (ttisp->tt_isdst != 0 && ttisp->tt_isdst != 1)

   591 				return -1;

   592 			ttisp->tt_abbrind = (unsigned char) *p++;

   593 			if (ttisp->tt_abbrind < 0 ||

   594 				ttisp->tt_abbrind > sp->charcnt)

   595 					return -1;

   596 		}

   597 		for (i = 0; i < sp->charcnt; ++i)

   598 			sp->chars[i] = *p++;

   599 		sp->chars[i] = '\0';	/* ensure '\0' at end */

   600 		for (i = 0; i < sp->leapcnt; ++i) {

   601 			struct lsinfo *	lsisp;

   602 

   603 			lsisp = &sp->lsis[i];

   604 			lsisp->ls_trans = detzcode(p);

   605 			p += 4;

   606 			lsisp->ls_corr = detzcode(p);

   607 			p += 4;

   608 		}

   609 		for (i = 0; i < sp->typecnt; ++i) {

   610 			struct ttinfo *	ttisp;

   611 

   612 			ttisp = &sp->ttis[i];

   613 			if (ttisstdcnt == 0)

   614 				ttisp->tt_ttisstd = FALSE;

   615 			else {

   616 				ttisp->tt_ttisstd = *p++;

   617 				if (ttisp->tt_ttisstd != TRUE &&

   618 					ttisp->tt_ttisstd != FALSE)

   619 						return -1;

   620 			}

   621 		}

   622 		for (i = 0; i < sp->typecnt; ++i) {

   623 			struct ttinfo *	ttisp;

   624 

   625 			ttisp = &sp->ttis[i];

   626 			if (ttisgmtcnt == 0)

   627 				ttisp->tt_ttisgmt = FALSE;

   628 			else {

   629 				ttisp->tt_ttisgmt = *p++;

   630 				if (ttisp->tt_ttisgmt != TRUE &&

   631 					ttisp->tt_ttisgmt != FALSE)

   632 						return -1;

   633 			}

   634 		}

   635 	}

   636 #endif //__SYMBIAN32__

   637 	return 0;

   638 }

   639 

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

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

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

   643 };

   644 

   645 static const int	year_lengths[2] = {

   646 	DAYSPERNYEAR, DAYSPERLYEAR

   647 };

   648 

   649 /*

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

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

   652 ** character.

   653 */

   654 

   655 static const char *

   656 getzname(strp)

   657 const char *	strp;

   658 {

   659 	char	c;

   660 

   661 	while ((c = *strp) != '\0' && !is_digit(c) && c != ',' && c != '-' &&

   662 		c != '+')

   663 			++strp;

   664 	return strp;

   665 }

   666 

   667 /*

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

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

   670 ** NULL.

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

   672 */

   673 

   674 static const char *

   675 getnum(strp, nump, min, max)

   676 const char *	strp;

   677 int * const		nump;

   678 const int		min;

   679 const int		max;

   680 {

   681 	char	c;

   682 	int	num;

   683 

   684 	if (strp == NULL || !is_digit(c = *strp))

   685 		return NULL;

   686 	num = 0;

   687 	do {

   688 		num = num * 10 + (c - '0');

   689 		if (num > max)

   690 			return NULL;	/* illegal value */

   691 		c = *++strp;

   692 	} while (is_digit(c));

   693 	if (num < min)

   694 		return NULL;		/* illegal value */

   695 	*nump = num;

   696 	return strp;

   697 }

   698 

   699 /*

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

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

   702 ** If any error occurs, return NULL.

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

   704 ** of seconds.

   705 */

   706 

   707 static const char *

   708 getsecs(strp, secsp)

   709 const char *	strp;

   710 long * const		secsp;

   711 {

   712 	int	num;

   713 

   714 	/*

   715 	** `HOURSPERDAY * DAYSPERWEEK - 1' allows quasi-Posix rules like

   716 	** "M10.4.6/26", which does not conform to Posix,

   717 	** but which specifies the equivalent of

   718 	** ``02:00 on the first Sunday on or after 23 Oct''.

   719 	*/

   720 	strp = getnum(strp, &num, 0, HOURSPERDAY * DAYSPERWEEK - 1);

   721 	if (strp == NULL)

   722 		return NULL;

   723 	*secsp = num * (long) SECSPERHOUR;

   724 	if (*strp == ':') {

   725 		++strp;

   726 		strp = getnum(strp, &num, 0, MINSPERHOUR - 1);

   727 		if (strp == NULL)

   728 			return NULL;

   729 		*secsp += num * SECSPERMIN;

   730 		if (*strp == ':') {

   731 			++strp;

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

   733 			strp = getnum(strp, &num, 0, SECSPERMIN);

   734 			if (strp == NULL)

   735 				return NULL;

   736 			*secsp += num;

   737 		}

   738 	}

   739 	return strp;

   740 }

   741 

   742 /*

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

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

   745 ** If any error occurs, return NULL.

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

   747 */

   748 

   749 static const char *

   750 getoffset(strp, offsetp)

   751 const char *	strp;

   752 long * const		offsetp;

   753 {

   754 	int	neg = 0;

   755 

   756 	if (*strp == '-') {

   757 		neg = 1;

   758 		++strp;

   759 	} else if (*strp == '+')

   760 		++strp;

   761 	strp = getsecs(strp, offsetp);

   762 	if (strp == NULL)

   763 		return NULL;		/* illegal time */

   764 	if (neg)

   765 		*offsetp = -*offsetp;

   766 	return strp;

   767 }

   768 

   769 /*

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

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

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

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

   774 */

   775 

   776 static const char *

   777 getrule(strp, rulep)

   778 const char *			strp;

   779 struct rule * const	rulep;

   780 {

   781 	if (*strp == 'J') {

   782 		/*

   783 		** Julian day.

   784 		*/

   785 		rulep->r_type = JULIAN_DAY;

   786 		++strp;

   787 		strp = getnum(strp, &rulep->r_day, 1, DAYSPERNYEAR);

   788 	} else if (*strp == 'M') {

   789 		/*

   790 		** Month, week, day.

   791 		*/

   792 		rulep->r_type = MONTH_NTH_DAY_OF_WEEK;

   793 		++strp;

   794 		strp = getnum(strp, &rulep->r_mon, 1, MONSPERYEAR);

   795 		if (strp == NULL)

   796 			return NULL;

   797 		if (*strp++ != '.')

   798 			return NULL;

   799 		strp = getnum(strp, &rulep->r_week, 1, 5);

   800 		if (strp == NULL)

   801 			return NULL;

   802 		if (*strp++ != '.')

   803 			return NULL;

   804 		strp = getnum(strp, &rulep->r_day, 0, DAYSPERWEEK - 1);

   805 	} else if (is_digit(*strp)) {

   806 		/*

   807 		** Day of year.

   808 		*/

   809 		rulep->r_type = DAY_OF_YEAR;

   810 		strp = getnum(strp, &rulep->r_day, 0, DAYSPERLYEAR - 1);

   811 	} else	return NULL;		/* invalid format */

   812 	if (strp == NULL)

   813 		return NULL;

   814 	if (*strp == '/') {

   815 		/*

   816 		** Time specified.

   817 		*/

   818 		++strp;

   819 		strp = getsecs(strp, &rulep->r_time);

   820 	} else	rulep->r_time = 2 * SECSPERHOUR;	/* default = 2:00:00 */

   821 	return strp;

   822 }

   823 

   824 /*

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

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

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

   828 */

   829 

   830 static time_t

   831 transtime(janfirst, year, rulep, offset)

   832 const time_t				janfirst;

   833 const int				year;

   834 const struct rule * const	rulep;

   835 const long				offset;

   836 {

   837 	int	leapyear;

   838 	time_t	value;

   839 	int	i;

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

   841 

   842 	INITIALIZE(value);

   843 	leapyear = isleap(year);

   844 	switch (rulep->r_type) {

   845 

   846 	case JULIAN_DAY:

   847 		/*

   848 		** Jn - Julian day, 1 == January 1, 60 == March 1 even in leap

   849 		** years.

   850 		** In non-leap years, or if the day number is 59 or less, just

   851 		** add SECSPERDAY times the day number-1 to the time of

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

   853 		*/

   854 		value = janfirst + (rulep->r_day - 1) * SECSPERDAY;

   855 		if (leapyear && rulep->r_day >= 60)

   856 			value += SECSPERDAY;

   857 		break;

   858 

   859 	case DAY_OF_YEAR:

   860 		/*

   861 		** n - day of year.

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

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

   864 		*/

   865 		value = janfirst + rulep->r_day * SECSPERDAY;

   866 		break;

   867 

   868 	case MONTH_NTH_DAY_OF_WEEK:

   869 		/*

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

   871 		*/

   872 		value = janfirst;

   873 		for (i = 0; i < rulep->r_mon - 1; ++i)

   874 			value += mon_lengths[leapyear][i] * SECSPERDAY;

   875 

   876 		/*

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

   878 		** month.

   879 		*/

   880 		m1 = (rulep->r_mon + 9) % 12 + 1;

   881 		yy0 = (rulep->r_mon <= 2) ? (year - 1) : year;

   882 		yy1 = yy0 / 100;

   883 		yy2 = yy0 % 100;

   884 		dow = ((26 * m1 - 2) / 10 +

   885 			1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;

   886 		if (dow < 0)

   887 			dow += DAYSPERWEEK;

   888 

   889 		/*

   890 		** "dow" is the day-of-week of the first day of the month.  Get

   891 		** the day-of-month (zero-origin) of the first "dow" day of the

   892 		** month.

   893 		*/

   894 		d = rulep->r_day - dow;

   895 		if (d < 0)

   896 			d += DAYSPERWEEK;

   897 		for (i = 1; i < rulep->r_week; ++i) {

   898 			if (d + DAYSPERWEEK >=

   899 				mon_lengths[leapyear][rulep->r_mon - 1])

   900 					break;

   901 			d += DAYSPERWEEK;

   902 		}

   903 

   904 		/*

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

   906 		*/

   907 		value += d * SECSPERDAY;

   908 		break;

   909 	}

   910 

   911 	/*

   912 	** "value" is the Epoch-relative time of 00:00:00 UTC on the day in

   913 	** question.  To get the Epoch-relative time of the specified local

   914 	** time on that day, add the transition time and the current offset

   915 	** from UTC.

   916 	*/

   917 	return value + rulep->r_time + offset;

   918 }

   919 

   920 /*

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

   922 ** appropriate.

   923 */

   924 

   925 static int

   926 tzparse(name, sp, lastditch)

   927 const char *			name;

   928 struct state * const	sp;

   929 const int			lastditch;

   930 {

   931 	const char *			stdname;

   932 	const char *			dstname;

   933 	size_t				stdlen;

   934 	size_t				dstlen;

   935 	long				stdoffset;

   936 	long				dstoffset;

   937 	time_t *		atp;

   938 	unsigned char *	typep;

   939 	char *			cp;

   940 	int			load_result;

   941 

   942 	INITIALIZE(dstname);

   943 	stdname = name;

   944 	if (lastditch) {

   945 		stdlen = strlen(name);	/* length of standard zone name */

   946 		name += stdlen;

   947 		if (stdlen >= sizeof sp->chars)

   948 			stdlen = (sizeof sp->chars) - 1;

   949 		#ifndef __SYMBIAN32__

   950 		stdoffset = 0;

   951 		#else	//__SYMBIAN32__

   952 		stdoffset = (-1)*GetStdOffset();

   953 		#endif	//__SYMBIAN32__

   954 	} else {

   955 		name = getzname(name);

   956 		stdlen = name - stdname;

   957 		if (stdlen < 3)

   958 			return -1;

   959 		if (*name == '\0')

   960 			return -1;	/* was "stdoffset = 0;" */

   961 		else {

   962 			name = getoffset(name, &stdoffset);

   963 			if (name == NULL)

   964 				return -1;

   965 		}

   966 	}

   967 	load_result = tzload(TZDEFRULES, sp);

   968 	if (load_result != 0)

   969 		sp->leapcnt = 0;		/* so, we're off a little */

   970 	if (*name != '\0') {

   971 		dstname = name;

   972 		name = getzname(name);

   973 		dstlen = name - dstname;	/* length of DST zone name */

   974 		if (dstlen < 3)

   975 			return -1;

   976 		if (*name != '\0' && *name != ',' && *name != ';') {

   977 			name = getoffset(name, &dstoffset);

   978 			if (name == NULL)

   979 				return -1;

   980 		} else	dstoffset = stdoffset - SECSPERHOUR;

   981 		if (*name == '\0' && load_result != 0)

   982 			name = TZDEFRULESTRING;

   983 		if (*name == ',' || *name == ';') {

   984 			struct rule	start;

   985 			struct rule	end;

   986 			int	year;

   987 			time_t	janfirst;

   988 			time_t		starttime;

   989 			time_t		endtime;

   990 

   991 			++name;

   992 			if ((name = getrule(name, &start)) == NULL)

   993 				return -1;

   994 			if (*name++ != ',')

   995 				return -1;

   996 			if ((name = getrule(name, &end)) == NULL)

   997 				return -1;

   998 			if (*name != '\0')

   999 				return -1;

  1000 			sp->typecnt = 2;	/* standard time and DST */

  1001 			/*

  1002 			** Two transitions per year, from EPOCH_YEAR to 2037.

  1003 			*/

  1004 			sp->timecnt = 2 * (2037 - EPOCH_YEAR + 1);

  1005 			if (sp->timecnt > TZ_MAX_TIMES)

  1006 				return -1;

  1007 			sp->ttis[0].tt_gmtoff = -dstoffset;

  1008 			sp->ttis[0].tt_isdst = 1;

  1009 			sp->ttis[0].tt_abbrind = stdlen + 1;

  1010 			sp->ttis[1].tt_gmtoff = -stdoffset;

  1011 			sp->ttis[1].tt_isdst = 0;

  1012 			sp->ttis[1].tt_abbrind = 0;

  1013 			atp = sp->ats;

  1014 			typep = sp->types;

  1015 			janfirst = 0;

  1016 			for (year = EPOCH_YEAR; year <= 2037; ++year) {

  1017 				starttime = transtime(janfirst, year, &start,

  1018 					stdoffset);

  1019 				endtime = transtime(janfirst, year, &end,

  1020 					dstoffset);

  1021 				if (starttime > endtime) {

  1022 					*atp++ = endtime;

  1023 					*typep++ = 1;	/* DST ends */

  1024 					*atp++ = starttime;

  1025 					*typep++ = 0;	/* DST begins */

  1026 				} else {

  1027 					*atp++ = starttime;

  1028 					*typep++ = 0;	/* DST begins */

  1029 					*atp++ = endtime;

  1030 					*typep++ = 1;	/* DST ends */

  1031 				}

  1032 				janfirst += year_lengths[isleap(year)] *

  1033 					SECSPERDAY;

  1034 			}

  1035 		} else {

  1036 			long	theirstdoffset;

  1037 			long	theirdstoffset;

  1038 			long	theiroffset;

  1039 			int	isdst;

  1040 			int	i;

  1041 			int	j;

  1042 

  1043 			if (*name != '\0')

  1044 				return -1;

  1045 			/*

  1046 			** Initial values of theirstdoffset and theirdstoffset.

  1047 			*/

  1048 			theirstdoffset = 0;

  1049 			for (i = 0; i < sp->timecnt; ++i) {

  1050 				j = sp->types[i];

  1051 				if (!sp->ttis[j].tt_isdst) {

  1052 					theirstdoffset =

  1053 						-sp->ttis[j].tt_gmtoff;

  1054 					break;

  1055 				}

  1056 			}

  1057 			theirdstoffset = 0;

  1058 			for (i = 0; i < sp->timecnt; ++i) {

  1059 				j = sp->types[i];

  1060 				if (sp->ttis[j].tt_isdst) {

  1061 					theirdstoffset =

  1062 						-sp->ttis[j].tt_gmtoff;

  1063 					break;

  1064 				}

  1065 			}

  1066 			/*

  1067 			** Initially we're assumed to be in standard time.

  1068 			*/

  1069 			isdst = FALSE;

  1070 			theiroffset = theirstdoffset;

  1071 			/*

  1072 			** Now juggle transition times and types

  1073 			** tracking offsets as you do.

  1074 			*/

  1075 			for (i = 0; i < sp->timecnt; ++i) {

  1076 				j = sp->types[i];

  1077 				sp->types[i] = sp->ttis[j].tt_isdst;

  1078 				if (sp->ttis[j].tt_ttisgmt) {

  1079 					/* No adjustment to transition time */

  1080 				} else {

  1081 					/*

  1082 					** If summer time is in effect, and the

  1083 					** transition time was not specified as

  1084 					** standard time, add the summer time

  1085 					** offset to the transition time;

  1086 					** otherwise, add the standard time

  1087 					** offset to the transition time.

  1088 					*/

  1089 					/*

  1090 					** Transitions from DST to DDST

  1091 					** will effectively disappear since

  1092 					** POSIX provides for only one DST

  1093 					** offset.

  1094 					*/

  1095 					if (isdst && !sp->ttis[j].tt_ttisstd) {

  1096 						sp->ats[i] += dstoffset -

  1097 							theirdstoffset;

  1098 					} else {

  1099 						sp->ats[i] += stdoffset -

  1100 							theirstdoffset;

  1101 					}

  1102 				}

  1103 				theiroffset = -sp->ttis[j].tt_gmtoff;

  1104 				if (sp->ttis[j].tt_isdst)

  1105 					theirdstoffset = theiroffset;

  1106 				else	theirstdoffset = theiroffset;

  1107 			}

  1108 			/*

  1109 			** Finally, fill in ttis.

  1110 			** ttisstd and ttisgmt need not be handled.

  1111 			*/

  1112 			sp->ttis[0].tt_gmtoff = -stdoffset;

  1113 			sp->ttis[0].tt_isdst = FALSE;

  1114 			sp->ttis[0].tt_abbrind = 0;

  1115 			sp->ttis[1].tt_gmtoff = -dstoffset;

  1116 			sp->ttis[1].tt_isdst = TRUE;

  1117 			sp->ttis[1].tt_abbrind = stdlen + 1;

  1118 			sp->typecnt = 2;

  1119 		}

  1120 	} else {

  1121 		dstlen = 0;

  1122 		sp->typecnt = 1;		/* only standard time */

  1123 		sp->timecnt = 0;

  1124 		sp->ttis[0].tt_gmtoff = -stdoffset;

  1125 		#ifndef __SYMBIAN32__

  1126 		sp->ttis[0].tt_isdst = 0;

  1127 		#else	//__SYMBIAN32__

  1128 		sp->ttis[0].tt_isdst = GetIsDst();

  1129 		#endif	//__SYMBIAN32__

  1130 		sp->ttis[0].tt_abbrind = 0;

  1131 	}

  1132 	sp->charcnt = stdlen + 1;

  1133 	if (dstlen != 0)

  1134 		sp->charcnt += dstlen + 1;