/*
Unix SMB/CIFS implementation.
time handling functions
- Copyright (C) Andrew Tridgell 1992-1998
+
+ Copyright (C) Andrew Tridgell 1992-2004
Copyright (C) Stefan (metze) Metzmacher 2002
+ Copyright (C) Jeremy Allison 2007
+
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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
-/*
- This stuff was largely rewritten by Paul Eggert <eggert@twinsun.com>
- in May 1996
- */
-
-int extra_time_offset = 0;
+/**
+ * @file
+ * @brief time handling functions
+ */
-#ifndef CHAR_BIT
-#define CHAR_BIT 8
-#endif
#ifndef TIME_T_MIN
#define TIME_T_MIN ((time_t)0 < (time_t) -1 ? (time_t) 0 \
#define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
#endif
+#define NTTIME_INFINITY (NTTIME)0x8000000000000000LL
+
+#if (SIZEOF_LONG == 8)
+#define TIME_FIXUP_CONSTANT_INT 11644473600L
+#elif (SIZEOF_LONG_LONG == 8)
+#define TIME_FIXUP_CONSTANT_INT 11644473600LL
+#endif
+
/*******************************************************************
- External access to time_t_min and time_t_max.
+ create a 16 bit dos packed date
********************************************************************/
-
-time_t get_time_t_max(void)
+static uint16_t make_dos_date1(struct tm *t)
{
- return TIME_T_MAX;
+ uint16_t ret=0;
+ ret = (((unsigned int)(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;
}
/*******************************************************************
- A gettimeofday wrapper.
+ create a 16 bit dos packed time
********************************************************************/
-
-void GetTimeOfDay(struct timeval *tval)
+static uint16_t make_dos_time1(struct tm *t)
{
-#ifdef HAVE_GETTIMEOFDAY_TZ
- gettimeofday(tval,NULL);
-#else
- gettimeofday(tval);
-#endif
+ uint16_t ret=0;
+ ret = ((((unsigned int)t->tm_min >> 3)&0x7) | (((unsigned int)t->tm_hour) << 3));
+ ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
+ return ret;
}
-#define TM_YEAR_BASE 1900
-
/*******************************************************************
- Yield the difference between *A and *B, in seconds, ignoring leap seconds.
+ create a 32 bit dos packed date/time from some parameters
+ This takes a GMT time and returns a packed localtime structure
********************************************************************/
+static uint32_t make_dos_date(time_t unixdate, int zone_offset)
+{
+ struct tm *t;
+ uint32_t ret=0;
+
+ 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);
+
+ return ret;
+}
-static int tm_diff(struct tm *a, struct tm *b)
+/**
+ parse a nttime as a large integer in a string and return a NTTIME
+*/
+NTTIME nttime_from_string(const char *s)
{
- 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 strtoull(s, NULL, 0);
}
-/*******************************************************************
- Return the UTC offset in seconds west of UTC, or 0 if it cannot be determined.
-******************************************************************/
+/**************************************************************
+ Handle conversions between time_t and uint32, taking care to
+ preserve the "special" values.
+**************************************************************/
-int get_time_zone(time_t t)
+uint32_t convert_time_t_to_uint32(time_t t)
{
- struct tm *tm = gmtime(&t);
- struct tm tm_utc;
+#if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
+ /* time_t is 64-bit. */
+ if (t == 0x8000000000000000LL) {
+ return 0x80000000;
+ } else if (t == 0x7FFFFFFFFFFFFFFFLL) {
+ return 0x7FFFFFFF;
+ }
+#endif
+ return (uint32_t)t;
+}
- if (!tm) {
- return 0;
+time_t convert_uint32_to_time_t(uint32_t u)
+{
+#if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
+ /* time_t is 64-bit. */
+ if (u == 0x80000000) {
+ return (time_t)0x8000000000000000LL;
+ } else if (u == 0x7FFFFFFF) {
+ return (time_t)0x7FFFFFFFFFFFFFFFLL;
}
- tm_utc = *tm;
- tm = localtime(&t);
- if (!tm) {
+#endif
+ return (time_t)u;
+}
+
+/****************************************************************************
+ Check if NTTIME is 0.
+****************************************************************************/
+
+bool nt_time_is_zero(const NTTIME *nt)
+{
+ return (*nt == 0);
+}
+
+/****************************************************************************
+ 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;
}
- return tm_diff(&tm_utc,tm) + 60*extra_time_offset;
+ tm.tm_year -= 1900;
+ tm.tm_mon -= 1;
+
+ return timegm(&tm);
}
/*******************************************************************
return server_zone_offset;
}
+/****************************************************************************
+ Return the date and time as a string
+****************************************************************************/
+
+char *current_timestring(TALLOC_CTX *ctx, bool hires)
+{
+ fstring TimeBuf;
+ struct timeval tp;
+ time_t t;
+ struct tm *tm;
+
+ if (hires) {
+ GetTimeOfDay(&tp);
+ t = (time_t)tp.tv_sec;
+ } else {
+ t = time(NULL);
+ }
+ tm = localtime(&t);
+ if (!tm) {
+ if (hires) {
+ slprintf(TimeBuf,
+ sizeof(TimeBuf)-1,
+ "%ld.%06ld seconds since the Epoch",
+ (long)tp.tv_sec,
+ (long)tp.tv_usec);
+ } else {
+ slprintf(TimeBuf,
+ sizeof(TimeBuf)-1,
+ "%ld seconds since the Epoch",
+ (long)t);
+ }
+ } else {
+#ifdef HAVE_STRFTIME
+ if (hires) {
+ strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
+ slprintf(TimeBuf+strlen(TimeBuf),
+ sizeof(TimeBuf)-1 - strlen(TimeBuf),
+ ".%06ld",
+ (long)tp.tv_usec);
+ } else {
+ strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
+ }
+#else
+ if (hires) {
+ const char *asct = asctime(tm);
+ slprintf(TimeBuf,
+ sizeof(TimeBuf)-1,
+ "%s.%06ld",
+ asct ? asct : "unknown",
+ (long)tp.tv_usec);
+ } else {
+ const char *asct = asctime(tm);
+ fstrcpy(TimeBuf, asct ? asct : "unknown");
+ }
+#endif
+ }
+ return talloc_strdup(ctx, TimeBuf);
+}
+
+
/*******************************************************************
- Re-read the smb serverzone value.
-******************************************************************/
+ Put a dos date into a buffer (time/date format).
+ This takes GMT time and puts local time in the buffer.
+********************************************************************/
-static struct timeval start_time_hires;
+static void put_dos_date(char *buf,int offset,time_t unixdate, int zone_offset)
+{
+ uint32_t x = make_dos_date(unixdate, zone_offset);
+ SIVAL(buf,offset,x);
+}
-void TimeInit(void)
+/*******************************************************************
+ Put a dos date into a buffer (date/time format).
+ This takes GMT time and puts local time in the buffer.
+********************************************************************/
+
+static void put_dos_date2(char *buf,int offset,time_t unixdate, int zone_offset)
{
- set_server_zone_offset(time(NULL));
+ uint32_t x = make_dos_date(unixdate, zone_offset);
+ x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
+ SIVAL(buf,offset,x);
+}
- DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));
+/*******************************************************************
+ 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)
+********************************************************************/
- /* Save the start time of this process. */
- if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0) {
- GetTimeOfDay(&start_time_hires);
+static void put_dos_date3(char *buf,int offset,time_t unixdate, int zone_offset)
+{
+ if (!null_mtime(unixdate)) {
+ unixdate -= zone_offset;
}
+ SIVAL(buf,offset,unixdate);
}
-/**********************************************************************
- Return a timeval struct of the uptime of this process. As TimeInit is
- done before a daemon fork then this is the start time from the parent
- daemon start. JRA.
-***********************************************************************/
-void get_process_uptime(struct timeval *ret_time)
-{
- struct timeval time_now_hires;
+/***************************************************************************
+ Server versions of the above functions.
+***************************************************************************/
- GetTimeOfDay(&time_now_hires);
- ret_time->tv_sec = time_now_hires.tv_sec - start_time_hires.tv_sec;
- 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 {
- ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
- }
+void srv_put_dos_date(char *buf,int offset,time_t unixdate)
+{
+ put_dos_date(buf, offset, unixdate, server_zone_offset);
}
-#if 0
-/****************************************************************************
- Return the UTC offset in seconds west of UTC, adjusted for extra time offset.
-**************************************************************************/
+void srv_put_dos_date2(char *buf,int offset, time_t unixdate)
+{
+ put_dos_date2(buf, offset, unixdate, server_zone_offset);
+}
-int TimeDiff(time_t t)
+void srv_put_dos_date3(char *buf,int offset,time_t unixdate)
{
- return get_time_zone(t);
+ put_dos_date3(buf, offset, unixdate, server_zone_offset);
}
-#endif
-time_t convert_timespec_to_time_t(struct timespec ts)
+/****************************************************************************
+ Take a Unix time and convert to an NTTIME structure and place in buffer
+ pointed to by p.
+****************************************************************************/
+
+void put_long_date_timespec(char *p, struct timespec ts)
{
- /* 1 ns == 1,000,000,000 - one thousand millionths of a second.
- increment if it's greater than 500 millionth of a second. */
- if (ts.tv_nsec > 500000000) {
- return ts.tv_sec + 1;
- }
- return ts.tv_sec;
+ NTTIME nt;
+ unix_timespec_to_nt_time(&nt, ts);
+ SIVAL(p, 0, nt & 0xFFFFFFFF);
+ SIVAL(p, 4, nt >> 32);
}
-struct timespec convert_time_t_to_timespec(time_t t)
+void put_long_date(char *p, time_t t)
{
struct timespec ts;
ts.tv_sec = t;
ts.tv_nsec = 0;
- return ts;
+ put_long_date_timespec(p, ts);
}
-#ifdef uint64
+/****************************************************************************
+ Return the best approximation to a 'create time' under UNIX from a stat
+ structure.
+****************************************************************************/
-#if (SIZEOF_LONG == 8)
-#define TIME_FIXUP_CONSTANT_INT 11644473600L
-#elif (SIZEOF_LONG_LONG == 8)
-#define TIME_FIXUP_CONSTANT_INT 11644473600LL
-#endif
+static time_t calc_create_time(const SMB_STRUCT_STAT *st)
+{
+ time_t ret, ret1;
-/****************************************************************************
- Interpret an 8 byte "filetime" structure to a time_t
- It's originally in "100ns units since jan 1st 1601"
+ ret = MIN(st->st_ctime, st->st_mtime);
+ ret1 = MIN(ret, st->st_atime);
- An 8 byte value of 0xffffffffffffffff will be returned as a timespec of
+ if(ret1 != (time_t)0) {
+ return ret1;
+ }
- tv_sec = 0
- tv_nsec = 0;
+ /*
+ * One of ctime, mtime or atime was zero (probably atime).
+ * Just return MIN(ctime, mtime).
+ */
+ return ret;
+}
- Returns GMT.
+/****************************************************************************
+ Return the 'create time' from a stat struct if it exists (birthtime) or else
+ use the best approximation.
****************************************************************************/
-/* Large integer version. */
-static struct timespec nt_time_to_unix_timespec(NTTIME *nt)
+struct timespec get_create_timespec(const SMB_STRUCT_STAT *pst,bool fake_dirs)
{
- uint64 d;
struct timespec ret;
- if ((nt->high == 0 && nt->low == 0 )||
- (nt->high == 0xffffffff && nt->low == 0xffffffff)) {
- ret.tv_sec = 0;
+ if(S_ISDIR(pst->st_mode) && fake_dirs) {
+ ret.tv_sec = 315493200L; /* 1/1/1980 */
ret.tv_nsec = 0;
return ret;
}
- d = (((uint64)nt->high) << 32 ) + ((uint64)nt->low);
- /* d is now in 100ns units, since jan 1st 1601".
- Save off the ns fraction. */
-
- ret.tv_nsec = (long) ((d % 100) * 100);
-
- /* Convert to seconds */
- d /= 1000*1000*10;
-
- /* Now adjust by 369 years to make the secs since 1970 */
- d -= TIME_FIXUP_CONSTANT_INT;
-
- if (((time_t)d) <= TIME_T_MIN) {
- ret.tv_sec = TIME_T_MIN;
- ret.tv_nsec = 0;
- return ret;
- }
+#if defined(HAVE_STAT_ST_BIRTHTIMESPEC)
+ ret = pst->st_birthtimespec;
+#elif defined(HAVE_STAT_ST_BIRTHTIMENSEC)
+ ret.tv_sec = pst->st_birthtime;
+ ret.tv_nsec = pst->st_birthtimenspec;
+#elif defined(HAVE_STAT_ST_BIRTHTIME)
+ ret.tv_sec = pst->st_birthtime;
+ ret.tv_nsec = 0;
+#else
+ ret.tv_sec = calc_create_time(pst);
+ ret.tv_nsec = 0;
+#endif
- if ((d >= (uint64)TIME_T_MAX)) {
- ret.tv_sec = TIME_T_MAX;
+ /* Deal with systems that don't initialize birthtime correctly.
+ * Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
+ */
+ if (null_timespec(ret)) {
+ ret.tv_sec = calc_create_time(pst);
ret.tv_nsec = 0;
- return ret;
}
-
- ret.tv_sec = (time_t)d;
- return ret;
+ return ret;
}
/****************************************************************************
- 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
-****************************************************************************/
-
-time_t nt_time_to_unix_abs(const NTTIME *nt)
-{
- uint64 d;
- NTTIME neg_nt;
-
- if (nt->high == 0) {
- return (time_t)0;
- }
-
- if (nt->high==0x80000000 && nt->low==0) {
- return (time_t)-1;
- }
-
- /* reverse the time */
- /* it's a negative value, turn it to positive */
- neg_nt.high=~nt->high;
- neg_nt.low=~nt->low;
-
- d = (((uint64)neg_nt.high) << 32 ) + ((uint64)neg_nt.low);
-
- d += 1000*1000*10/2;
- d /= 1000*1000*10;
-
- if (!(TIME_T_MIN <= ((time_t)d) && ((time_t)d) <= TIME_T_MAX)) {
- return (time_t)0;
- }
-
- return (time_t)d;
-}
-
-/****************************************************************************
- Put a 8 byte filetime from a struct timespec. Uses GMT.
+ Get/Set all the possible time fields from a stat struct as a timespec.
****************************************************************************/
-void unix_timespec_to_nt_time(NTTIME *nt, struct timespec ts)
-{
- uint64 d;
-
- if (ts.tv_sec ==0 && ts.tv_nsec == 0) {
- nt->low = 0;
- nt->high = 0;
- return;
- }
- if (ts.tv_sec == TIME_T_MAX) {
- nt->low = 0xffffffff;
- nt->high = 0x7fffffff;
- return;
- }
- if (ts.tv_sec == (time_t)-1) {
- nt->low = 0xffffffff;
- nt->high = 0xffffffff;
- return;
- }
-
- d = ts.tv_sec;
- d += TIME_FIXUP_CONSTANT_INT;
- d *= 1000*1000*10;
- /* d is now in 100ns units. */
- d += (ts.tv_nsec / 100);
-
- nt->low = (uint32)(d & 0xFFFFFFFF);
- nt->high = (uint32)(d >> 32 );
-}
-
-#else
-
-/* No 64-bit datatype. Use double float. */
-#define TIME_FIXUP_CONSTANT_DOUBLE (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60))
-
-/* Floating point double versions. */
-static struct timespec nt_time_to_unix_timespec(NTTIME *nt)
+struct timespec get_atimespec(const SMB_STRUCT_STAT *pst)
{
- double d;
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
struct timespec ret;
- if ((nt->high == 0 && nt->low == 0 )||
- (nt->high == 0xffffffff && nt->low == 0xffffffff)) {
- ret.tv_sec = 0;
- ret.tv_nsec = 0;
- return ret;
- }
-
- 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_DOUBLE;
-
- if (d <= TIME_T_MIN) {
- ret.tv_sec = TIME_T_MIN;
- ret.tv_nsec = 0;
- return ret;
- }
-
- if (d >= TIME_T_MAX) {
- ret.tv_sec = TIME_T_MAX;
- ret.tv_nsec = 0;
- return ret;
- }
-
- ret.tv_sec = (time_t)d;
- ret.tv_nsec = (long) ((d - (double)ret.tv_sec)*1.0e9);
+ /* Old system - no ns timestamp. */
+ ret.tv_sec = pst->st_atime;
+ ret.tv_nsec = 0;
return ret;
-}
-
-/****************************************************************************
- 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
-****************************************************************************/
-
-time_t nt_time_to_unix_abs(const NTTIME *nt)
-{
- double d;
- time_t ret;
- NTTIME neg_nt;
-
- if (nt->high == 0) {
- return (time_t)0;
- }
-
- if (nt->high==0x80000000 && nt->low==0) {
- return (time_t)-1;
- }
-
- /* reverse the time */
- /* it's a negative value, turn it to positive */
- neg_nt.high=~nt->high;
- neg_nt.low=~nt->low;
-
- d = ((double)neg_nt.high)*4.0*(double)(1<<30);
- d += (neg_nt.low&0xFFF00000);
- d *= 1.0e-7;
-
- if (!(TIME_T_MIN <= d && d <= TIME_T_MAX)) {
- return (time_t)0;
- }
-
- ret = (time_t)(d+0.5);
+#else
+#if defined(HAVE_STAT_ST_ATIM)
+ return pst->st_atim;
+#elif defined(HAVE_STAT_ST_ATIMENSEC)
+ struct timespec ret;
+ ret.tv_sec = pst->st_atime;
+ ret.tv_nsec = pst->st_atimensec;
return ret;
-}
-
-/****************************************************************************
- Put a 8 byte filetime from a struct timespec. Uses GMT.
-****************************************************************************/
-
-void unix_timespec_to_nt_time(NTTIME *nt, struct timespec ts)
-{
- double d;
-
- if (ts.tv_sec ==0 && ts.tv_nsec == 0) {
- nt->low = 0;
- nt->high = 0;
- return;
- }
- if (ts.tv_sec == TIME_T_MAX) {
- nt->low = 0xffffffff;
- nt->high = 0x7fffffff;
- return;
- }
- if (ts.tv_sec == (time_t)-1) {
- nt->low = 0xffffffff;
- nt->high = 0xffffffff;
- return;
- }
-
- d = (double)(ts.tv_sec);
- d += TIME_FIXUP_CONSTANT_DOUBLE;
- d *= 1.0e7;
- d += ((double)ts.tv_nsec / 100.0);
-
- nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
- nt->low = (uint32)(d - ((double)nt->high)*4.0*(double)(1<<30));
-}
+#elif defined(HAVE_STAT_ST_ATIMESPEC)
+ return pst->st_atimespec;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
#endif
-
-time_t nt_time_to_unix(NTTIME *nt)
-{
- return convert_timespec_to_time_t(nt_time_to_unix_timespec(nt));
-}
-
-/****************************************************************************
- Interprets an nt time into a unix struct timespec.
- 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.
-****************************************************************************/
-
-struct timespec interpret_long_date(char *p)
-{
- NTTIME nt;
- nt.low = IVAL(p,0);
- nt.high = IVAL(p,4);
- if (nt.low == 0xFFFFFFFF && nt.high == 0xFFFFFFFF) {
- struct timespec ret;
- ret.tv_sec = (time_t)-1;
- ret.tv_nsec = 0;
- return ret;
- }
- return nt_time_to_unix_timespec(&nt);
-}
-
-/****************************************************************************
- Put a 8 byte filetime from a time_t. Uses GMT.
-****************************************************************************/
-
-void unix_to_nt_time(NTTIME *nt, time_t t)
-{
- struct timespec ts;
- ts.tv_sec = t;
- ts.tv_nsec = 0;
- unix_timespec_to_nt_time(nt, ts);
-}
-
-/****************************************************************************
- 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
-****************************************************************************/
-
-void unix_to_nt_time_abs(NTTIME *nt, time_t t)
-{
- double d;
-
- if (t==0) {
- nt->low = 0;
- nt->high = 0;
- return;
- }
-
- if (t == TIME_T_MAX) {
- nt->low = 0xffffffff;
- nt->high = 0x7fffffff;
- return;
- }
-
- if (t == (time_t)-1) {
- /* that's what NT uses for infinite */
- nt->low = 0x0;
- nt->high = 0x80000000;
- return;
- }
-
- d = (double)(t);
- d *= 1.0e7;
-
- nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
- nt->low = (uint32)(d - ((double)nt->high)*4.0*(double)(1<<30));
-
- /* convert to a negative value */
- nt->high=~nt->high;
- nt->low=~nt->low;
-}
-
-/****************************************************************************
- Take a Unix time and convert to an NTTIME structure and place in buffer
- pointed to by p.
-****************************************************************************/
-
-void put_long_date_timespec(char *p, struct timespec ts)
-{
- NTTIME nt;
- unix_timespec_to_nt_time(&nt, ts);
- SIVAL(p, 0, nt.low);
- SIVAL(p, 4, nt.high);
-}
-
-void put_long_date(char *p, time_t t)
-{
- struct timespec ts;
- ts.tv_sec = t;
- ts.tv_nsec = 0;
- put_long_date_timespec(p, ts);
-}
-
-/****************************************************************************
- Check if it's a null mtime.
-****************************************************************************/
-
-BOOL null_mtime(time_t mtime)
-{
- if (mtime == 0 || mtime == (time_t)0xFFFFFFFF || mtime == (time_t)-1)
- return(True);
- return(False);
-}
-
-/*******************************************************************
- 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);
}
-/*******************************************************************
- Create a 16 bit dos packed time.
-********************************************************************/
-
-static uint16 make_dos_time1(struct tm *t)
+void set_atimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
{
- 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);
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+ /* Old system - no ns timestamp. */
+ pst->st_atime = ts.tv_sec;
+#else
+#if defined(HAVE_STAT_ST_ATIM)
+ pst->st_atim = ts;
+#elif defined(HAVE_STAT_ST_ATIMENSEC)
+ pst->st_atime = ts.tv_sec;
+ pst->st_atimensec = ts.tv_nsec
+#elif defined(HAVE_STAT_ST_ATIMESPEC)
+ pst->st_atimespec = ts;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
}
-/*******************************************************************
- 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, int zone_offset)
+struct timespec get_mtimespec(const SMB_STRUCT_STAT *pst)
{
- struct tm *t;
- uint32 ret=0;
-
- 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);
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+ struct timespec ret;
- return(ret);
+ /* Old system - no ns timestamp. */
+ ret.tv_sec = pst->st_mtime;
+ ret.tv_nsec = 0;
+ return ret;
+#else
+#if defined(HAVE_STAT_ST_MTIM)
+ return pst->st_mtim;
+#elif defined(HAVE_STAT_ST_MTIMENSEC)
+ struct timespec ret;
+ ret.tv_sec = pst->st_mtime;
+ ret.tv_nsec = pst->st_mtimensec;
+ return ret;
+#elif defined(HAVE_STAT_ST_MTIMESPEC)
+ return pst->st_mtimespec;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
}
-/*******************************************************************
- Put a dos date into a buffer (time/date format).
- This takes GMT time and puts local time in the buffer.
-********************************************************************/
-
-static void put_dos_date(char *buf,int offset,time_t unixdate, int zone_offset)
+void set_mtimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
{
- uint32 x = make_dos_date(unixdate, zone_offset);
- SIVAL(buf,offset,x);
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+ /* Old system - no ns timestamp. */
+ pst->st_mtime = ts.tv_sec;
+#else
+#if defined(HAVE_STAT_ST_MTIM)
+ pst->st_mtim = ts;
+#elif defined(HAVE_STAT_ST_MTIMENSEC)
+ pst->st_mtime = ts.tv_sec;
+ pst->st_mtimensec = ts.tv_nsec
+#elif defined(HAVE_STAT_ST_ATIMESPEC)
+ pst->st_atimespec = ts;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
}
-/*******************************************************************
- Put a dos date into a buffer (date/time format).
- This takes GMT time and puts local time in the buffer.
-********************************************************************/
-
-static void put_dos_date2(char *buf,int offset,time_t unixdate, int zone_offset)
+struct timespec get_ctimespec(const SMB_STRUCT_STAT *pst)
{
- uint32 x = make_dos_date(unixdate, zone_offset);
- x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
- SIVAL(buf,offset,x);
-}
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+ struct timespec ret;
-/*******************************************************************
- 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)
-********************************************************************/
+ /* Old system - no ns timestamp. */
+ ret.tv_sec = pst->st_ctime;
+ ret.tv_nsec = 0;
+ return ret;
+#else
+#if defined(HAVE_STAT_ST_CTIM)
+ return pst->st_ctim;
+#elif defined(HAVE_STAT_ST_CTIMENSEC)
+ struct timespec ret;
+ ret.tv_sec = pst->st_ctime;
+ ret.tv_nsec = pst->st_ctimensec;
+ return ret;
+#elif defined(HAVE_STAT_ST_CTIMESPEC)
+ return pst->st_ctimespec;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
+}
-static void put_dos_date3(char *buf,int offset,time_t unixdate, int zone_offset)
+void set_ctimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
{
- if (!null_mtime(unixdate)) {
- unixdate -= zone_offset;
- }
- SIVAL(buf,offset,unixdate);
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+ /* Old system - no ns timestamp. */
+ pst->st_ctime = ts.tv_sec;
+#else
+#if defined(HAVE_STAT_ST_CTIM)
+ pst->st_ctim = ts;
+#elif defined(HAVE_STAT_ST_CTIMENSEC)
+ pst->st_ctime = ts.tv_sec;
+ pst->st_ctimensec = ts.tv_nsec
+#elif defined(HAVE_STAT_ST_CTIMESPEC)
+ pst->st_ctimespec = ts;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
}
-/*******************************************************************
- 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)
+void dos_filetime_timespec(struct timespec *tsp)
{
- uint32 p0,p1,p2,p3;
-
- 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;
+ tsp->tv_sec &= ~1;
+ tsp->tv_nsec = 0;
}
/*******************************************************************
localtime).
********************************************************************/
-static time_t make_unix_date(void *date_ptr, int zone_offset)
+static time_t make_unix_date(const void *date_ptr, int zone_offset)
{
- uint32 dos_date=0;
+ uint32_t dos_date=0;
struct tm t;
time_t ret;
Like make_unix_date() but the words are reversed.
********************************************************************/
-static time_t make_unix_date2(void *date_ptr, int zone_offset)
+static time_t make_unix_date2(const void *date_ptr, int zone_offset)
{
- uint32 x,x2;
+ uint32_t x,x2;
x = IVAL(date_ptr,0);
x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
SIVAL(&x,0,x2);
- return(make_unix_date((void *)&x, zone_offset));
+ return(make_unix_date((const void *)&x, zone_offset));
}
/*******************************************************************
these generally arrive as localtimes, with corresponding DST.
******************************************************************/
-static time_t make_unix_date3(void *date_ptr, int zone_offset)
+static time_t make_unix_date3(const void *date_ptr, int zone_offset)
{
time_t t = (time_t)IVAL(date_ptr,0);
if (!null_mtime(t)) {
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)
+time_t srv_make_unix_date(const void *date_ptr)
{
return make_unix_date(date_ptr, server_zone_offset);
}
-time_t srv_make_unix_date2(void *date_ptr)
+time_t srv_make_unix_date2(const void *date_ptr)
{
return make_unix_date2(date_ptr, server_zone_offset);
}
-time_t srv_make_unix_date3(void *date_ptr)
+time_t srv_make_unix_date3(const 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)
-{
- 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.
-***************************************************************************/
-
-char *http_timestring(time_t t)
-{
- static fstring buf;
- struct tm *tm = localtime(&t);
-
- if (!tm) {
- slprintf(buf,sizeof(buf)-1,"%ld seconds since the Epoch",(long)t);
- } else {
-#ifndef HAVE_STRFTIME
- const char *asct = asctime(tm);
- fstrcpy(buf, asct ? asct : "unknown");
- }
- 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);
-#endif /* !HAVE_STRFTIME */
- }
- return buf;
-}
-
-/****************************************************************************
- Return the date and time as a string
-****************************************************************************/
-
-char *current_timestring(BOOL hires)
-{
- static fstring TimeBuf;
- struct timeval tp;
- time_t t;
- struct tm *tm;
-
- if (hires) {
- GetTimeOfDay(&tp);
- t = (time_t)tp.tv_sec;
- } else {
- t = time(NULL);
- }
- tm = localtime(&t);
- if (!tm) {
- if (hires) {
- slprintf(TimeBuf,
- sizeof(TimeBuf)-1,
- "%ld.%06ld seconds since the Epoch",
- (long)tp.tv_sec,
- (long)tp.tv_usec);
- } else {
- slprintf(TimeBuf,
- sizeof(TimeBuf)-1,
- "%ld seconds since the Epoch",
- (long)t);
- }
- } else {
-#ifdef HAVE_STRFTIME
- if (hires) {
- strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
- slprintf(TimeBuf+strlen(TimeBuf),
- sizeof(TimeBuf)-1 - strlen(TimeBuf),
- ".%06ld",
- (long)tp.tv_usec);
- } else {
- strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
- }
-#else
- if (hires) {
- const char *asct = asctime(tm);
- slprintf(TimeBuf,
- sizeof(TimeBuf)-1,
- "%s.%06ld",
- asct ? asct : "unknown",
- (long)tp.tv_usec);
- } else {
- const char *asct = asctime(tm);
- fstrcpy(TimeBuf, asct ? asct : "unknown");
- }
-#endif
- }
- return(TimeBuf);
-}
-
/****************************************************************************
- Return the best approximation to a 'create time' under UNIX from a stat
- structure.
+ Convert a normalized timeval to a timespec.
****************************************************************************/
-time_t get_create_time(SMB_STRUCT_STAT *st,BOOL fake_dirs)
-{
- time_t ret, ret1;
-
- 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);
-
- if(ret1 != (time_t)0) {
- return ret1;
- }
-
- /*
- * One of ctime, mtime or atime was zero (probably atime).
- * Just return MIN(ctime, mtime).
- */
- return ret;
-}
-
-struct timespec get_create_timespec(SMB_STRUCT_STAT *st,BOOL fake_dirs)
+struct timespec convert_timeval_to_timespec(const struct timeval tv)
{
struct timespec ts;
- ts.tv_sec = get_create_time(st, fake_dirs);
- ts.tv_nsec = 0;
+ ts.tv_sec = tv.tv_sec;
+ ts.tv_nsec = tv.tv_usec * 1000;
return ts;
}
/****************************************************************************
- Initialise an NTTIME to -1, which means "unknown" or "don't expire".
+ Convert a normalized timespec to a timeval.
****************************************************************************/
-void init_nt_time(NTTIME *nt)
-{
- nt->high = 0x7FFFFFFF;
- nt->low = 0xFFFFFFFF;
-}
-
-BOOL nt_time_is_set(const NTTIME *nt)
+struct timeval convert_timespec_to_timeval(const struct timespec ts)
{
- if ((nt->high == 0x7FFFFFFF) && (nt->low == 0xFFFFFFFF)) {
- return False;
- }
-
- if ((nt->high == 0x80000000) && (nt->low == 0)) {
- return False;
- }
-
- return True;
+ struct timeval tv;
+ tv.tv_sec = ts.tv_sec;
+ tv.tv_usec = ts.tv_nsec / 1000;
+ return tv;
}
/****************************************************************************
- Check if NTTIME is 0.
+ Return a timespec for the current time
****************************************************************************/
-BOOL nt_time_is_zero(const NTTIME *nt)
+struct timespec timespec_current(void)
{
- if(nt->high==0) {
- return True;
- }
- return False;
+ struct timeval tv;
+ struct timespec ts;
+ GetTimeOfDay(&tv);
+ ts.tv_sec = tv.tv_sec;
+ ts.tv_nsec = tv.tv_usec * 1000;
+ return ts;
}
/****************************************************************************
- Check if two NTTIMEs are the same.
+ Return the lesser of two timespecs.
****************************************************************************/
-BOOL nt_time_equals(const NTTIME *nt1, const NTTIME *nt2)
+struct timespec timespec_min(const struct timespec *ts1,
+ const struct timespec *ts2)
{
- return (nt1->high == nt2->high && nt1->low == nt2->low);
+ if (ts1->tv_sec < ts2->tv_sec) return *ts1;
+ if (ts1->tv_sec > ts2->tv_sec) return *ts2;
+ if (ts1->tv_nsec < ts2->tv_nsec) return *ts1;
+ return *ts2;
}
/****************************************************************************
- Return a timeval difference in usec.
+ compare two timespec structures.
+ Return -1 if ts1 < ts2
+ Return 0 if ts1 == ts2
+ Return 1 if ts1 > ts2
****************************************************************************/
-SMB_BIG_INT usec_time_diff(const struct timeval *larget, const struct timeval *smallt)
+int timespec_compare(const struct timespec *ts1, const struct timespec *ts2)
{
- SMB_BIG_INT sec_diff = larget->tv_sec - smallt->tv_sec;
- return (sec_diff * 1000000) + (SMB_BIG_INT)(larget->tv_usec - smallt->tv_usec);
+ if (ts1->tv_sec > ts2->tv_sec) return 1;
+ if (ts1->tv_sec < ts2->tv_sec) return -1;
+ if (ts1->tv_nsec > ts2->tv_nsec) return 1;
+ if (ts1->tv_nsec < ts2->tv_nsec) return -1;
+ return 0;
}
/****************************************************************************
- Return a timeval struct with the given elements.
+ Interprets an nt time into a unix struct timespec.
+ 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.
****************************************************************************/
-struct timeval timeval_set(uint32_t secs, uint32_t usecs)
+struct timespec interpret_long_date(const char *p)
{
- struct timeval tv;
- tv.tv_sec = secs;
- tv.tv_usec = usecs;
- return tv;
+ NTTIME nt;
+ nt = IVAL(p,0) + ((uint64_t)IVAL(p,4) << 32);
+ if (nt == (uint64_t)-1) {
+ struct timespec ret;
+ ret.tv_sec = (time_t)-1;
+ ret.tv_nsec = 0;
+ return ret;
+ }
+ return nt_time_to_unix_timespec(&nt);
}
-/****************************************************************************
- Return a zero timeval.
-****************************************************************************/
+/***************************************************************************
+ Client versions of the above functions.
+***************************************************************************/
-struct timeval timeval_zero(void)
+void cli_put_dos_date(struct cli_state *cli, char *buf, int offset, time_t unixdate)
{
- return timeval_set(0,0);
+ put_dos_date(buf, offset, unixdate, cli->serverzone);
}
-/****************************************************************************
- Return True if a timeval is zero.
-****************************************************************************/
-
-BOOL timeval_is_zero(const struct timeval *tv)
+void cli_put_dos_date2(struct cli_state *cli, char *buf, int offset, time_t unixdate)
{
- return tv->tv_sec == 0 && tv->tv_usec == 0;
+ put_dos_date2(buf, offset, unixdate, cli->serverzone);
}
-/****************************************************************************
- Return a timeval for the current time.
-****************************************************************************/
-
-struct timeval timeval_current(void)
+void cli_put_dos_date3(struct cli_state *cli, char *buf, int offset, time_t unixdate)
{
- struct timeval tv;
- GetTimeOfDay(&tv);
- return tv;
+ put_dos_date3(buf, offset, unixdate, cli->serverzone);
}
-/****************************************************************************
- Return a timeval ofs microseconds after tv.
-****************************************************************************/
-
-struct timeval timeval_add(const struct timeval *tv,
- uint32_t secs, uint32_t usecs)
+time_t cli_make_unix_date(struct cli_state *cli, const void *date_ptr)
{
- 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 make_unix_date(date_ptr, cli->serverzone);
}
-/****************************************************************************
- Return the sum of two timeval structures.
-****************************************************************************/
-
-struct timeval timeval_sum(const struct timeval *tv1,
- const struct timeval *tv2)
+time_t cli_make_unix_date2(struct cli_state *cli, const void *date_ptr)
{
- return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
+ return make_unix_date2(date_ptr, cli->serverzone);
}
-/****************************************************************************
- Return a timeval secs/usecs into the future.
-****************************************************************************/
-
-struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
+time_t cli_make_unix_date3(struct cli_state *cli, const void *date_ptr)
{
- struct timeval tv = timeval_current();
- return timeval_add(&tv, secs, usecs);
+ return make_unix_date3(date_ptr, cli->serverzone);
}
/****************************************************************************
- Compare two timeval structures.
- Return -1 if tv1 < tv2
- Return 0 if tv1 == tv2
- Return 1 if tv1 > tv2
+ Check if two NTTIMEs are the same.
****************************************************************************/
-int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
+bool nt_time_equals(const NTTIME *nt1, const NTTIME *nt2)
{
- 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 (*nt1 == *nt2);
}
-/****************************************************************************
- 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;
-}
+/*******************************************************************
+ Re-read the smb serverzone value.
+******************************************************************/
-/****************************************************************************
- Return the lesser of two timevals.
-****************************************************************************/
+static struct timeval start_time_hires;
-struct timeval timeval_min(const struct timeval *tv1,
- const struct timeval *tv2)
+void TimeInit(void)
{
- 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;
-}
+ set_server_zone_offset(time(NULL));
-/****************************************************************************
- Return the greater of two timevals.
-****************************************************************************/
+ DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));
-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;
+ /* Save the start time of this process. */
+ if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0) {
+ GetTimeOfDay(&start_time_hires);
}
- 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;
+/**********************************************************************
+ Return a timeval struct of the uptime of this process. As TimeInit is
+ done before a daemon fork then this is the start time from the parent
+ daemon start. JRA.
+***********************************************************************/
- ZERO_STRUCT(tm);
+void get_process_uptime(struct timeval *ret_time)
+{
+ struct timeval time_now_hires;
- 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;
+ GetTimeOfDay(&time_now_hires);
+ ret_time->tv_sec = time_now_hires.tv_sec - start_time_hires.tv_sec;
+ 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 {
+ ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
}
- tm.tm_year -= 1900;
- tm.tm_mon -= 1;
-
- return timegm(&tm);
}
/****************************************************************************
- Get/Set all the possible time fields from a stat struct as a timespec.
+ 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
****************************************************************************/
-struct timespec get_atimespec(SMB_STRUCT_STAT *pst)
+time_t nt_time_to_unix_abs(const NTTIME *nt)
{
-#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
- struct timespec ret;
+ uint64_t d;
- /* Old system - no ns timestamp. */
- ret.tv_sec = pst->st_atime;
- ret.tv_nsec = 0;
- return ret;
-#else
-#if defined(HAVE_STAT_ST_ATIM)
- return pst->st_atim;
-#elif defined(HAVE_STAT_ST_ATIMENSEC)
- struct timespec ret;
- ret.tv_sec = pst->st_atime;
- ret.tv_nsec = pst->st_atimensec;
- return ret;
-#else
-#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
-#endif
-#endif
-}
+ if (*nt == 0) {
+ return (time_t)0;
+ }
-void set_atimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
-{
-#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
- /* Old system - no ns timestamp. */
- pst->st_atime = ts.tv_sec;
-#else
-#if defined(HAVE_STAT_ST_ATIM)
- pst->st_atim = ts;
-#elif defined(HAVE_STAT_ST_ATIMENSEC)
- pst->st_atime = ts.tv_sec;
- pst->st_atimensec = ts.tv_nsec
-#else
-#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
-#endif
-#endif
-}
+ if (*nt == (uint64_t)-1) {
+ return (time_t)-1;
+ }
-struct timespec get_mtimespec(SMB_STRUCT_STAT *pst)
-{
-#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
- struct timespec ret;
+ if (*nt == NTTIME_INFINITY) {
+ return (time_t)-1;
+ }
- /* Old system - no ns timestamp. */
- ret.tv_sec = pst->st_mtime;
- ret.tv_nsec = 0;
- return ret;
-#else
-#if defined(HAVE_STAT_ST_MTIM)
- return pst->st_mtim;
-#elif defined(HAVE_STAT_ST_MTIMENSEC)
- struct timespec ret;
- ret.tv_sec = pst->st_mtime;
- ret.tv_nsec = pst->st_mtimensec;
- return ret;
-#else
-#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
-#endif
-#endif
-}
+ /* reverse the time */
+ /* it's a negative value, turn it to positive */
+ d=~*nt;
-void set_mtimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
-{
-#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
- /* Old system - no ns timestamp. */
- pst->st_mtime = ts.tv_sec;
-#else
-#if defined(HAVE_STAT_ST_MTIM)
- pst->st_mtim = ts;
-#elif defined(HAVE_STAT_ST_MTIMENSEC)
- pst->st_mtime = ts.tv_sec;
- pst->st_mtimensec = ts.tv_nsec
-#else
-#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
-#endif
-#endif
-}
+ d += 1000*1000*10/2;
+ d /= 1000*1000*10;
-struct timespec get_ctimespec(SMB_STRUCT_STAT *pst)
-{
-#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
- struct timespec ret;
+ if (!(TIME_T_MIN <= ((time_t)d) && ((time_t)d) <= TIME_T_MAX)) {
+ return (time_t)0;
+ }
- /* Old system - no ns timestamp. */
- ret.tv_sec = pst->st_ctime;
- ret.tv_nsec = 0;
- return ret;
-#else
-#if defined(HAVE_STAT_ST_CTIM)
- return pst->st_ctim;
-#elif defined(HAVE_STAT_ST_CTIMENSEC)
- struct timespec ret;
- ret.tv_sec = pst->st_ctime;
- ret.tv_nsec = pst->st_ctimensec;
- return ret;
-#else
-#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
-#endif
-#endif
+ return (time_t)d;
}
-void set_ctimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
+time_t uint64s_nt_time_to_unix_abs(const uint64_t *src)
{
-#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
- /* Old system - no ns timestamp. */
- pst->st_ctime = ts.tv_sec;
-#else
-#if defined(HAVE_STAT_ST_CTIM)
- pst->st_atim = ts;
-#elif defined(HAVE_STAT_ST_CTIMENSEC)
- pst->st_ctime = ts.tv_sec;
- pst->st_ctimensec = ts.tv_nsec
-#else
-#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
-#endif
-#endif
+ NTTIME nttime;
+ nttime = *src;
+ return nt_time_to_unix_abs(&nttime);
}
-#if 0
/****************************************************************************
- Return the best approximation to a 'create time' under UNIX from a stat
- structure.
+ Put a 8 byte filetime from a struct timespec. Uses GMT.
****************************************************************************/
-struct timespec get_create_timespec(SMB_STRUCT_STAT *st,BOOL fake_dirs)
+void unix_timespec_to_nt_time(NTTIME *nt, struct timespec ts)
{
- time_t ret, ret1;
+ uint64_t d;
- if(S_ISDIR(st->st_mode) && fake_dirs) {
- return (time_t)315493200L; /* 1/1/1980 */
+ if (ts.tv_sec ==0 && ts.tv_nsec == 0) {
+ *nt = 0;
+ return;
}
-
- ret = MIN(st->st_ctime, st->st_mtime);
- ret1 = MIN(ret, st->st_atime);
+ if (ts.tv_sec == TIME_T_MAX) {
+ *nt = 0x7fffffffffffffffLL;
+ return;
+ }
+ if (ts.tv_sec == (time_t)-1) {
+ *nt = (uint64_t)-1;
+ return;
+ }
- if(ret1 != (time_t)0) {
- return ret1;
- }
+ d = ts.tv_sec;
+ d += TIME_FIXUP_CONSTANT_INT;
+ d *= 1000*1000*10;
+ /* d is now in 100ns units. */
+ d += (ts.tv_nsec / 100);
- /*
- * One of ctime, mtime or atime was zero (probably atime).
- * Just return MIN(ctime, mtime).
- */
- return ret;
+ *nt = d;
}
-#endif
-void dos_filetime_timespec(struct timespec *tsp)
-{
- tsp->tv_sec &= ~1;
- tsp->tv_nsec = 0;
-}
+/****************************************************************************
+ Convert a time_t to a NTTIME structure
-/**
- Return the date and time as a string
-**/
-char *timestring(TALLOC_CTX *mem_ctx, time_t t)
+ 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 time_t was 5 seconds, the NTTIME is 5 seconds. JFM
+****************************************************************************/
+
+void unix_to_nt_time_abs(NTTIME *nt, time_t t)
{
- char *TimeBuf;
- char tempTime[80];
- struct tm *tm;
+ double d;
- tm = localtime(&t);
- if (!tm) {
- return talloc_asprintf(mem_ctx,
- "%ld seconds since the Epoch",
- (long)t);
+ if (t==0) {
+ *nt = 0;
+ return;
}
-#ifdef HAVE_STRFTIME
- /* some versions of gcc complain about using %c. This is a bug
- in the gcc warning, not a bug in this code. See a recent
- strftime() manual page for details.
- */
- strftime(tempTime,sizeof(tempTime)-1,"%c %Z",tm);
- TimeBuf = talloc_strdup(mem_ctx, tempTime);
-#else
- TimeBuf = talloc_strdup(mem_ctx, asctime(tm));
-#endif
+ if (t == TIME_T_MAX) {
+ *nt = 0x7fffffffffffffffLL;
+ return;
+ }
+
+ if (t == (time_t)-1) {
+ /* that's what NT uses for infinite */
+ *nt = NTTIME_INFINITY;
+ return;
+ }
+
+ d = (double)(t);
+ d *= 1.0e7;
- return TimeBuf;
+ *nt = (NTTIME)d;
+
+ /* convert to a negative value */
+ *nt=~*nt;
}
-/**
- return a talloced string representing a NTTIME for human consumption
-*/
-const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
+/****************************************************************************
+ Check if it's a null mtime.
+****************************************************************************/
+
+bool null_mtime(time_t mtime)
{
- time_t t;
- if (nt.low == 0 && nt.high == 0) {
- return "NTTIME(0)";
- }
- t = nt_time_to_unix(&nt);
- return timestring(mem_ctx, t);
+ if (mtime == 0 || mtime == (time_t)0xFFFFFFFF || mtime == (time_t)-1)
+ return true;
+ return false;
}
/****************************************************************************
and asctime fail.
****************************************************************************/
-const char *time_to_asc(const time_t *t)
+const char *time_to_asc(const time_t t)
{
const char *asct;
- struct tm *lt = localtime(t);
+ struct tm *lt = localtime(&t);
if (!lt) {
return "unknown time";
}
return asct;
}
+
+const char *display_time(NTTIME nttime)
+{
+ float high;
+ float low;
+ int sec;
+ int days, hours, mins, secs;
+
+ if (nttime==0)
+ return "Now";
+
+ if (nttime==NTTIME_INFINITY)
+ return "Never";
+
+ high = 65536;
+ high = high/10000;
+ high = high*65536;
+ high = high/1000;
+ high = high * (~(nttime >> 32));
+
+ low = ~(nttime & 0xFFFFFFFF);
+ low = low/(1000*1000*10);
+
+ sec=(int)(high+low);
+
+ days=sec/(60*60*24);
+ hours=(sec - (days*60*60*24)) / (60*60);
+ mins=(sec - (days*60*60*24) - (hours*60*60) ) / 60;
+ secs=sec - (days*60*60*24) - (hours*60*60) - (mins*60);
+
+ return talloc_asprintf(talloc_tos(), "%u days, %u hours, %u minutes, "
+ "%u seconds", days, hours, mins, secs);
+}
+
+bool nt_time_is_set(const NTTIME *nt)
+{
+ if (*nt == 0x7FFFFFFFFFFFFFFFLL) {
+ return false;
+ }
+
+ if (*nt == NTTIME_INFINITY) {
+ return false;
+ }
+
+ return true;
+}
git.samba.org / metze / samba / wip.git / blobdiff