/* 

 * tclUnixTime.c --

 *

 *	Contains Unix specific versions of Tcl functions that

 *	obtain time values from the operating system.

 *

 * Copyright (c) 1995 Sun Microsystems, Inc.

 * Portions Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiaries. All rights reserved.  

 *

 * See the file "license.terms" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 * RCS: @(#) $Id: tclUnixTime.c,v 1.15.2.6 2007/04/21 19:52:15 kennykb Exp $

 */

#include "tclInt.h"

#include "tclPort.h"

#include <locale.h>

#define TM_YEAR_BASE 1900

#define IsLeapYear(x)   ((x % 4 == 0) && (x % 100 != 0 || x % 400 == 0))

/*

 * TclpGetDate is coded to return a pointer to a 'struct tm'.  For

 * thread safety, this structure must be in thread-specific data.

 * The 'tmKey' variable is the key to this buffer.

 */

static Tcl_ThreadDataKey tmKey;

typedef struct ThreadSpecificData {

    struct tm gmtime_buf;

    struct tm localtime_buf;

} ThreadSpecificData;

/*

 * If we fall back on the thread-unsafe versions of gmtime and localtime,

 * use this mutex to try to protect them.

 */

TCL_DECLARE_MUTEX(tmMutex)

static char* lastTZ = NULL;	/* Holds the last setting of the

				 * TZ environment variable, or an

				 * empty string if the variable was

				 * not set. */

/* Static functions declared in this file */

static void SetTZIfNecessary _ANSI_ARGS_((void));

static void CleanupMemory _ANSI_ARGS_((ClientData));

/*

 *-----------------------------------------------------------------------------

 *

 * TclpGetSeconds --

 *

 *	This procedure returns the number of seconds from the epoch.  On

 *	most Unix systems the epoch is Midnight Jan 1, 1970 GMT.

 *

 * Results:

 *	Number of seconds from the epoch.

 *

 * Side effects:

 *	None.

 *

 *-----------------------------------------------------------------------------

 */

unsigned long

TclpGetSeconds()

{

    return time((time_t *) NULL);

}

/*

 *-----------------------------------------------------------------------------

 *

 * TclpGetClicks --

 *

 *	This procedure returns a value that represents the highest resolution

 *	clock available on the system.  There are no garantees on what the

 *	resolution will be.  In Tcl we will call this value a "click".  The

 *	start time is also system dependant.

 *

 * Results:

 *	Number of clicks from some start time.

 *

 * Side effects:

 *	None.

 *

 *-----------------------------------------------------------------------------

 */

unsigned long

TclpGetClicks()

{

    unsigned long now;

#ifdef NO_GETTOD

    struct tms dummy;

#else

    struct timeval date;

    struct timezone tz;

#endif

#ifdef NO_GETTOD

    now = (unsigned long) times(&dummy);

#else

    gettimeofday(&date, &tz);

    now = date.tv_sec*1000000 + date.tv_usec;

#endif

    return now;

}

/*

 *----------------------------------------------------------------------

 *

 * TclpGetTimeZone --

 *

 *	Determines the current timezone.  The method varies wildly

 *	between different platform implementations, so its hidden in

 *	this function.

 *

 * Results:

 *	The return value is the local time zone, measured in

 *	minutes away from GMT (-ve for east, +ve for west).

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

int

TclpGetTimeZone (currentTime)

    Tcl_WideInt  currentTime;

{

    /*

     * We prefer first to use the time zone in "struct tm" if the

     * structure contains such a member.  Following that, we try

     * to locate the external 'timezone' variable and use its value.

     * If both of those methods fail, we attempt to convert a known

     * time to local time and use the difference from UTC as the local

     * time zone.  In all cases, we need to undo any Daylight Saving Time

     * adjustment.

     */

#if defined(HAVE_TM_TZADJ)

#   define TCL_GOT_TIMEZONE

    /* Struct tm contains tm_tzadj - that value may be used. */

    time_t      curTime = (time_t) currentTime;

    struct tm  *timeDataPtr = TclpLocaltime((TclpTime_t) &curTime);

    int         timeZone;

    timeZone = timeDataPtr->tm_tzadj  / 60;

    if (timeDataPtr->tm_isdst) {

        timeZone += 60;

    }

    return timeZone;

#endif

