path: root/private/crt32/time/tzset.c

/***
*tzset.c - set timezone information and see if we're in daylight time
*
*	Copyright (c) 1985-1993, Microsoft Corporation. All rights reserved.
*
*Purpose:
*	defines _tzset() - set timezone and daylight saving time vars
*
*Revision History:
*	03-??-84  RLB	initial version
*	03-26-86  TC	added minus capability to time difference w.r.t GMT
*	03-27-86  TC	fixed daylight davings time calculation, off by a day
*			error
*	12-03-86  SKS	daylight savings time is different starting april 1987
*			Fixed off-by-1 errors when either Apr 30 or Oct 31 is
*			Sat. Simplified leap year check: this works for
*			1970-2099 only!
*	11-19-87  SKS	Add __tzset() which calls tzset only the first time
*			Made _isindst() a near procedure
*	11-25-87  WAJ	Added calls to _lock and _unlock
*	12-11-87  JCR	Added "_LOAD_DS" to declaration
*	01-27-88  SKS	Made _isindst() and _dtoxtime() are no longer near (for
*			QC)
*	05-24-88  PHG	Merged DLL and normal versions
*	03-20-90  GJF	Made calling type _CALLTYPE1, added #include
*			<cruntime.h>, removed #include <register.h>, removed
*			some leftover 16-bit support and fixed the copyright.
*			Also, cleaned up the formatting a bit.
*	03-23-90  GJF	Made static functions _CALLTYPE4.
*	07-30-90  SBM	Added void to empty function arg lists to create
*			prototypes
*	10-04-90  GJF	New-style function declarators.
*	01-21-91  GJF	ANSI naming.
*	08-10-92  PBS	Posix Support (TZ stuff).
*	03-30-93  GJF	Ported C8-16 version to Win32.
*	06-28-93  GJF	Limited support for system's notion of time zone
*			in Windows NT.
*	07-15-93  GJF	Resurrected __tzset().
*
*******************************************************************************/

#include <cruntime.h>
#include <ctype.h>
#include <ctime.h>
#include <time.h>
#include <stdlib.h>
#include <internal.h>
#ifdef _POSIX_
#include <limits.h>
#else
#include <os2dll.h>
#include <windows.h>
#endif
#include <string.h>

#ifndef _POSIX_
/*
 * Pointer to a saved copy of the TZ value obtained in the previous call
 * to tzset() set (if any).
 */
static char * lastTZ = NULL;
#endif


/***
*void tzset() - sets timezone information and calc if in daylight time
*
*Purpose:
*	Sets the timezone information from the TZ environment variable
*	and then sets _timezone, _daylight, and _tzname. If we're in daylight
*	time is automatically calculated.
*
*Entry:
*	None, reads TZ environment variable.
*
*Exit:
*	sets _daylight, _timezone, and _tzname global vars, no return value
*
*Exceptions:
*
*******************************************************************************/

#ifndef _POSIX_

#ifdef MTHREAD
static void _CRTAPI3 _tzset_lk(void);
#else
#define _tzset_lk _tzset
#endif

void _CRTAPI1 __tzset(void)
{
	static int first_time;

	if ( !first_time ) {

	    _mlock( _TIME_LOCK );

	    if ( !first_time ) {
		_tzset_lk();
		first_time++;
	    }

	    _munlock(_TIME_LOCK );

	}
}


#ifdef MTHREAD	/* multi-thread; define both tzset and _tzset_lk */
void _CRTAPI1 _tzset (
	void
	)
{
	_mlock( _TIME_LOCK );

	_tzset_lk();

	_munlock( _TIME_LOCK );
}


