/*
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
- */
-
+/**
+ * @file
+ * @brief time handling functions
+ */
-int extra_time_offset = 0;
-
-#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
-/*******************************************************************
- External access to time_t_min and time_t_max.
-********************************************************************/
+#define NTTIME_INFINITY (NTTIME)0x8000000000000000LL
-time_t get_time_t_min(void)
-{
- return TIME_T_MIN;
-}
+#if (SIZEOF_LONG == 8)
+#define TIME_FIXUP_CONSTANT_INT 11644473600L
+#elif (SIZEOF_LONG_LONG == 8)
+#define TIME_FIXUP_CONSTANT_INT 11644473600LL
+#endif
-time_t get_time_t_max(void)
+/*******************************************************************
+ create a 16 bit dos packed date
+********************************************************************/
+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 int tm_diff(struct tm *a, struct tm *b)
+static uint32_t make_dos_date(time_t unixdate, int zone_offset)
{
- 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);
+ struct tm *t;
+ uint32_t ret=0;
+
+ if (unixdate == 0) {
+ return 0;
+ }
+
+ unixdate -= zone_offset;
+
+ t = gmtime(&unixdate);
+ if (!t) {
+ return 0xFFFFFFFF;
+ }
- return seconds;
+ ret = make_dos_date1(t);
+ ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
+
+ return ret;
}
-/*******************************************************************
- return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
- ******************************************************************/
-static int TimeZone(time_t t)
+/**
+ parse a nttime as a large integer in a string and return a NTTIME
+*/
+NTTIME nttime_from_string(const char *s)
{
- 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);
+ return strtoull(s, NULL, 0);
+}
+
+/**************************************************************
+ Handle conversions between time_t and uint32, taking care to
+ preserve the "special" values.
+**************************************************************/
+uint32_t convert_time_t_to_uint32(time_t t)
+{
+#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;
}
-static BOOL done_serverzone_init;
+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;
+ }
+#endif
+ return (time_t)u;
+}
-/* Return the smb serverzone value */
+/****************************************************************************
+ Check if NTTIME is 0.
+****************************************************************************/
-static int get_serverzone(void)
+bool nt_time_is_zero(const NTTIME *nt)
{
- static int serverzone;
+ return (*nt == 0);
+}
- if (!done_serverzone_init) {
- serverzone = TimeZone(time(NULL));
+/****************************************************************************
+ Convert ASN.1 GeneralizedTime string to unix-time.
+ Returns 0 on failure; Currently ignores timezone.
+****************************************************************************/
- if ((serverzone % 60) != 0) {
- DEBUG(1,("WARNING: Your timezone is not a multiple of 1 minute.\n"));
- }
+time_t generalized_to_unix_time(const char *str)
+{
+ struct tm tm;
- DEBUG(4,("Serverzone is %d\n",serverzone));
+ ZERO_STRUCT(tm);
- done_serverzone_init = True;
- }
+ 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 serverzone;
+ return timegm(&tm);
}
-/* Re-read the smb serverzone value */
+/*******************************************************************
+ Accessor function for the server time zone offset.
+ set_server_zone_offset() must have been called first.
+******************************************************************/
-static struct timeval start_time_hires;
+static int server_zone_offset;
-void TimeInit(void)
+int get_server_zone_offset(void)
{
- done_serverzone_init = False;
- get_serverzone();
- /* 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 server_zone_offset;
}
-/**********************************************************************
- 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.
-***********************************************************************/
+/*******************************************************************
+ Initialize the server time zone offset. Called when a client connects.
+******************************************************************/
-void get_process_uptime(struct timeval *ret_time)
+int set_server_zone_offset(time_t t)
{
- struct timeval time_now_hires;
+ server_zone_offset = get_time_zone(t);
+ return server_zone_offset;
+}
- GetTimeOfDay(&time_now_hires);
- ret_time->tv_sec = time_now_hires.tv_sec - start_time_hires.tv_sec;
- ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
- 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;
+/****************************************************************************
+ 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);
}
+
/*******************************************************************
-return the same value as TimeZone, but it should be more efficient.
+ Put a dos date into a buffer (time/date format).
+ This takes GMT time and puts local time in the buffer.
+********************************************************************/
-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.
+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);
+}
-Updated by Paul Eggert <eggert@twinsun.com>
+/*******************************************************************
+ Put a dos date into a buffer (date/time format).
+ This takes GMT time and puts local time in the buffer.
********************************************************************/
-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
- **************************************************************************/
-int TimeDiff(time_t t)
+static void put_dos_date2(char *buf,int offset,time_t unixdate, int zone_offset)
{
- return TimeZoneFaster(t) + 60*extra_time_offset;
+ uint32_t 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)
+********************************************************************/
-/****************************************************************************
- 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)
+static void put_dos_date3(char *buf,int offset,time_t unixdate, int zone_offset)
{
- time_t lt = lte - 60*extra_time_offset;
- int d = TimeZoneFaster(lt);
- time_t t = lt + d;
+ if (!null_mtime(unixdate)) {
+ unixdate -= zone_offset;
+ }
+ SIVAL(buf,offset,unixdate);
+}
- /* if overflow occurred, ignore all the adjustments so far */
- if (((lte < lt) ^ (extra_time_offset < 0)) | ((t < lt) ^ (d < 0)))
- t = lte;
- /* now t should be close enough to the true UTC to yield the right answer */
- return TimeDiff(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);
+}
-/****************************************************************************
-try to optimise the localtime call, it can be quite expensive on some machines
-****************************************************************************/
-struct tm *LocalTime(time_t *t)
+void srv_put_dos_date3(char *buf,int offset,time_t unixdate)
{
- time_t t2 = *t;
+ put_dos_date3(buf, offset, unixdate, server_zone_offset);
+}
- t2 -= TimeDiff(t2);
+/****************************************************************************
+ Take a Unix time and convert to an NTTIME structure and place in buffer
+ pointed to by p.
+****************************************************************************/
- return(gmtime(&t2));
+void put_long_date_timespec(char *p, struct timespec ts)
+{
+ NTTIME nt;
+ unix_timespec_to_nt_time(&nt, ts);
+ SIVAL(p, 0, nt & 0xFFFFFFFF);
+ SIVAL(p, 4, nt >> 32);
}
-#define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60))
+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);
+}
/****************************************************************************
-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.
+ Return the best approximation to a 'create time' under UNIX from a stat
+ structure.
****************************************************************************/
-time_t nt_time_to_unix(NTTIME *nt)
+
+static time_t calc_create_time(const SMB_STRUCT_STAT *st)
{
- 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;
+ time_t ret, ret1;
+
+ ret = MIN(st->st_ctime, st->st_mtime);
+ ret1 = MIN(ret, st->st_atime);
- if (nt->high == 0) return(0);
+ if(ret1 != (time_t)0) {
+ return ret1;
+ }
- 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;
+ /*
+ * One of ctime, mtime or atime was zero (probably atime).
+ * Just return MIN(ctime, mtime).
+ */
+ return ret;
+}
- if (!(l_time_min <= d && d <= l_time_max))
- return(0);
+/****************************************************************************
+ Return the 'create time' from a stat struct if it exists (birthtime) or else
+ use the best approximation.
+****************************************************************************/
- ret = (time_t)(d+0.5);
+struct timespec get_create_timespec(const SMB_STRUCT_STAT *pst,bool fake_dirs)
+{
+ struct timespec ret;
- /* this takes us from kludge-GMT to real GMT */
- ret -= get_serverzone();
- ret += LocTimeDiff(ret);
+ if(S_ISDIR(pst->st_mode) && fake_dirs) {
+ ret.tv_sec = 315493200L; /* 1/1/1980 */
+ ret.tv_nsec = 0;
+ return ret;
+ }
- 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
+
+ /* 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;
}
/****************************************************************************
-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
+ Get/Set all the possible time fields from a stat struct as a timespec.
****************************************************************************/
-time_t nt_time_to_unix_abs(NTTIME *nt)
+
+struct timespec get_atimespec(const SMB_STRUCT_STAT *pst)
{
- 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 !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+ struct timespec ret;
- if (nt->high == 0)
- return(0);
+ /* 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;
+#elif defined(HAVE_STAT_ST_ATIMESPEC)
+ return pst->st_atimespec;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
+}
- if (nt->high==0x80000000 && nt->low==0)
- return -1;
+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
+#elif defined(HAVE_STAT_ST_ATIMESPEC)
+ pst->st_atimespec = ts;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
+}
- /* reverse the time */
- /* it's a negative value, turn it to positive */
- nt->high=~nt->high;
- nt->low=~nt->low;
+struct timespec get_mtimespec(const SMB_STRUCT_STAT *pst)
+{
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+ struct timespec ret;
- d = ((double)nt->high)*4.0*(double)(1<<30);
- d += (nt->low&0xFFF00000);
- d *= 1.0e-7;
-
- if (!(l_time_min <= d && d <= l_time_max))
- return(0);
+ /* 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
+}
- ret = (time_t)(d+0.5);
+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
+#elif defined(HAVE_STAT_ST_ATIMESPEC)
+ pst->st_atimespec = ts;
+#else
+#error CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
+#endif
+#endif
+}
- /* this takes us from kludge-GMT to real GMT */
- ret -= get_serverzone();
- ret += LocTimeDiff(ret);
+struct timespec get_ctimespec(const SMB_STRUCT_STAT *pst)
+{
+#if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
+ struct timespec ret;
- return(ret);
+ /* 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
}
+void set_ctimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
+{
+#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
+}
-
-/****************************************************************************
-interprets an nt time into a unix time_t
-****************************************************************************/
-time_t interpret_long_date(char *p)
+void dos_filetime_timespec(struct timespec *tsp)
{
- NTTIME nt;
- nt.low = IVAL(p,0);
- nt.high = IVAL(p,4);
- return nt_time_to_unix(&nt);
+ tsp->tv_sec &= ~1;
+ tsp->tv_nsec = 0;
}
-/****************************************************************************
-put a 8 byte filetime from a time_t
-This takes real GMT as input and converts to kludge-GMT
-****************************************************************************/
-void unix_to_nt_time(NTTIME *nt, time_t t)
+/*******************************************************************
+ Create a unix date (int GMT) from a dos date (which is actually in
+ localtime).
+********************************************************************/
+
+static time_t make_unix_date(const void *date_ptr, int zone_offset)
{
- double d;
+ uint32_t dos_date=0;
+ struct tm t;
+ time_t ret;
- if (t==0)
- {
- nt->low = 0;
- nt->high = 0;
- return;
- }
- if (t == TIME_T_MAX)
- {
- nt->low = 0xffffffff;
- nt->high = 0x7fffffff;
- return;
- }
- if (t == -1)
- {
- nt->low = 0xffffffff;
- nt->high = 0xffffffff;
- return;
- }
+ dos_date = IVAL(date_ptr,0);
- /* this converts GMT to kludge-GMT */
- t -= LocTimeDiff(t) - get_serverzone();
+ 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;
+
+ ret = timegm(&t);
- d = (double)(t);
- d += TIME_FIXUP_CONSTANT;
- d *= 1.0e7;
+ ret += zone_offset;
- nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
- nt->low = (uint32)(d - ((double)nt->high)*4.0*(double)(1<<30));
+ return(ret);
}
-/****************************************************************************
-convert a time_t to a NTTIME structure
+/*******************************************************************
+ Like make_unix_date() but the words are reversed.
+********************************************************************/
-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)
+static time_t make_unix_date2(const void *date_ptr, int zone_offset)
{
- double d;
+ uint32_t x,x2;
- if (t==0) {
- nt->low = 0;
- nt->high = 0;
- return;
- }
+ x = IVAL(date_ptr,0);
+ x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
+ SIVAL(&x,0,x2);
- if (t == TIME_T_MAX) {
- nt->low = 0xffffffff;
- nt->high = 0x7fffffff;
- return;
- }
-
- if (t == -1) {
- /* that's what NT uses for infinite */
- nt->low = 0x0;
- nt->high = 0x80000000;
- return;
- }
+ return(make_unix_date((const void *)&x, zone_offset));
+}
- /* this converts GMT to kludge-GMT */
- t -= LocTimeDiff(t) - get_serverzone();
+/*******************************************************************
+ Create a unix GMT date from a dos date in 32 bit "unix like" format
+ these generally arrive as localtimes, with corresponding DST.
+******************************************************************/
- d = (double)(t);
- d *= 1.0e7;
+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)) {
+ t += zone_offset;
+ }
+ return(t);
+}
- nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
- nt->low = (uint32)(d - ((double)nt->high)*4.0*(double)(1<<30));
+time_t srv_make_unix_date(const void *date_ptr)
+{
+ return make_unix_date(date_ptr, server_zone_offset);
+}
- /* convert to a negative value */
- nt->high=~nt->high;
- nt->low=~nt->low;
+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(const void *date_ptr)
+{
+ return make_unix_date3(date_ptr, server_zone_offset);
+}
/****************************************************************************
-take an NTTIME structure, containing high / low time. convert to unix time.
-lkclXXXX this may need 2 SIVALs not a memcpy. we'll see...
+ Convert a normalized timeval to a timespec.
****************************************************************************/
-void put_long_date(char *p,time_t t)
+
+struct timespec convert_timeval_to_timespec(const struct timeval tv)
{
- NTTIME nt;
- unix_to_nt_time(&nt, t);
- SIVAL(p, 0, nt.low);
- SIVAL(p, 4, nt.high);
+ struct timespec ts;
+ ts.tv_sec = tv.tv_sec;
+ ts.tv_nsec = tv.tv_usec * 1000;
+ return ts;
}
/****************************************************************************
-check if it's a null mtime
+ Convert a normalized timespec to a timeval.
****************************************************************************/
-BOOL null_mtime(time_t mtime)
+
+struct timeval convert_timespec_to_timeval(const struct timespec ts)
{
- if (mtime == 0 || mtime == 0xFFFFFFFF || mtime == (time_t)-1)
- return(True);
- return(False);
+ struct timeval tv;
+ tv.tv_sec = ts.tv_sec;
+ tv.tv_usec = ts.tv_nsec / 1000;
+ return tv;
}
-/*******************************************************************
- create a 16 bit dos packed date
-********************************************************************/
-static uint16 make_dos_date1(struct tm *t)
+/****************************************************************************
+ Return a timespec for the current time
+****************************************************************************/
+
+struct timespec timespec_current(void)
{
- 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);
+ struct timeval tv;
+ struct timespec ts;
+ GetTimeOfDay(&tv);
+ ts.tv_sec = tv.tv_sec;
+ ts.tv_nsec = tv.tv_usec * 1000;
+ return ts;
}
-/*******************************************************************
- create a 16 bit dos packed time
-********************************************************************/
-static uint16 make_dos_time1(struct tm *t)
+/****************************************************************************
+ Return the lesser of two timespecs.
+****************************************************************************/
+
+struct timespec timespec_min(const struct timespec *ts1,
+ const struct timespec *ts2)
{
- 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 (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;
}
-/*******************************************************************
- 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)
+/****************************************************************************
+ compare two timespec structures.
+ Return -1 if ts1 < ts2
+ Return 0 if ts1 == ts2
+ Return 1 if ts1 > ts2
+****************************************************************************/
+
+int timespec_compare(const struct timespec *ts1, const struct timespec *ts2)
+{
+ 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;
+}
+
+/****************************************************************************
+ 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(const char *p)
{
- struct tm *t;
- uint32 ret=0;
+ 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);
+}
- t = LocalTime(&unixdate);
- if (!t)
- return 0xFFFFFFFF;
+/***************************************************************************
+ Client versions of the above functions.
+***************************************************************************/
- ret = make_dos_date1(t);
- ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
+void cli_put_dos_date(struct cli_state *cli, char *buf, int offset, time_t unixdate)
+{
+ put_dos_date(buf, offset, unixdate, cli->serverzone);
+}
- return(ret);
+void cli_put_dos_date2(struct cli_state *cli, char *buf, int offset, time_t unixdate)
+{
+ put_dos_date2(buf, offset, unixdate, cli->serverzone);
}
-/*******************************************************************
-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)
+void cli_put_dos_date3(struct cli_state *cli, char *buf, int offset, time_t unixdate)
{
- uint32 x = make_dos_date(unixdate);
- SIVAL(buf,offset,x);
+ put_dos_date3(buf, offset, unixdate, cli->serverzone);
}
-/*******************************************************************
-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)
+time_t cli_make_unix_date(struct cli_state *cli, const void *date_ptr)
{
- uint32 x = make_dos_date(unixdate);
- x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
- SIVAL(buf,offset,x);
+ return make_unix_date(date_ptr, cli->serverzone);
}
-/*******************************************************************
-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)
+time_t cli_make_unix_date2(struct cli_state *cli, const void *date_ptr)
{
- if (!null_mtime(unixdate))
- unixdate -= TimeDiff(unixdate);
- SIVAL(buf,offset,unixdate);
+ return make_unix_date2(date_ptr, cli->serverzone);
}
-/*******************************************************************
- 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)
+time_t cli_make_unix_date3(struct cli_state *cli, const void *date_ptr)
{
- uint32 p0,p1,p2,p3;
+ return make_unix_date3(date_ptr, cli->serverzone);
+}
- p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF;
- p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF;
+/****************************************************************************
+ Check if two NTTIMEs are the same.
+****************************************************************************/
- *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;
+bool nt_time_equals(const NTTIME *nt1, const NTTIME *nt2)
+{
+ return (*nt1 == *nt2);
}
/*******************************************************************
- create a unix date (int GMT) from a dos date (which is actually in
- localtime)
-********************************************************************/
-time_t make_unix_date(void *date_ptr)
+ Re-read the smb serverzone value.
+******************************************************************/
+
+static struct timeval start_time_hires;
+
+void TimeInit(void)
{
- uint32 dos_date=0;
- struct tm t;
- time_t ret;
+ set_server_zone_offset(time(NULL));
- dos_date = IVAL(date_ptr,0);
+ DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));
- 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;
-
- /* mktime() also does the local to GMT time conversion for us */
- ret = mktime(&t);
+ /* 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 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.
+***********************************************************************/
- return(ret);
+void get_process_uptime(struct timeval *ret_time)
+{
+ struct timeval time_now_hires;
+
+ 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;
+ }
}
-/*******************************************************************
-like make_unix_date() but the words are reversed
-********************************************************************/
-time_t make_unix_date2(void *date_ptr)
+/****************************************************************************
+ 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)
{
- uint32 x,x2;
+ uint64_t d;
+
+ if (*nt == 0) {
+ return (time_t)0;
+ }
+
+ if (*nt == (uint64_t)-1) {
+ return (time_t)-1;
+ }
- x = IVAL(date_ptr,0);
- x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
- SIVAL(&x,0,x2);
+ if (*nt == NTTIME_INFINITY) {
+ return (time_t)-1;
+ }
+
+ /* reverse the time */
+ /* it's a negative value, turn it to positive */
+ d=~*nt;
+
+ 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(make_unix_date((void *)&x));
+ return (time_t)d;
}
-/*******************************************************************
- 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)
+time_t uint64s_nt_time_to_unix_abs(const uint64_t *src)
{
- time_t t = (time_t)IVAL(date_ptr,0);
- if (!null_mtime(t))
- t += LocTimeDiff(t);
- return(t);
+ NTTIME nttime;
+ nttime = *src;
+ return nt_time_to_unix_abs(&nttime);
}
+/****************************************************************************
+ Put a 8 byte filetime from a struct timespec. Uses GMT.
+****************************************************************************/
-/***************************************************************************
-return a HTTP/1.0 time string
- ***************************************************************************/
-char *http_timestring(time_t t)
+void unix_timespec_to_nt_time(NTTIME *nt, struct timespec ts)
{
- static fstring buf;
- struct tm *tm = LocalTime(&t);
+ uint64_t d;
- 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;
-#else /* !HAVE_STRFTIME */
- strftime(buf, sizeof(buf)-1, "%a, %d %b %Y %H:%M:%S %Z", tm);
-#endif /* !HAVE_STRFTIME */
- return buf;
-}
+ if (ts.tv_sec ==0 && ts.tv_nsec == 0) {
+ *nt = 0;
+ return;
+ }
+ if (ts.tv_sec == TIME_T_MAX) {
+ *nt = 0x7fffffffffffffffLL;
+ return;
+ }
+ if (ts.tv_sec == (time_t)-1) {
+ *nt = (uint64_t)-1;
+ 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 = d;
+}
/****************************************************************************
- Return the date and time as a string
+ 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 time_t was 5 seconds, the NTTIME is 5 seconds. JFM
****************************************************************************/
-char *timestring(BOOL hires)
+void unix_to_nt_time_abs(NTTIME *nt, time_t t)
{
- static fstring TimeBuf;
- struct timeval tp;
- time_t t;
- struct tm *tm;
+ double d;
- if (hires) {
- GetTimeOfDay(&tp);
- t = (time_t)tp.tv_sec;
- } else {
- t = time(NULL);
+ if (t==0) {
+ *nt = 0;
+ return;
}
- 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,100,"%Y/%m/%d %H:%M:%S",tm);
- }
-#else
- if (hires) {
- slprintf(TimeBuf,
- sizeof(TimeBuf)-1,
- "%s.%06ld",
- asctime(tm),
- (long)tp.tv_usec);
- } else {
- fstrcpy(TimeBuf, asctime(tm));
- }
-#endif
+
+ if (t == TIME_T_MAX) {
+ *nt = 0x7fffffffffffffffLL;
+ return;
}
- return(TimeBuf);
+
+ if (t == (time_t)-1) {
+ /* that's what NT uses for infinite */
+ *nt = NTTIME_INFINITY;
+ return;
+ }
+
+ d = (double)(t);
+ d *= 1.0e7;
+
+ *nt = (NTTIME)d;
+
+ /* convert to a negative value */
+ *nt=~*nt;
}
+
/****************************************************************************
- return the best approximation to a 'create time' under UNIX from a stat
- structure.
+ Check if it's a null mtime.
****************************************************************************/
-time_t get_create_time(SMB_STRUCT_STAT *st,BOOL fake_dirs)
+bool null_mtime(time_t mtime)
{
- time_t ret, ret1;
+ if (mtime == 0 || mtime == (time_t)0xFFFFFFFF || mtime == (time_t)-1)
+ return true;
+ return false;
+}
+
+/****************************************************************************
+ Utility function that always returns a const string even if localtime
+ and asctime fail.
+****************************************************************************/
- 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);
+const char *time_to_asc(const time_t t)
+{
+ const char *asct;
+ struct tm *lt = localtime(&t);
- if(ret1 != (time_t)0)
- return ret1;
+ if (!lt) {
+ return "unknown time";
+ }
- /*
- * One of ctime, mtime or atime was zero (probably atime).
- * Just return MIN(ctime, mtime).
- */
- return ret;
+ asct = asctime(lt);
+ if (!asct) {
+ return "unknown time";
+ }
+ return asct;
}
-/****************************************************************************
-initialise an NTTIME to -1, which means "unknown" or "don't expire"
-****************************************************************************/
+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);
-void init_nt_time(NTTIME *nt)
+ 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)
{
- nt->high = 0x7FFFFFFF;
- nt->low = 0xFFFFFFFF;
+ if (*nt == 0x7FFFFFFFFFFFFFFFLL) {
+ return false;
+ }
+
+ if (*nt == NTTIME_INFINITY) {
+ return false;
+ }
+
+ return true;
}
git.samba.org / metze / samba / wip.git / blobdiff