#if defined(HAVE_TM_GMTOFF) && !defined (TCL_GOT_TIMEZONE)

#   define TCL_GOT_TIMEZONE

    /* Struct tm contains tm_gmtoff - that value may be used. */

    time_t     curTime = (time_t) currentTime;

    struct tm *timeDataPtr = TclpLocaltime((TclpTime_t) &curTime);

    int        timeZone;

    timeZone = -(timeDataPtr->tm_gmtoff / 60);

    if (timeDataPtr->tm_isdst) {

        timeZone += 60;

    }

    return timeZone;

#endif

#if defined(HAVE_TIMEZONE_VAR) && !defined(TCL_GOT_TIMEZONE) && !defined(USE_DELTA_FOR_TZ)

#   define TCL_GOT_TIMEZONE

    int        timeZone;

    /* The 'timezone' external var is present and may be used. */

    SetTZIfNecessary();

    /*

     * Note: this is not a typo in "timezone" below!  See tzset

     * documentation for details.

     */

    timeZone = timezone / 60;

    return timeZone;

#endif

#if !defined(TCL_GOT_TIMEZONE) 

#define TCL_GOT_TIMEZONE 1

    /*

     * Fallback - determine time zone with a known reference time.

     */

    int timeZone;

    time_t tt;

    struct tm *stm;

    tt = 849268800L;      /*    1996-11-29 12:00:00  GMT */

    stm = TclpLocaltime((TclpTime_t) &tt); /* eg 1996-11-29  6:00:00  CST6CDT */

    /* The calculation below assumes a max of +12 or -12 hours from GMT */

    timeZone = (12 - stm->tm_hour)*60 + (0 - stm->tm_min);

    if ( stm -> tm_isdst ) {

        timeZone += 60;

    }

    return timeZone;  /* eg +360 for CST6CDT */

#endif

#ifndef TCL_GOT_TIMEZONE

    /*

     * Cause compile error, we don't know how to get timezone.

     */

#error autoconf did not figure out how to determine the timezone. 

#endif

}

/*

 *----------------------------------------------------------------------

 *

 * Tcl_GetTime --

 *

 *	Gets the current system time in seconds and microseconds

 *	since the beginning of the epoch: 00:00 UCT, January 1, 1970.

 *

 * Results:

 *	Returns the current time in timePtr.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

EXPORT_C void

Tcl_GetTime(timePtr)

    Tcl_Time *timePtr;		/* Location to store time information. */

{

    struct timeval tv;

    struct timezone tz;

    (void) gettimeofday(&tv, &tz);

    timePtr->sec = tv.tv_sec;

    timePtr->usec = tv.tv_usec;

}

/*

 *----------------------------------------------------------------------

 *

 * TclpGetDate --

 *

 *	This function converts between seconds and struct tm.  If

 *	useGMT is true, then the returned date will be in Greenwich

 *	Mean Time (GMT).  Otherwise, it will be in the local time zone.

 *

 * Results:

 *	Returns a static tm structure.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

struct tm *

TclpGetDate(time, useGMT)

    TclpTime_t time;

    int useGMT;

{

    if (useGMT) {

	return TclpGmtime(time);

    } else {

	return TclpLocaltime(time);

    }

}

/*

 *----------------------------------------------------------------------

 *

 * TclpStrftime --

 *

 *	On Unix, we can safely call the native strftime implementation,

 *	and also ignore the useGMT parameter.

 *

 * Results:

 *	The normal strftime result.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

size_t

TclpStrftime(s, maxsize, format, t, useGMT)

    char *s;

    size_t maxsize;

    CONST char *format;

    CONST struct tm *t;

    int useGMT;

{

    if (format[0] == '%' && format[1] == 'Q') {

	/* Format as a stardate */

	sprintf(s, "Stardate %2d%03d.%01d",

		(((t->tm_year + TM_YEAR_BASE) + 377) - 2323),

		(((t->tm_yday + 1) * 1000) /

			(365 + IsLeapYear((t->tm_year + TM_YEAR_BASE)))),

		(((t->tm_hour * 60) + t->tm_min)/144));

	return(strlen(s));

    }

    setlocale(LC_TIME, "");

    return strftime(s, maxsize, format, t);

}

