-/*
+/*
Unix SMB/CIFS implementation.
time handling functions
Copyright (C) Andrew Tridgell 1992-2004
- Copyright (C) Stefan (metze) Metzmacher 2002
+ 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 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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, see <http://www.gnu.org/licenses/>.
*/
preserve the "special" values.
**************************************************************/
-uint32_t convert_time_t_to_uint32(time_t t)
+uint32_t convert_time_t_to_uint32_t(time_t t)
{
#if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
/* time_t is 64-bit. */
return (uint32_t)t;
}
-time_t convert_uint32_to_time_t(uint32_t u)
+time_t convert_uint32_t_to_time_t(uint32_t u)
{
#if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
/* time_t is 64-bit. */
/****************************************************************************
Convert ASN.1 GeneralizedTime string to unix-time.
- Returns 0 on failure; Currently ignores timezone.
+ 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,
+ 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 server_zone_offset;
}
-/****************************************************************************
- Return the date and time as a string
-****************************************************************************/
-
-char *timeval_string(TALLOC_CTX *ctx, const struct timeval *tp, bool hires)
-{
- fstring TimeBuf;
- time_t t;
- struct tm *tm;
-
- t = (time_t)tp->tv_sec;
- 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);
-}
-
-char *current_timestring(TALLOC_CTX *ctx, bool hires)
-{
- struct timeval tv;
-
- GetTimeOfDay(&tv);
- return timeval_string(ctx, &tv, hires);
-}
-
-
-
/***************************************************************************
Server versions of the above functions.
***************************************************************************/
}
/****************************************************************************
- Take a Unix time and convert to an NTTIME structure and place in buffer
+ Take a Unix time and convert to an NTTIME structure and place in buffer
pointed to by p, rounded to the correct resolution.
****************************************************************************/
{
NTTIME nt;
round_timespec(res, &ts);
- unix_timespec_to_nt_time(&nt, ts);
- SIVAL(p, 0, nt & 0xFFFFFFFF);
- SIVAL(p, 4, nt >> 32);
+ nt = unix_timespec_to_nt_time(ts);
+ SBVAL(p, 0, nt);
}
void put_long_date(char *p, time_t t)
localtime).
********************************************************************/
-static time_t make_unix_date(const void *date_ptr, int zone_offset)
+time_t make_unix_date(const void *date_ptr, int zone_offset)
{
- uint32_t dos_date=0;
- struct tm t;
- time_t ret;
-
- dos_date = IVAL(date_ptr,0);
-
- if (dos_date == 0) {
- return 0;
- }
-
- interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
- &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
- t.tm_isdst = -1;
-
- ret = timegm(&t);
-
- ret += zone_offset;
-
- return(ret);
+ return pull_dos_date(date_ptr, zone_offset);
}
/*******************************************************************
time_t make_unix_date2(const void *date_ptr, int zone_offset)
{
- uint32_t x,x2;
-
- x = IVAL(date_ptr,0);
- x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
- SIVAL(&x,0,x2);
-
- return(make_unix_date((const void *)&x, zone_offset));
+ return pull_dos_date2(date_ptr, zone_offset);
}
/*******************************************************************
time_t make_unix_date3(const void *date_ptr, int zone_offset)
{
- time_t t = (time_t)IVAL(date_ptr,0);
- if (!null_time(t)) {
- t += zone_offset;
- }
- return(t);
+ return pull_dos_date3(date_ptr, zone_offset);
}
time_t srv_make_unix_date(const void *date_ptr)
return make_unix_date3(date_ptr, server_zone_offset);
}
-/****************************************************************************
- Convert a normalized timeval to a timespec.
-****************************************************************************/
-
-struct timespec convert_timeval_to_timespec(const struct timeval tv)
-{
- struct timespec ts;
- ts.tv_sec = tv.tv_sec;
- ts.tv_nsec = tv.tv_usec * 1000;
- return ts;
-}
-
-/****************************************************************************
- Convert a normalized timespec to a timeval.
-****************************************************************************/
-
-struct timeval convert_timespec_to_timeval(const struct timespec ts)
-{
- struct timeval tv;
- tv.tv_sec = ts.tv_sec;
- tv.tv_usec = ts.tv_nsec / 1000;
- return tv;
-}
-
-/****************************************************************************
- Return a timespec for the current time
-****************************************************************************/
-
-struct timespec timespec_current(void)
-{
- struct timeval tv;
- struct timespec ts;
- GetTimeOfDay(&tv);
- ts.tv_sec = tv.tv_sec;
- ts.tv_nsec = tv.tv_usec * 1000;
- return ts;
-}
-
-/****************************************************************************
- Return the lesser of two timespecs.
-****************************************************************************/
-
-struct timespec timespec_min(const struct timespec *ts1,
- const struct timespec *ts2)
-{
- 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;
-}
-
-/****************************************************************************
- 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;
-}
-
-/****************************************************************************
- Round up a timespec if nsec > 500000000, round down if lower,
- then zero nsec.
-****************************************************************************/
-
-void round_timespec_to_sec(struct timespec *ts)
-{
- ts->tv_sec = convert_timespec_to_time_t(*ts);
- ts->tv_nsec = 0;
-}
-
-/****************************************************************************
- Round a timespec to usec value.
-****************************************************************************/
-
-void round_timespec_to_usec(struct timespec *ts)
-{
- struct timeval tv = convert_timespec_to_timeval(*ts);
- *ts = convert_timeval_to_timespec(tv);
-}
-
/****************************************************************************
Interprets an nt time into a unix struct timespec.
Differs from nt_time_to_unix in that an 8 byte value of 0xffffffffffffffff
struct timespec interpret_long_date(const char *p)
{
NTTIME nt;
- nt = IVAL(p,0) + ((uint64_t)IVAL(p,4) << 32);
+ nt = BVAL(p, 0);
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);
-}
-
-/***************************************************************************
- Client versions of the above functions.
-***************************************************************************/
-
-void cli_put_dos_date(struct cli_state *cli, char *buf, int offset, time_t unixdate)
-{
- push_dos_date((uint8_t *)buf, offset, unixdate, cli->serverzone);
-}
-
-void cli_put_dos_date2(struct cli_state *cli, char *buf, int offset, time_t unixdate)
-{
- push_dos_date2((uint8_t *)buf, offset, unixdate, cli->serverzone);
-}
-
-void cli_put_dos_date3(struct cli_state *cli, char *buf, int offset, time_t unixdate)
-{
- push_dos_date3((uint8_t *)buf, offset, unixdate, cli->serverzone);
+ return nt_time_to_unix_timespec(nt);
}
-time_t cli_make_unix_date(struct cli_state *cli, const void *date_ptr)
-{
- return make_unix_date(date_ptr, cli->serverzone);
-}
-
-time_t cli_make_unix_date2(struct cli_state *cli, const void *date_ptr)
-{
- return make_unix_date2(date_ptr, cli->serverzone);
-}
-
-time_t cli_make_unix_date3(struct cli_state *cli, const void *date_ptr)
-{
- return make_unix_date3(date_ptr, cli->serverzone);
-}
-
-
/*******************************************************************
Re-read the smb serverzone value.
******************************************************************/
}
}
+/**
+ * @brief Get the startup time of the server.
+ *
+ * @param[out] ret_time A pointer to a timveal structure to set the startup
+ * time.
+ */
+void get_startup_time(struct timeval *ret_time)
+{
+ ret_time->tv_sec = start_time_hires.tv_sec;
+ ret_time->tv_usec = start_time_hires.tv_usec;
+}
+
+
/****************************************************************************
Convert a NTTIME structure to a time_t.
It's originally in "100ns units".
return nt_time_to_unix_abs(&nttime);
}
-/****************************************************************************
- Put a 8 byte filetime from a struct timespec. Uses GMT.
-****************************************************************************/
-
-void unix_timespec_to_nt_time(NTTIME *nt, struct timespec ts)
-{
- uint64_t d;
-
- 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;
-}
-
-#if 0
-void nt_time_to_unix_timespec(struct timespec *ts, NTTIME t)
-{
- if (ts == NULL) {
- return;
- }
-
- /* t starts in 100 nsec units since 1601-01-01. */
-
- t *= 100;
- /* t is now in nsec units since 1601-01-01. */
-
- t -= TIME_FIXUP_CONSTANT*1000*1000*100;
- /* t is now in nsec units since the UNIX epoch 1970-01-01. */
-
- ts->tv_sec = t / 1000000000LL;
-
- if (TIME_T_MIN > ts->tv_sec || ts->tv_sec > TIME_T_MAX) {
- ts->tv_sec = 0;
- ts->tv_nsec = 0;
- return;
- }
-
- ts->tv_nsec = t - ts->tv_sec*1000000000LL;
-}
-#endif
-
/****************************************************************************
Convert a time_t to a NTTIME structure
*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;
if (nttime==NTTIME_INFINITY)
return "Never";
- high = 65536;
+ high = 65536;
high = high/10000;
high = high*65536;
high = high/1000;
git.samba.org / samba.git / blobdiff