/*
Unix SMB/CIFS implementation.
time handling functions
- Copyright (C) Andrew Tridgell 1992-1998
-
+ Copyright (C) Andrew Tridgell 1992-1998
+ Copyright (C) Stefan (metze) Metzmacher 2002
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
in May 1996
*/
-
int extra_time_offset = 0;
#ifndef CHAR_BIT
#define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
#endif
+void get_nttime_max(NTTIME *t)
+{
+ /* FIXME: This is incorrect */
+ unix_to_nt_time(t, get_time_t_max());
+}
+
/*******************************************************************
External access to time_t_min and time_t_max.
********************************************************************/
-time_t get_time_t_min(void)
-{
- return TIME_T_MIN;
-}
-
time_t get_time_t_max(void)
{
return TIME_T_MAX;
}
/*******************************************************************
-a gettimeofday wrapper
+ A gettimeofday wrapper.
********************************************************************/
+
void GetTimeOfDay(struct timeval *tval)
{
#ifdef HAVE_GETTIMEOFDAY_TZ
#define TM_YEAR_BASE 1900
/*******************************************************************
-yield the difference between *A and *B, in seconds, ignoring leap seconds
+ Yield the difference between *A and *B, in seconds, ignoring leap seconds.
********************************************************************/
+
static int tm_diff(struct tm *a, struct tm *b)
{
- int ay = a->tm_year + (TM_YEAR_BASE - 1);
- int by = b->tm_year + (TM_YEAR_BASE - 1);
- int intervening_leap_days =
- (ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400);
- int years = ay - by;
- int days = 365*years + intervening_leap_days + (a->tm_yday - b->tm_yday);
- int hours = 24*days + (a->tm_hour - b->tm_hour);
- int minutes = 60*hours + (a->tm_min - b->tm_min);
- int seconds = 60*minutes + (a->tm_sec - b->tm_sec);
+ int ay = a->tm_year + (TM_YEAR_BASE - 1);
+ int by = b->tm_year + (TM_YEAR_BASE - 1);
+ int intervening_leap_days = (ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400);
+ int years = ay - by;
+ int days = 365*years + intervening_leap_days + (a->tm_yday - b->tm_yday);
+ int hours = 24*days + (a->tm_hour - b->tm_hour);
+ int minutes = 60*hours + (a->tm_min - b->tm_min);
+ int seconds = 60*minutes + (a->tm_sec - b->tm_sec);
- return seconds;
+ return seconds;
}
/*******************************************************************
- return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
- ******************************************************************/
-static int TimeZone(time_t t)
+ Return the UTC offset in seconds west of UTC, or 0 if it cannot be determined.
+******************************************************************/
+
+int get_time_zone(time_t t)
{
- struct tm *tm = gmtime(&t);
- struct tm tm_utc;
- if (!tm)
- return 0;
- tm_utc = *tm;
- tm = localtime(&t);
- if (!tm)
- return 0;
- return tm_diff(&tm_utc,tm);
+ struct tm *tm = gmtime(&t);
+ struct tm tm_utc;
+ if (!tm) {
+ return 0;
+ }
+ tm_utc = *tm;
+ tm = localtime(&t);
+ if (!tm) {
+ return 0;
+ }
+ return tm_diff(&tm_utc,tm) + 60*extra_time_offset;
}
-static BOOL done_serverzone_init;
+/*******************************************************************
+ Accessor function for the server time zone offset.
+ set_server_zone_offset() must have been called first.
+******************************************************************/
-/* Return the smb serverzone value */
+static int server_zone_offset;
-static int get_serverzone(void)
+int get_server_zone_offset(void)
{
- static int serverzone;
-
- if (!done_serverzone_init) {
- serverzone = TimeZone(time(NULL));
-
- if ((serverzone % 60) != 0) {
- DEBUG(1,("WARNING: Your timezone is not a multiple of 1 minute.\n"));
- }
-
- DEBUG(4,("Serverzone is %d\n",serverzone));
+ return server_zone_offset;
+}
- done_serverzone_init = True;
- }
+/*******************************************************************
+ Initialize the server time zone offset. Called when a client connects.
+******************************************************************/
- return serverzone;
+int set_server_zone_offset(time_t t)
+{
+ server_zone_offset = get_time_zone(t);
+ return server_zone_offset;
}
-/* Re-read the smb serverzone value */
+/*******************************************************************
+ Re-read the smb serverzone value.
+******************************************************************/
static struct timeval start_time_hires;
void TimeInit(void)
{
- done_serverzone_init = False;
- get_serverzone();
+ set_server_zone_offset(time(NULL));
+
+ DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));
+
/* Save the start time of this process. */
- if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0)
+ if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0) {
GetTimeOfDay(&start_time_hires);
+ }
}
/**********************************************************************
if (time_now_hires.tv_usec < start_time_hires.tv_usec) {
ret_time->tv_sec -= 1;
ret_time->tv_usec = 1000000 + (time_now_hires.tv_usec - start_time_hires.tv_usec);
- } else
+ } else {
ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
+ }
}
-/*******************************************************************
-return the same value as TimeZone, but it should be more efficient.
-
-We keep a table of DST offsets to prevent calling localtime() on each
-call of this function. This saves a LOT of time on many unixes.
-
-Updated by Paul Eggert <eggert@twinsun.com>
-********************************************************************/
-static int TimeZoneFaster(time_t t)
-{
- static struct dst_table {time_t start,end; int zone;} *tdt, *dst_table = NULL;
- static int table_size = 0;
- int i;
- int zone = 0;
-
- if (t == 0) t = time(NULL);
-
- /* Tunis has a 8 day DST region, we need to be careful ... */
-#define MAX_DST_WIDTH (365*24*60*60)
-#define MAX_DST_SKIP (7*24*60*60)
-
- for (i=0;i<table_size;i++)
- if (t >= dst_table[i].start && t <= dst_table[i].end) break;
-
- if (i<table_size) {
- zone = dst_table[i].zone;
- } else {
- time_t low,high;
-
- zone = TimeZone(t);
- tdt = (struct dst_table *)Realloc(dst_table,
- sizeof(dst_table[0])*(i+1));
- if (!tdt) {
- DEBUG(0,("TimeZoneFaster: out of memory!\n"));
- SAFE_FREE(dst_table);
- table_size = 0;
- } else {
- dst_table = tdt;
- table_size++;
-
- dst_table[i].zone = zone;
- dst_table[i].start = dst_table[i].end = t;
-
- /* no entry will cover more than 6 months */
- low = t - MAX_DST_WIDTH/2;
- if (t < low)
- low = TIME_T_MIN;
-
- high = t + MAX_DST_WIDTH/2;
- if (high < t)
- high = TIME_T_MAX;
-
- /* widen the new entry using two bisection searches */
- while (low+60*60 < dst_table[i].start) {
- if (dst_table[i].start - low > MAX_DST_SKIP*2)
- t = dst_table[i].start - MAX_DST_SKIP;
- else
- t = low + (dst_table[i].start-low)/2;
- if (TimeZone(t) == zone)
- dst_table[i].start = t;
- else
- low = t;
- }
-
- while (high-60*60 > dst_table[i].end) {
- if (high - dst_table[i].end > MAX_DST_SKIP*2)
- t = dst_table[i].end + MAX_DST_SKIP;
- else
- t = high - (high-dst_table[i].end)/2;
- if (TimeZone(t) == zone)
- dst_table[i].end = t;
- else
- high = t;
- }
#if 0
- DEBUG(1,("Added DST entry from %s ",
- asctime(localtime(&dst_table[i].start))));
- DEBUG(1,("to %s (%d)\n",asctime(localtime(&dst_table[i].end)),
- dst_table[i].zone));
-#endif
- }
- }
- return zone;
-}
-
/****************************************************************************
- return the UTC offset in seconds west of UTC, adjusted for extra time offset
- **************************************************************************/
+ Return the UTC offset in seconds west of UTC, adjusted for extra time offset.
+**************************************************************************/
+
int TimeDiff(time_t t)
{
- return TimeZoneFaster(t) + 60*extra_time_offset;
+ return get_time_zone(t);
}
+#endif
+#define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60))
/****************************************************************************
- return the UTC offset in seconds west of UTC, adjusted for extra time
- offset, for a local time value. If ut = lt + LocTimeDiff(lt), then
- lt = ut - TimeDiff(ut), but the converse does not necessarily hold near
- daylight savings transitions because some local times are ambiguous.
- LocTimeDiff(t) equals TimeDiff(t) except near daylight savings transitions.
- +**************************************************************************/
-static int LocTimeDiff(time_t lte)
-{
- time_t lt = lte - 60*extra_time_offset;
- int d = TimeZoneFaster(lt);
- time_t t = lt + d;
-
- /* if overflow occurred, ignore all the adjustments so far */
- if (((lte < lt) ^ (extra_time_offset < 0)) | ((t < lt) ^ (d < 0)))
- t = lte;
+ Interpret an 8 byte "filetime" structure to a time_t
+ It's originally in "100ns units since jan 1st 1601"
- /* now t should be close enough to the true UTC to yield the right answer */
- return TimeDiff(t);
-}
+ An 8 byte value of 0xffffffffffffffff will be returned as (time_t)0.
-
-/****************************************************************************
-try to optimise the localtime call, it can be quite expensive on some machines
+ Returns GMT.
****************************************************************************/
-struct tm *LocalTime(time_t *t)
-{
- time_t t2 = *t;
-
- t2 -= TimeDiff(t2);
-
- return(gmtime(&t2));
-}
-#define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60))
-
-/****************************************************************************
-interpret an 8 byte "filetime" structure to a time_t
-It's originally in "100ns units since jan 1st 1601"
-
-It appears to be kludge-GMT (at least for file listings). This means
-its the GMT you get by taking a localtime and adding the
-serverzone. This is NOT the same as GMT in some cases. This routine
-converts this to real GMT.
-****************************************************************************/
time_t nt_time_to_unix(NTTIME *nt)
{
- double d;
- time_t ret;
- /* The next two lines are a fix needed for the
- broken SCO compiler. JRA. */
- time_t l_time_min = TIME_T_MIN;
- time_t l_time_max = TIME_T_MAX;
+ double d;
+ time_t ret;
+ /* The next two lines are a fix needed for the
+ broken SCO compiler. JRA. */
+ time_t l_time_min = TIME_T_MIN;
+ time_t l_time_max = TIME_T_MAX;
- if (nt->high == 0) return(0);
+ if (nt->high == 0 || (nt->high == 0xffffffff && nt->low == 0xffffffff)) {
+ return(0);
+ }
- d = ((double)nt->high)*4.0*(double)(1<<30);
- d += (nt->low&0xFFF00000);
- d *= 1.0e-7;
+ d = ((double)nt->high)*4.0*(double)(1<<30);
+ d += (nt->low&0xFFF00000);
+ d *= 1.0e-7;
- /* now adjust by 369 years to make the secs since 1970 */
- d -= TIME_FIXUP_CONSTANT;
+ /* now adjust by 369 years to make the secs since 1970 */
+ d -= TIME_FIXUP_CONSTANT;
- if (!(l_time_min <= d && d <= l_time_max))
- return(0);
-
- ret = (time_t)(d+0.5);
+ if (d <= l_time_min) {
+ return (l_time_min);
+ }
- /* this takes us from kludge-GMT to real GMT */
- ret -= get_serverzone();
- ret += LocTimeDiff(ret);
+ if (d >= l_time_max) {
+ return (l_time_max);
+ }
- return(ret);
+ ret = (time_t)(d+0.5);
+ return(ret);
}
/****************************************************************************
-convert a NTTIME structure to a time_t
-It's originally in "100ns units"
+ Convert a NTTIME structure to a time_t.
+ It's originally in "100ns units".
-this is an absolute version of the one above.
-By absolute I mean, it doesn't adjust from 1/1/1601 to 1/1/1970
-if the NTTIME was 5 seconds, the time_t is 5 seconds. JFM
+ This is an absolute version of the one above.
+ By absolute I mean, it doesn't adjust from 1/1/1601 to 1/1/1970
+ if the NTTIME was 5 seconds, the time_t is 5 seconds. JFM
****************************************************************************/
-time_t nt_time_to_unix_abs(NTTIME *nt)
+
+time_t nt_time_to_unix_abs(const NTTIME *nt)
{
double d;
time_t ret;
broken SCO compiler. JRA. */
time_t l_time_min = TIME_T_MIN;
time_t l_time_max = TIME_T_MAX;
+ NTTIME neg_nt;
- if (nt->high == 0)
+ if (nt->high == 0) {
return(0);
+ }
- if (nt->high==0x80000000 && nt->low==0)
- return -1;
+ if (nt->high==0x80000000 && nt->low==0) {
+ return (time_t)-1;
+ }
/* reverse the time */
/* it's a negative value, turn it to positive */
- nt->high=~nt->high;
- nt->low=~nt->low;
+ neg_nt.high=~nt->high;
+ neg_nt.low=~nt->low;
- d = ((double)nt->high)*4.0*(double)(1<<30);
- d += (nt->low&0xFFF00000);
+ d = ((double)neg_nt.high)*4.0*(double)(1<<30);
+ d += (neg_nt.low&0xFFF00000);
d *= 1.0e-7;
- if (!(l_time_min <= d && d <= l_time_max))
+ if (!(l_time_min <= d && d <= l_time_max)) {
return(0);
+ }
ret = (time_t)(d+0.5);
- /* this takes us from kludge-GMT to real GMT */
- ret -= get_serverzone();
- ret += LocTimeDiff(ret);
-
return(ret);
}
-
-
/****************************************************************************
-interprets an nt time into a unix time_t
+ Interprets an nt time into a unix time_t.
+ Differs from nt_time_to_unix in that an 8 byte value of 0xffffffffffffffff
+ will be returned as (time_t)-1, whereas nt_time_to_unix returns 0 in this case.
****************************************************************************/
+
time_t interpret_long_date(char *p)
{
NTTIME nt;
nt.low = IVAL(p,0);
nt.high = IVAL(p,4);
+ if (nt.low == 0xFFFFFFFF && nt.high == 0xFFFFFFFF) {
+ return (time_t)-1;
+ }
return nt_time_to_unix(&nt);
}
/****************************************************************************
-put a 8 byte filetime from a time_t
-This takes real GMT as input and converts to kludge-GMT
+ Put a 8 byte filetime from a time_t. Uses GMT.
****************************************************************************/
+
void unix_to_nt_time(NTTIME *nt, time_t t)
{
double d;
- if (t==0)
- {
+ if (t==0) {
nt->low = 0;
nt->high = 0;
return;
}
- if (t == TIME_T_MAX)
- {
+ if (t == TIME_T_MAX) {
nt->low = 0xffffffff;
nt->high = 0x7fffffff;
return;
}
- if (t == -1)
- {
+ if (t == (time_t)-1) {
nt->low = 0xffffffff;
nt->high = 0xffffffff;
return;
}
- /* this converts GMT to kludge-GMT */
- t -= LocTimeDiff(t) - get_serverzone();
-
d = (double)(t);
d += TIME_FIXUP_CONSTANT;
d *= 1.0e7;
}
/****************************************************************************
-convert a time_t to a NTTIME structure
+ Convert a time_t to a NTTIME structure
-this is an absolute version of the one above.
-By absolute I mean, it doesn't adjust from 1/1/1970 to 1/1/1601
-if the nttime_t was 5 seconds, the NTTIME is 5 seconds. JFM
+ This is an absolute version of the one above.
+ By absolute I mean, it doesn't adjust from 1/1/1970 to 1/1/1601
+ If the nttime_t was 5 seconds, the NTTIME is 5 seconds. JFM
****************************************************************************/
+
void unix_to_nt_time_abs(NTTIME *nt, time_t t)
{
double d;
return;
}
- if (t == -1) {
+ if (t == (time_t)-1) {
/* that's what NT uses for infinite */
nt->low = 0x0;
nt->high = 0x80000000;
return;
}
- /* this converts GMT to kludge-GMT */
- t -= LocTimeDiff(t) - get_serverzone();
-
d = (double)(t);
d *= 1.0e7;
nt->low=~nt->low;
}
-
/****************************************************************************
-take an NTTIME structure, containing high / low time. convert to unix time.
-lkclXXXX this may need 2 SIVALs not a memcpy. we'll see...
+ Take a Unix time and convert to an NTTIME structure and place in buffer
+ pointed to by p.
****************************************************************************/
-void put_long_date(char *p,time_t t)
+
+void put_long_date(char *p, time_t t)
{
NTTIME nt;
unix_to_nt_time(&nt, t);
}
/****************************************************************************
-check if it's a null mtime
+ Check if it's a null mtime.
****************************************************************************/
+
BOOL null_mtime(time_t mtime)
{
- if (mtime == 0 || mtime == 0xFFFFFFFF || mtime == (time_t)-1)
- return(True);
- return(False);
+ if (mtime == 0 || mtime == (time_t)0xFFFFFFFF || mtime == (time_t)-1)
+ return(True);
+ return(False);
}
/*******************************************************************
- create a 16 bit dos packed date
+ Create a 16 bit dos packed date.
********************************************************************/
+
static uint16 make_dos_date1(struct tm *t)
{
- uint16 ret=0;
- ret = (((unsigned)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
- ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5));
- return(ret);
+ uint16 ret=0;
+ ret = (((unsigned)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
+ ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5));
+ return(ret);
}
/*******************************************************************
- create a 16 bit dos packed time
+ Create a 16 bit dos packed time.
********************************************************************/
+
static uint16 make_dos_time1(struct tm *t)
{
- uint16 ret=0;
- ret = ((((unsigned)t->tm_min >> 3)&0x7) | (((unsigned)t->tm_hour) << 3));
- ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
- return(ret);
+ uint16 ret=0;
+ ret = ((((unsigned)t->tm_min >> 3)&0x7) | (((unsigned)t->tm_hour) << 3));
+ ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
+ return(ret);
}
/*******************************************************************
- create a 32 bit dos packed date/time from some parameters
- This takes a GMT time and returns a packed localtime structure
+ Create a 32 bit dos packed date/time from some parameters.
+ This takes a GMT time and returns a packed localtime structure.
********************************************************************/
-static uint32 make_dos_date(time_t unixdate)
+
+static uint32 make_dos_date(time_t unixdate, int zone_offset)
{
- struct tm *t;
- uint32 ret=0;
+ struct tm *t;
+ uint32 ret=0;
- t = LocalTime(&unixdate);
- if (!t)
- return 0xFFFFFFFF;
+ if (unixdate == 0) {
+ return 0;
+ }
+
+ unixdate -= zone_offset;
+ t = gmtime(&unixdate);
+ if (!t) {
+ return 0xFFFFFFFF;
+ }
- ret = make_dos_date1(t);
- ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
+ ret = make_dos_date1(t);
+ ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
- return(ret);
+ return(ret);
}
/*******************************************************************
-put a dos date into a buffer (time/date format)
-This takes GMT time and puts local time in the buffer
+ Put a dos date into a buffer (time/date format).
+ This takes GMT time and puts local time in the buffer.
********************************************************************/
-void put_dos_date(char *buf,int offset,time_t unixdate)
+
+static void put_dos_date(char *buf,int offset,time_t unixdate, int zone_offset)
{
- uint32 x = make_dos_date(unixdate);
- SIVAL(buf,offset,x);
+ uint32 x = make_dos_date(unixdate, zone_offset);
+ SIVAL(buf,offset,x);
}
/*******************************************************************
-put a dos date into a buffer (date/time format)
-This takes GMT time and puts local time in the buffer
+ Put a dos date into a buffer (date/time format).
+ This takes GMT time and puts local time in the buffer.
********************************************************************/
-void put_dos_date2(char *buf,int offset,time_t unixdate)
+
+static void put_dos_date2(char *buf,int offset,time_t unixdate, int zone_offset)
{
- uint32 x = make_dos_date(unixdate);
- x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
- SIVAL(buf,offset,x);
+ uint32 x = make_dos_date(unixdate, zone_offset);
+ x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
+ SIVAL(buf,offset,x);
}
/*******************************************************************
-put a dos 32 bit "unix like" date into a buffer. This routine takes
-GMT and converts it to LOCAL time before putting it (most SMBs assume
-localtime for this sort of date)
+ Put a dos 32 bit "unix like" date into a buffer. This routine takes
+ GMT and converts it to LOCAL time before putting it (most SMBs assume
+ localtime for this sort of date)
********************************************************************/
-void put_dos_date3(char *buf,int offset,time_t unixdate)
+
+static void put_dos_date3(char *buf,int offset,time_t unixdate, int zone_offset)
{
- if (!null_mtime(unixdate))
- unixdate -= TimeDiff(unixdate);
- SIVAL(buf,offset,unixdate);
+ if (!null_mtime(unixdate)) {
+ unixdate -= zone_offset;
+ }
+ SIVAL(buf,offset,unixdate);
}
/*******************************************************************
- interpret a 32 bit dos packed date/time to some parameters
+ Interpret a 32 bit dos packed date/time to some parameters.
********************************************************************/
+
static void interpret_dos_date(uint32 date,int *year,int *month,int *day,int *hour,int *minute,int *second)
{
- uint32 p0,p1,p2,p3;
+ uint32 p0,p1,p2,p3;
- p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF;
- p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF;
+ p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF;
+ p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF;
- *second = 2*(p0 & 0x1F);
- *minute = ((p0>>5)&0xFF) + ((p1&0x7)<<3);
- *hour = (p1>>3)&0xFF;
- *day = (p2&0x1F);
- *month = ((p2>>5)&0xFF) + ((p3&0x1)<<3) - 1;
- *year = ((p3>>1)&0xFF) + 80;
+ *second = 2*(p0 & 0x1F);
+ *minute = ((p0>>5)&0xFF) + ((p1&0x7)<<3);
+ *hour = (p1>>3)&0xFF;
+ *day = (p2&0x1F);
+ *month = ((p2>>5)&0xFF) + ((p3&0x1)<<3) - 1;
+ *year = ((p3>>1)&0xFF) + 80;
}
/*******************************************************************
- create a unix date (int GMT) from a dos date (which is actually in
- localtime)
+ Create a unix date (int GMT) from a dos date (which is actually in
+ localtime).
********************************************************************/
-time_t make_unix_date(void *date_ptr)
+
+static time_t make_unix_date(void *date_ptr, int zone_offset)
{
- uint32 dos_date=0;
- struct tm t;
- time_t ret;
+ uint32 dos_date=0;
+ struct tm t;
+ time_t ret;
- dos_date = IVAL(date_ptr,0);
+ dos_date = IVAL(date_ptr,0);
- if (dos_date == 0) return(0);
+ if (dos_date == 0) {
+ return 0;
+ }
- interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
- &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
- t.tm_isdst = -1;
+ interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
+ &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
+ t.tm_isdst = -1;
- /* mktime() also does the local to GMT time conversion for us */
- ret = mktime(&t);
+ ret = timegm(&t);
+
+ ret += zone_offset;
- return(ret);
+ return(ret);
}
/*******************************************************************
-like make_unix_date() but the words are reversed
+ Like make_unix_date() but the words are reversed.
********************************************************************/
-time_t make_unix_date2(void *date_ptr)
+
+static time_t make_unix_date2(void *date_ptr, int zone_offset)
{
- uint32 x,x2;
+ uint32 x,x2;
- x = IVAL(date_ptr,0);
- x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
- SIVAL(&x,0,x2);
+ x = IVAL(date_ptr,0);
+ x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
+ SIVAL(&x,0,x2);
- return(make_unix_date((void *)&x));
+ return(make_unix_date((void *)&x, zone_offset));
}
/*******************************************************************
- create a unix GMT date from a dos date in 32 bit "unix like" format
- these generally arrive as localtimes, with corresponding DST
- ******************************************************************/
-time_t make_unix_date3(void *date_ptr)
+ Create a unix GMT date from a dos date in 32 bit "unix like" format
+ these generally arrive as localtimes, with corresponding DST.
+******************************************************************/
+
+static time_t make_unix_date3(void *date_ptr, int zone_offset)
+{
+ time_t t = (time_t)IVAL(date_ptr,0);
+ if (!null_mtime(t)) {
+ t += zone_offset;
+ }
+ return(t);
+}
+
+/***************************************************************************
+ Server versions of the above functions.
+***************************************************************************/
+
+void srv_put_dos_date(char *buf,int offset,time_t unixdate)
+{
+ put_dos_date(buf, offset, unixdate, server_zone_offset);
+}
+
+void srv_put_dos_date2(char *buf,int offset, time_t unixdate)
+{
+ put_dos_date2(buf, offset, unixdate, server_zone_offset);
+}
+
+void srv_put_dos_date3(char *buf,int offset,time_t unixdate)
+{
+ put_dos_date3(buf, offset, unixdate, server_zone_offset);
+}
+
+time_t srv_make_unix_date(void *date_ptr)
+{
+ return make_unix_date(date_ptr, server_zone_offset);
+}
+
+time_t srv_make_unix_date2(void *date_ptr)
+{
+ return make_unix_date2(date_ptr, server_zone_offset);
+}
+
+time_t srv_make_unix_date3(void *date_ptr)
+{
+ return make_unix_date3(date_ptr, server_zone_offset);
+}
+
+/***************************************************************************
+ Client versions of the above functions.
+***************************************************************************/
+
+void cli_put_dos_date(struct cli_state *cli, char *buf, int offset, time_t unixdate)
+{
+ put_dos_date(buf, offset, unixdate, cli->serverzone);
+}
+
+void cli_put_dos_date2(struct cli_state *cli, char *buf, int offset, time_t unixdate)
+{
+ put_dos_date2(buf, offset, unixdate, cli->serverzone);
+}
+
+void cli_put_dos_date3(struct cli_state *cli, char *buf, int offset, time_t unixdate)
{
- time_t t = (time_t)IVAL(date_ptr,0);
- if (!null_mtime(t))
- t += LocTimeDiff(t);
- return(t);
+ put_dos_date3(buf, offset, unixdate, cli->serverzone);
}
+time_t cli_make_unix_date(struct cli_state *cli, void *date_ptr)
+{
+ return make_unix_date(date_ptr, cli->serverzone);
+}
+
+time_t cli_make_unix_date2(struct cli_state *cli, void *date_ptr)
+{
+ return make_unix_date2(date_ptr, cli->serverzone);
+}
+
+time_t cli_make_unix_date3(struct cli_state *cli, void *date_ptr)
+{
+ return make_unix_date3(date_ptr, cli->serverzone);
+}
/***************************************************************************
-return a HTTP/1.0 time string
- ***************************************************************************/
+ Return a HTTP/1.0 time string.
+***************************************************************************/
+
char *http_timestring(time_t t)
{
- static fstring buf;
- struct tm *tm = LocalTime(&t);
+ static fstring buf;
+ struct tm *tm = localtime(&t);
- if (!tm)
- slprintf(buf,sizeof(buf)-1,"%ld seconds since the Epoch",(long)t);
- else
+ if (!tm)
+ slprintf(buf,sizeof(buf)-1,"%ld seconds since the Epoch",(long)t);
+ else
#ifndef HAVE_STRFTIME
- fstrcpy(buf, asctime(tm));
- if(buf[strlen(buf)-1] == '\n')
- buf[strlen(buf)-1] = 0;
+ fstrcpy(buf, asctime(tm));
+ if(buf[strlen(buf)-1] == '\n')
+ buf[strlen(buf)-1] = 0;
#else /* !HAVE_STRFTIME */
- strftime(buf, sizeof(buf)-1, "%a, %d %b %Y %H:%M:%S %Z", tm);
+ strftime(buf, sizeof(buf)-1, "%a, %d %b %Y %H:%M:%S %Z", tm);
#endif /* !HAVE_STRFTIME */
- return buf;
+ return buf;
}
-
-
/****************************************************************************
Return the date and time as a string
****************************************************************************/
} else {
t = time(NULL);
}
- tm = LocalTime(&t);
+ tm = localtime(&t);
if (!tm) {
if (hires) {
slprintf(TimeBuf,
".%06ld",
(long)tp.tv_usec);
} else {
- strftime(TimeBuf,100,"%Y/%m/%d %H:%M:%S",tm);
+ strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
}
#else
if (hires) {
}
/****************************************************************************
- return the best approximation to a 'create time' under UNIX from a stat
- structure.
+ Return the best approximation to a 'create time' under UNIX from a stat
+ structure.
****************************************************************************/
time_t get_create_time(SMB_STRUCT_STAT *st,BOOL fake_dirs)
{
- time_t ret, ret1;
+ time_t ret, ret1;
- if(S_ISDIR(st->st_mode) && fake_dirs)
- return (time_t)315493200L; /* 1/1/1980 */
+ if(S_ISDIR(st->st_mode) && fake_dirs) {
+ return (time_t)315493200L; /* 1/1/1980 */
+ }
- ret = MIN(st->st_ctime, st->st_mtime);
- ret1 = MIN(ret, st->st_atime);
+ ret = MIN(st->st_ctime, st->st_mtime);
+ ret1 = MIN(ret, st->st_atime);
- if(ret1 != (time_t)0)
- return ret1;
+ if(ret1 != (time_t)0) {
+ return ret1;
+ }
- /*
- * One of ctime, mtime or atime was zero (probably atime).
- * Just return MIN(ctime, mtime).
- */
- return ret;
+ /*
+ * One of ctime, mtime or atime was zero (probably atime).
+ * Just return MIN(ctime, mtime).
+ */
+ return ret;
}
/****************************************************************************
-initialise an NTTIME to -1, which means "unknown" or "don't expire"
+ Initialise an NTTIME to -1, which means "unknown" or "don't expire".
****************************************************************************/
void init_nt_time(NTTIME *nt)
nt->high = 0x7FFFFFFF;
nt->low = 0xFFFFFFFF;
}
+
+BOOL nt_time_is_set(const NTTIME *nt)
+{
+ if ((nt->high == 0x7FFFFFFF) && (nt->low == 0xFFFFFFFF)) {
+ return False;
+ }
+
+ if ((nt->high == 0x80000000) && (nt->low == 0)) {
+ return False;
+ }
+
+ return True;
+}
+
+/****************************************************************************
+ Check if NTTIME is 0.
+****************************************************************************/
+
+BOOL nt_time_is_zero(const NTTIME *nt)
+{
+ if(nt->high==0) {
+ return True;
+ }
+ return False;
+}
+
+/****************************************************************************
+ Check if two NTTIMEs are the same.
+****************************************************************************/
+
+BOOL nt_time_equals(const NTTIME *nt1, const NTTIME *nt2)
+{
+ return (nt1->high == nt2->high && nt1->low == nt2->low);
+}
+
+/****************************************************************************
+ Return a timeval difference in usec.
+****************************************************************************/
+
+SMB_BIG_INT usec_time_diff(const struct timeval *larget, const struct timeval *smallt)
+{
+ SMB_BIG_INT sec_diff = larget->tv_sec - smallt->tv_sec;
+ return (sec_diff * 1000000) + (SMB_BIG_INT)(larget->tv_usec - smallt->tv_usec);
+}
+
+/****************************************************************************
+ Return a timeval struct with the given elements.
+****************************************************************************/
+
+struct timeval timeval_set(uint32_t secs, uint32_t usecs)
+{
+ struct timeval tv;
+ tv.tv_sec = secs;
+ tv.tv_usec = usecs;
+ return tv;
+}
+
+/****************************************************************************
+ Return a zero timeval.
+****************************************************************************/
+
+struct timeval timeval_zero(void)
+{
+ return timeval_set(0,0);
+}
+
+/****************************************************************************
+ Return True if a timeval is zero.
+****************************************************************************/
+
+BOOL timeval_is_zero(const struct timeval *tv)
+{
+ return tv->tv_sec == 0 && tv->tv_usec == 0;
+}
+
+/****************************************************************************
+ Return a timeval for the current time.
+****************************************************************************/
+
+struct timeval timeval_current(void)
+{
+ struct timeval tv;
+ GetTimeOfDay(&tv);
+ return tv;
+}
+
+/****************************************************************************
+ Return a timeval ofs microseconds after tv.
+****************************************************************************/
+
+struct timeval timeval_add(const struct timeval *tv,
+ uint32_t secs, uint32_t usecs)
+{
+ struct timeval tv2 = *tv;
+ tv2.tv_sec += secs;
+ tv2.tv_usec += usecs;
+ tv2.tv_sec += tv2.tv_usec / 1000000;
+ tv2.tv_usec = tv2.tv_usec % 1000000;
+ return tv2;
+}
+
+/****************************************************************************
+ Return the sum of two timeval structures.
+****************************************************************************/
+
+struct timeval timeval_sum(const struct timeval *tv1,
+ const struct timeval *tv2)
+{
+ return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
+}
+
+/****************************************************************************
+ Return a timeval secs/usecs into the future.
+****************************************************************************/
+
+struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
+{
+ struct timeval tv = timeval_current();
+ return timeval_add(&tv, secs, usecs);
+}
+
+/****************************************************************************
+ Compare two timeval structures.
+ Return -1 if tv1 < tv2
+ Return 0 if tv1 == tv2
+ Return 1 if tv1 > tv2
+****************************************************************************/
+
+int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
+{
+ if (tv1->tv_sec > tv2->tv_sec) {
+ return 1;
+ }
+ if (tv1->tv_sec < tv2->tv_sec) {
+ return -1;
+ }
+ if (tv1->tv_usec > tv2->tv_usec) {
+ return 1;
+ }
+ if (tv1->tv_usec < tv2->tv_usec) {
+ return -1;
+ }
+ return 0;
+}
+
+/****************************************************************************
+ Return the difference between two timevals as a timeval.
+ If tv1 comes after tv2, then return a zero timeval
+ (this is *tv2 - *tv1).
+****************************************************************************/
+
+struct timeval timeval_until(const struct timeval *tv1,
+ const struct timeval *tv2)
+{
+ struct timeval t;
+ if (timeval_compare(tv1, tv2) >= 0) {
+ return timeval_zero();
+ }
+ t.tv_sec = tv2->tv_sec - tv1->tv_sec;
+ if (tv1->tv_usec > tv2->tv_usec) {
+ t.tv_sec--;
+ t.tv_usec = 1000000 - (tv1->tv_usec - tv2->tv_usec);
+ } else {
+ t.tv_usec = tv2->tv_usec - tv1->tv_usec;
+ }
+ return t;
+}
+
+/****************************************************************************
+ Return the lesser of two timevals.
+****************************************************************************/
+
+struct timeval timeval_min(const struct timeval *tv1,
+ const struct timeval *tv2)
+{
+ if (tv1->tv_sec < tv2->tv_sec) {
+ return *tv1;
+ }
+ if (tv1->tv_sec > tv2->tv_sec) {
+ return *tv2;
+ }
+ if (tv1->tv_usec < tv2->tv_usec) {
+ return *tv1;
+ }
+ return *tv2;
+}
+
+/****************************************************************************
+ Return the greater of two timevals.
+****************************************************************************/
+
+struct timeval timeval_max(const struct timeval *tv1,
+ const struct timeval *tv2)
+{
+ if (tv1->tv_sec > tv2->tv_sec) {
+ return *tv1;
+ }
+ if (tv1->tv_sec < tv2->tv_sec) {
+ return *tv2;
+ }
+ if (tv1->tv_usec > tv2->tv_usec) {
+ return *tv1;
+ }
+ return *tv2;
+}
+
+/****************************************************************************
+ Convert ASN.1 GeneralizedTime string to unix-time.
+ Returns 0 on failure; Currently ignores timezone.
+****************************************************************************/
+
+time_t generalized_to_unix_time(const char *str)
+{
+ struct tm tm;
+
+ ZERO_STRUCT(tm);
+
+ if (sscanf(str, "%4d%2d%2d%2d%2d%2d",
+ &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
+ &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
+ return 0;
+ }
+ tm.tm_year -= 1900;
+ tm.tm_mon -= 1;
+
+ return timegm(&tm);
+}