/*

 *----------------------------------------------------------------------

 *

 * TclpGmtime --

 *

 *	Wrapper around the 'gmtime' library function to make it thread

 *	safe.

 *

 * Results:

 *	Returns a pointer to a 'struct tm' in thread-specific data.

 *

 * Side effects:

 *	Invokes gmtime or gmtime_r as appropriate.

 *

 *----------------------------------------------------------------------

 */

struct tm *

TclpGmtime( tt )

    TclpTime_t_CONST tt;

{

    CONST time_t *timePtr = (CONST time_t *) tt;

				/* Pointer to the number of seconds

				 * since the local system's epoch */

    /*

     * Get a thread-local buffer to hold the returned time.

     */

    ThreadSpecificData *tsdPtr = TCL_TSD_INIT( &tmKey );

#ifdef HAVE_GMTIME_R

    gmtime_r(timePtr, &( tsdPtr->gmtime_buf ));

#else

    Tcl_MutexLock( &tmMutex );

    memcpy( (VOID *) &( tsdPtr->gmtime_buf ),

	    (VOID *) gmtime( timePtr ),

	    sizeof( struct tm ) );

    Tcl_MutexUnlock( &tmMutex );

#endif    

    return &( tsdPtr->gmtime_buf );

}

/*

 * Forwarder for obsolete item in Stubs

 */

struct tm*

TclpGmtime_unix( timePtr )

    TclpTime_t_CONST timePtr;

{

    return TclpGmtime( timePtr );

}

/*

 *----------------------------------------------------------------------

 *

 * TclpLocaltime --

 *

 *	Wrapper around the 'localtime' library function to make it thread

 *	safe.

 *

 * Results:

 *	Returns a pointer to a 'struct tm' in thread-specific data.

 *

 * Side effects:

 *	Invokes localtime or localtime_r as appropriate.

 *

 *----------------------------------------------------------------------

 */

struct tm *

TclpLocaltime( tt )

    TclpTime_t_CONST tt;

{

    CONST time_t *timePtr = (CONST time_t *) tt;

				/* Pointer to the number of seconds

				 * since the local system's epoch */

    /*

     * Get a thread-local buffer to hold the returned time.

     */

    ThreadSpecificData *tsdPtr = TCL_TSD_INIT( &tmKey );

    SetTZIfNecessary();

#ifdef HAVE_LOCALTIME_R

    localtime_r( timePtr, &( tsdPtr->localtime_buf ) );

#else

    Tcl_MutexLock( &tmMutex );

    memcpy( (VOID *) &( tsdPtr -> localtime_buf ),

	    (VOID *) localtime( timePtr ),

	    sizeof( struct tm ) );

    Tcl_MutexUnlock( &tmMutex );

#endif    

    return &( tsdPtr->localtime_buf );

}

/*

 * Forwarder for obsolete item in Stubs

 */

struct tm*

TclpLocaltime_unix( timePtr )

    TclpTime_t_CONST timePtr;

{

    return TclpLocaltime( timePtr );

}

/*

 *----------------------------------------------------------------------

 *

 * SetTZIfNecessary --

 *

 *	Determines whether a call to 'tzset' is needed prior to the

 *	next call to 'localtime' or examination of the 'timezone' variable.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	If 'tzset' has never been called in the current process, or if

 *	the value of the environment variable TZ has changed since the

 *	last call to 'tzset', then 'tzset' is called again.

 *

 *----------------------------------------------------------------------

 */

static void

SetTZIfNecessary() {

    CONST char* newTZ = getenv( "TZ" );

    Tcl_MutexLock(&tmMutex);

    if ( newTZ == NULL ) {

	newTZ = "";

    }

    if ( lastTZ == NULL || strcmp( lastTZ, newTZ ) ) {

        tzset();

	if ( lastTZ == NULL ) {

	    Tcl_CreateExitHandler( CleanupMemory, (ClientData) NULL );

	} else {

	    Tcl_Free( lastTZ );

	}

	lastTZ = ckalloc( strlen( newTZ ) + 1 );

	strcpy( lastTZ, newTZ );

    }

    Tcl_MutexUnlock(&tmMutex);

}

/*

 *----------------------------------------------------------------------

 *

 * CleanupMemory --

 *

 *	Releases the private copy of the TZ environment variable

 *	upon exit from Tcl.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	Frees allocated memory.

 *

 *----------------------------------------------------------------------

 */

static void

CleanupMemory( ClientData ignored )

{

    ckfree( lastTZ );

}