static void _CRTAPI3 _tzset_lk (

#else	/* non multi-thread; only define tzset */

void _CRTAPI1 _tzset (

#endif	/* rejoin common code */

	void
	)
{
	REG1 char *TZ;
	REG2 int negdiff = 0;

	_mlock(_ENV_LOCK);

	/*
	 * Fetch the value of the TZ environment variable.
	 */
	if ( (TZ = _getenv_lk("TZ")) == NULL ) {
	    /*
	     * If there is no TZ environment variable, try to use the
	     * time zone information from the system.
	     */
	    TIME_ZONE_INFORMATION tzinfo;

	    if ( GetTimeZoneInformation( &tzinfo ) != 0xffffffff ) {
		/*
		 * Derive _timezone value from Bias and StandardBias fields.
		 */
		_timezone = tzinfo.Bias * 60L;

		if ( tzinfo.StandardDate.wMonth != 0 )
		    _timezone += (tzinfo.StandardBias * 60L);

		/*
		 * Check to see if there is a daylight time bias. If so, we
		 * ASSUME it is USA daylight saving time (that is all we
		 * support for rev. one).
		 */
		if ( (tzinfo.DaylightDate.wMonth != 0) &&
		     (tzinfo.DaylightBias != 0) )
		    _daylight = 1;
		else
		    _daylight = 0;

		/*
		 * Remove the default names, but don't try to determine
		 * suitable replacements (NT does not enforce any standard
		 * or convention for timezone naming).
		 */
		*_tzname[0] = '\0';
		*_tzname[1] = '\0';
	    }

	    /*
	     * Time zone information is unavailable, just return.
	     */
	    _munlock(_ENV_LOCK);
	    return;
	}


	if ( (*TZ == '\0') || ((lastTZ != NULL) && (strcmp(TZ, lastTZ) == 0)) )
	{
	    /*
	     * Either TZ is NULL, pointing to '\0', or is the unchanged
	     * from a earlier call (to this function). In any case, there
	     * is no work to do, so just return
	     */
	    _munlock(_ENV_LOCK);
	    return;
	}

	/*
	 * Update lastTZ
	 */
        if (lastTZ != NULL) {
            free(lastTZ);
        }
	lastTZ = strdup(TZ);

	_munlock(_ENV_LOCK);

	/*
	 * Process TZ value and update _tzname, _timezone and _daylight.
	 */

	strncpy(_tzname[0], TZ, 3);

	/*
	 * time difference is of the form:
	 *
	 *	[+|-]hh[:mm[:ss]]
	 *
	 * check minus sign first.
	 */
	if ( *(TZ += 3) == '-' ) {
		negdiff++;
		TZ++;
	}

	/*
	 * process, then skip over, the hours
	 */
	_timezone = atol(TZ) * 3600L;

	while ( (*TZ == '+') || ((*TZ >= '0') && (*TZ <= '9')) ) TZ++;

	/*
	 * check if minutes were specified
	 */
	if ( *TZ == ':' ) {
	    /*
	     * process, then skip over, the minutes
	     */
	    _timezone += atol(++TZ) * 60L;
	    while ( (*TZ >= '0') && (*TZ <= '9') ) TZ++;

	    /*
	     * check if seconds were specified
	     */
	    if ( *TZ == ':' ) {
		/*
		 * process, then skip over, the seconds
		 */
		_timezone += atol(++TZ);
		while ( (*TZ >= '0') && (*TZ <= '9') ) TZ++;
	    }
	}

	if ( negdiff )
		_timezone = -_timezone;

	/*
	 * finally, check for a DST zone suffix
	 */
	if ( _daylight = *TZ )
	    strncpy(_tzname[1], TZ, 3);
	else
	    *_tzname[1] = '\0';

}


/***
*int _isindst(tb) - determine if broken-down time falls in DST
*
*Purpose:
*	Determine if the given broken-down time falls within DST. Only
*	modern, summer-time DST is handled (USA, post 1967).
*
*	This is the rule for years before 1987:
*	a time is in DST iff it is on or after 02:00:00 on the last Sunday
*	in April and before 01:00:00 on the last Sunday in October.
*	This is the rule for years starting with 1987:
*	a time is in DST iff it is on or after 02:00:00 on the first Sunday
*	in April and before 01:00:00 on the last Sunday in October.
*
*Entry:
*	struct tm *tb - structure holding broken-down time value
*
*Exit:
*	1, if time represented is in DST
*	0, otherwise
*
*******************************************************************************/

int _CRTAPI1 _isindst (
	REG1 struct tm *tb
	)
{
	int mdays;
	REG2 int yr;
	int critsun;

	/*
	 * Handle easy cases.
	 *
	 * Modern DST was put into effect by Congress in 1967. Also, if the
	 * month is before April or after October, it cannot be DST.
	 */
	if ( (tb->tm_year < 67) || (tb->tm_mon < 3) || (tb->tm_mon > 9) )
	    return(0);

	/*
	 * If the month is after April and before October, it must be DST.
	 */
	if ( (tb->tm_mon > 3) && (tb->tm_mon < 9) )
	    return(1);

	/*
	 * Now for the hard part.  Month is April or October; see if date
	 * falls between appropriate Sundays.
	 */

	/*
	 * The objective for years before 1987 (after 1986) is to determine
	 * if the day is on or after 2:00 am on the last (first) Sunday in
	 * April, or before 1:00 am on the last Sunday in October.
	 *
	 * We know the year-day (0..365) of the current time structure. We must
	 * determine the year-day of the last (first) Sunday in this month,
	 * April or October, and then do the comparison.
	 *
	 * To determine the year-day of the last Sunday, we do the following:
	 *	  1. Get the year-day of the last day of the current month (Apr
	 *	     or Oct)
	 *	  2. Determine the week-day number of #1,
	 *	     which is defined as 0 = Sun, 1 = Mon, ... 6 = Sat
	 *	  3. Subtract #2 from #1
	 *
	 * To determine the year-day of the first Sunday, we do the following:
	 *	  1. Get the year-day of the 7th day of the current month
	 *	     (April)
	 *	  2. Determine the week-day number of #1,
	 *	     which is defined as 0 = Sun, 1 = Mon, ... 6 = Sat
	 *	  3. Subtract #2 from #1
	 */

	/*
	 * First we get #1. The year-days for each month are stored in _days[]
	 * they're all off by -1
	 */
	if ( ((yr = tb->tm_year) > 86) && (tb->tm_mon == 3) )
	    mdays = 7 + _days[tb->tm_mon];
	else
	    mdays = _days[tb->tm_mon+1];

	/*
	 * if this is a leap-year, add an extra day
	 */
	if ( !(yr & 3) )
	    mdays++;

	/*
	 * mdays now has #1
	 */

	/* Now get #2. We know the week-day number of January 1, 1970, which is
	 * defined as the constant _BASE_DOW. Add to this the number of elapsed
	 * days since then, take the result mod 7, and we have our day number.
	 *
	 * To obtain #3, we just subtract this from mdays.
	 */

	critsun = mdays - ((mdays + 365 * (yr - 70) + ((yr - 1) >> 2) -
		  _LEAP_YEAR_ADJUST + _BASE_DOW) % 7);

	/* Now we know 1 and 3; we're golden: */

	return ( (tb->tm_mon == 3)
		 ? ((tb->tm_yday > critsun) ||
		    ((tb->tm_yday == critsun) && (tb->tm_hour >= 2)))
		 : ((tb->tm_yday < critsun) ||
		    ((tb->tm_yday == critsun) && (tb->tm_hour < 1))) );
}


#else	/* _POSIX_ */

/*
 *  The following is an implementation of the TZ grammar specified in the
 *  document:
 *
 *       8.1.1 Extension to Time Functions
 *       IEEE Std 1003.1 - 1990
 *       Page 152 - 153
 *
 *  The TZ grammar looks like:
 *
 *          stdoffset[dst[offset][,start[/time],end[/time]]]
 *
 *  Variables used in code:
 *
 *      tzname[0] ==> std
 *      _timezone  ==> offset(the one after 'std')
 *      tzname[1] ==> dst
 *      _dstoffset ==> offset(the one after 'dst')
 *      _startdate ==> start
 *      _starttime ==> time(the one after 'start')
 *      _enddate   ==> end
 *      _endtime   ==> time(the one after 'end')
 *
 */

/*
 *  Refer to the document for the detailed description of fields of _DSTDATE.
 *  Two of Jn, n, and Mm are -1, indicating the one(not -1) is a vaild value.
 */

typedef struct _DSTDATE {
	int Jn; /* -1 or [1, 365](year day and leap day shall not be counted) */
	int n;  /* -1 or [0, 365](year day and leap day shall be counted) */
	int Mm; /* -1 or [1, 12](month) */
	int Mn; /* [1, 5] if Mm != -1 (week) */
	int Md; /* [0, 6] if Mm != -1 (weekday, Sunday == 0) */
} DSTDATE, *PDSTDATE;

#define SEC_PER_HOUR	(60 * 60)
#define SEC_PER_DAY	(SEC_PER_HOUR * 24)


/*
 *  The default TZ in tzset() should look like:
 *
 *       TZ = "PST8PDT,M4.1.0/2:00,M10.5.0/2:00";
 */

/* Day light saving start/end date and default vaules */
static DSTDATE _startdate = { -1, -1, 4, 1, 0};
static DSTDATE _enddate = {-1, -1, 10, 5, 0};


/* Seconds since midnight on _startdate/_enddate with default values.
 * _endtime is 1am instead of 2am because the DST end time is 2am
 * local time, which by default is 1am standard time.
 */
long  _starttime = 7200L, _endtime = 7200L;

/*
 * If we are only interested in years between 1901 and 2099, we could use this:
 *
 *      #define IS_LEAP_YEAR(y)  (y % 4 == 0)
 */

#define IS_LEAP_YEAR(y)  ((y % 4 == 0 && y % 100 != 0) || y % 400 == 0)


/*
 *  ParsePosixStdOrDst - parse the std or dst element in TZ.
 *
 *  ENTRY   pch - beginning of the substring in TZ.
 *
 *  RETURN  pointer to one position after the std or dst element parsed,
 *          or NULL if failed.
 */


static	char * _CRTAPI3
ParsePosixStdOrDst(
	REG1 char *pch
	)
{
#define UNWANTED(x) (isdigit(x) || x=='\0' || x==',' || x=='-' || x=='+')
	int i;

	/*
	 *  Check against the rule.
	 */

	if(*pch == ':' || UNWANTED(*pch)) {
		return NULL;
	}

	/*
	 *  Get a valid std or dst(i.e. 3 <= lenth_of(std | dst) <= TZNAME_MAX).
	 */

	for(i=1, ++pch; (i < TZNAME_MAX) && !UNWANTED(*pch); i++, pch++) {
		;
	}

	/*
	 *  pch now point to 1 position after the valid std or dst.
	 */

	return (i >= 3) ? pch : NULL;
}


/*
 *  ParsePosixOffset - parse the offset element in TZ. The format of time is:
 *
 *                   [- | +]hh[:mm[:ss]]
 *
 *  ENTRY   pch - beginning of the substring in TZ.
 *
 *          ptime - pointer to a variable(_timezone or _dstoffset) storing the
 *                  time(in seconds) parsed.
 *
 *  RETURN  pointer to one position after the end of the offset element parsed.
 */


static	char * _CRTAPI3
ParsePosixOffset(
	REG1 char *pch,
	REG2 long *poffset
	)
{
	int  fNegative;
	long offset;

	if((fNegative = (*pch == '-')) || *pch == '+') {
		pch++;
	}

	offset = atol(pch)*3600L; /* hh */

	while(*pch && isdigit(*pch)) {
		pch++;
	}

	if(*pch == ':') {
		offset += atol(++pch)*60L; /* mm */
		while(*pch && isdigit(*pch)) {
			pch++;
		}

		if(*pch == ':') {
			offset += atol(++pch); /* ss */
			while(*pch && isdigit(*pch)) {
				pch++;
			}
		}
	}

	*poffset = fNegative ? -offset : offset;

	return pch;
}



/*
 *  ParsePosixDate - parse the date element in TZ. The format of date is one
 *                   of following:
 *
 *                   Jn, n, and Mm.n.d
 *
 *  ENTRY   pch - beginning of the substring in TZ.
 *
 *          pDstDate - pointer to _startdate or _enddate storing the result.
 *
 *  RETURN  pointer to one position after the end of the date element parsed,
 *          or NULL if failed.
 */

static	char * _CRTAPI3
ParsePosixDate(
	REG1 char *pch,
	REG2 PDSTDATE pDstDate
	)
{
	pDstDate->Jn = -1;
	pDstDate->n = -1;
	pDstDate->Mn = -1;

	/*
	 *  Two out of the three -1's will remain.
	 */

	if(*pch == 'J') {			 /* Jn */
		pDstDate->Jn = atoi(++pch);
	} else if(*pch != 'M') {		 /* n */
		pDstDate->n = atoi(pch);
	} else {				 /* Mm.n.d */

		pDstDate->Mm = atoi(++pch);

		if(*++pch != '.') {
			pch++;
		}
		pDstDate->Mn = atoi(++pch);

		if(*++pch != '.') {
			pch++;
		}
		pDstDate->Md = atoi(++pch);
	}

	while(*pch && isdigit(*pch)) {
		pch++;
	}

#define IN_RANGE(x, a, b)    (x >= a && x <= b)

	return ((pDstDate->Jn != -1 && IN_RANGE(pDstDate->Jn, 1, 365)) ||
		(pDstDate->n != -1 && IN_RANGE(pDstDate->n, 0, 365)) ||
		(pDstDate->Mm != -1 && IN_RANGE(pDstDate->Mm, 1, 12) &&
		IN_RANGE(pDstDate->Mn, 1, 5) && IN_RANGE(pDstDate->Md, 0, 6)))
		? pch : NULL;
}

/*
 *  ParsePosixTime - parse the time element in TZ. The format of time is:
 *
 *                   hh[:mm[:ss]]
 *
 *  ENTRY   pch - beginning of the substring in TZ.
 *
 *          ptime - pointer to a variable(_starttime or _endtime) storing the
 *                  time(in seconds) parsed.
 *
 *  RETURN  pointer to one position after the end of the time element parsed.
 */

static	char * _CRTAPI3
ParsePosixTime(
	REG1 char *pch,
	REG2 long *ptime
	)
{
	long time;

	time = atol(pch)*SEC_PER_HOUR; /* hh */

	while(*pch && isdigit(*pch)) {
		pch++;
	}

	if(*pch == ':') {

		time += atol(++pch)*60L; /* mm */
		while(*pch && isdigit(*pch)) {
			pch++;
		}

		if(*pch == ':') {

			time += atol(++pch); /* ss */
			while(*pch && isdigit(*pch)) {
				pch++;
			}
		}
	}

	*ptime = time;

	return pch;
}

/*
 *  tzset -  sets the timezone information from the TZ environment variable.
 *           Global tzname[], _timezone, _daylight, and _dstoffset will be
 *           set. Static _startdate, _enddate, _starttime, and _endtime will
 *           also be set. TZ string looks like:
 *
 *                stdoffset[dst[offset][,start[/time],end[/time]]]
 *
 *  In form of variables: tzname[0]_timezone[tzname[1][_dstoffset]
 *                        [,_startdate[/_starttime],_enddate[/_endtime]]]
 *
 *  ENTRY   none.
 *
 *  RETURN  none.
 */

void _CRTAPI1 tzset(
	void
	)
{
	/* pch points to the beginning of an element to be parsed. */
	REG1 char *pch;

	/* pchCurr points to one position after the end of last element parsed. */
	REG2 char *pchCurr;

	char *TZ;

	_endtime = 7200L;
	_starttime = 7200L;

	if (!(TZ = getenv("TZ")) || !*TZ) {
		TZ = "PST8PDT7,M4.1.0/2:00,M10.5.0/2:00"; /* use default */
	}

	if((pchCurr = ParsePosixStdOrDst(pch=TZ)) == NULL) {
		return;
	}

	memcpy(tzname[0], pch, (int)(pchCurr-pch));
	tzname[0][(int)(pchCurr-pch)] = '\0';

	if((pchCurr = ParsePosixOffset(pch=pchCurr, &_timezone)) == NULL) {
		return;
	}

	_daylight = (*pchCurr != '\0');

	if(!_daylight) {
		return;
	}

	if((pchCurr = ParsePosixStdOrDst(pch=pchCurr)) == NULL) {
		return;
	}

	memcpy(tzname[1], pch, (int)(pchCurr-pch));
	tzname[1][(int)(pchCurr-pch)] = '\0';

	if(isdigit(*pchCurr) || *pchCurr == '-' || *pchCurr == '+') {
		if((pchCurr = ParsePosixOffset(pch=pchCurr, &_dstoffset)) == NULL) {
			return;
		}
	} else {
		/* default: 1 hour ahead of standard time */
		_dstoffset = _timezone - SEC_PER_HOUR;
	}

	if(*pchCurr == ',') { /* ,start[/time],end[/time] */

		if((pchCurr = ParsePosixDate(pchCurr+1, &_startdate)) == NULL) {
			goto out;
		}

		if(*pchCurr == '/') {
			if(!(pchCurr = ParsePosixTime(pchCurr+1, &_starttime))) {
				goto out;
			}
		}

		if(*pchCurr != ',') {
			goto out;
		}

		if ((pchCurr = ParsePosixDate(pchCurr+1, &_enddate)) == NULL) {
			goto out;
		}

		if (*pchCurr == '/') {
			if(!(pchCurr = ParsePosixTime(pchCurr+1, &_endtime))) {
				goto out;
			}
		}
	}
out:
	/*
	 * Adjust the _endtime to account for the fact that
	 * dst ends at _endtime local time, rather than
	 * standard time.
	 */

	_endtime -= (_timezone - _dstoffset);
}


#define DAY1	(4)		/* Jan 1 1970 was a Thursday */

/*
 *  GetDstStartOrEndYearDay - Converts day info from DSTDATE into 0-based
 *                            year-day.
 *
 *  ENTRY   tm_year - the year concerned(tb->tm_year).
 *
 *          pDstDate - pointer to either _startdate or _enddate.
 *
 *  RETURN  the year-day calculated.
 */

static int _CRTAPI3
GetDstStartOrEndYearDay(
	REG1 int tm_year,
	REG2 PDSTDATE pDstDate
	)
{
	REG1 int yday; /* year-day */
	REG2 int theyear;

	theyear = tm_year + 1900;

	if(pDstDate->Jn != -1) {

	        /*
	         *  Jn is in [1, 365] and leap day is not counted.
	         *  Convert Jn to 0-based yday; Note: 60 is March 1.
	         */


        	yday = (IS_LEAP_YEAR(theyear) && (pDstDate->Jn >= 60))
               		? pDstDate->Jn : pDstDate->Jn - 1;

	} else if(pDstDate->n != -1) {

	        /*
	         *  n is in [0, 365] and leap day is counted.
	         */

		yday = pDstDate->n;

	} else { /* Mm.n.d */

	        int *ptrday;
	        int years;
	        int wday;

	        /*
	         *  We first need to calculate year-day(yday) and week-day
		 *  (wday) of 1st day of month pDstDate->Mm. We then figure
		 *  out year-day(yday) of Md day of week Mn of month Mm.
	         */

		ptrday = IS_LEAP_YEAR(theyear) ? _lpdays : _days;

		yday = ptrday[pDstDate->Mm-1] + 1; /* ptrday[i] are all by -1 off */

		years = tm_year - 70;

	        /*
	         *  Here constant Day1 is the week-day of Jan 1, 1970.
		 *  (years+1)/4 is for correcting the leap years.
	         */

		wday = (yday + 365*years + (years+1)/4 + DAY1) % 7;

	        /*
	         *  Calculate yday of Md day of week 1 of month Mm.
	         */

	        yday += pDstDate->Md - wday;
	        if(pDstDate->Md < wday) {
			yday += 7;
		}

        	/*
		 *  Calculate yday of Md day of week Mn of month Mm.
		 */

		yday += (pDstDate->Mn-1)*7;

		/*
		 *  Adjust if yday goes beyond the end of the month.
		 */

		if(pDstDate->Md == 5 && yday >= ptrday[pDstDate->Mm] + 1) {
			yday -= 7;
		}

	}

	return yday;
}

/*
 *  _isindst - Tells whether Xenix-type time value falls under DST.
 *
 *  ENTRY   tb - 'time' structure holding broken-down time value.
 *
 *  RETURN  1 if time represented is in DST, else 0.
 */

int _CRTAPI1 _isindst (
	REG1 struct tm *tb
	)
{
	int st_yday, end_yday;
	int st_sec, end_sec;

	int check_time;

	/*
	 * We need start/end year-days of DST in syday/eyday which are converted
	 * from one of the format Jn, n, and Mm.n.d. We already have start/end
	 * time (in seconds) of DST in _starttime/_endtime.
	 */

	st_yday = GetDstStartOrEndYearDay(tb->tm_year, &_startdate);
	end_yday = GetDstStartOrEndYearDay(tb->tm_year, &_enddate);

	st_sec = st_yday * SEC_PER_DAY + _starttime;
	end_sec = end_yday * SEC_PER_DAY + _endtime;

	check_time = tb->tm_yday * SEC_PER_DAY + tb->tm_hour * SEC_PER_HOUR
		+ tb->tm_min * 60 + tb->tm_sec;

	if (check_time >= st_sec && check_time < end_sec)
		return 1;

	return 0;
}

/*
 *  _isskiptime - Tells whether the given time is skipped at the
 * 	dst change.  For instance, we set our clocks forward one
 *	hour at 2am to 3am...  This function returns true for
 *	the times between 1:59:59 and 3:00:00.
 *
 *  ENTRY   tb - 'time' structure holding broken-down time value.
 *
 *  RETURN  1 if time represented is in the skipped period, 0
 *	otherwise.
 */

int _CRTAPI1 _isskiptime (
	REG1 struct tm *tb
	)
{
	int st_yday;
	int st_sec;
	int check_time;

	st_yday = GetDstStartOrEndYearDay(tb->tm_year, &_startdate);
	st_sec = st_yday * SEC_PER_DAY + _starttime;

	check_time = tb->tm_yday * SEC_PER_DAY + tb->tm_hour * SEC_PER_HOUR
		+ tb->tm_min * 60 + tb->tm_sec;

	if (check_time >= st_sec && check_time < st_sec - _dstoffset) {
		return 1;
	}
	return 0;
}

#endif /* _POSIX_ */