/*

   Unix SMB/CIFS implementation.

   time handling functions

   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 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/>.

*/

#include "includes.h"

/**

 * @file

 * @brief time handling functions

 */

#define NTTIME_INFINITY (NTTIME)0x8000000000000000LL

#define TIME_FIXUP_CONSTANT_INT INT64_C(11644473600)

/**************************************************************

 Handle conversions between time_t and uint32, taking care to

 preserve the "special" values.

**************************************************************/

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. */

  if (t == 0x8000000000000000LL) {

    return 0x80000000;

  } else if (t == 0x7FFFFFFFFFFFFFFFLL) {

    return 0x7FFFFFFF;

  }

#endif

  return (uint32_t)t;

}

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. */

  if (u == 0x80000000) {

    return (time_t)0x8000000000000000LL;

  } else if (u == 0x7FFFFFFF) {

    return (time_t)0x7FFFFFFFFFFFFFFFLL;

  }

#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;

  }

  tm.tm_year -= 1900;

  tm.tm_mon -= 1;

  return timegm(&tm);

}

/*******************************************************************

 Accessor function for the server time zone offset.

 set_server_zone_offset() must have been called first.

******************************************************************/

static int server_zone_offset;

int get_server_zone_offset(void)

{

  return server_zone_offset;

}

/*******************************************************************

 Initialize the server time zone offset. Called when a client connects.

******************************************************************/

int set_server_zone_offset(time_t t)

{

  server_zone_offset = get_time_zone(t);

  return server_zone_offset;

}

/***************************************************************************

 Server versions of the above functions.

***************************************************************************/

void srv_put_dos_date(char *buf,int offset,time_t unixdate)

{

  push_dos_date((uint8_t *)buf, offset, unixdate, server_zone_offset);

}

void srv_put_dos_date2_ts(char *buf, int offset, struct timespec unix_ts)

{

  time_t unixdate = convert_timespec_to_time_t(unix_ts);

  push_dos_date2((uint8_t *)buf, offset, unixdate, server_zone_offset);

}

void srv_put_dos_date3(char *buf,int offset,time_t unixdate)

{

  push_dos_date3((uint8_t *)buf, offset, unixdate, server_zone_offset);

}

void round_timespec(enum timestamp_set_resolution res, struct timespec *ts)

{

  if (is_omit_timespec(ts)) {

    return;

  }

  switch (res) {

    case TIMESTAMP_SET_SECONDS:

      round_timespec_to_sec(ts);

      break;

    case TIMESTAMP_SET_MSEC:

      round_timespec_to_usec(ts);

      break;

    case TIMESTAMP_SET_NT_OR_BETTER:

      /* No rounding needed. */

      break;

        }

}

/****************************************************************************

 Take a Unix time and convert to an NTTIME structure and place in buffer

 pointed to by p, rounded to the correct resolution.

****************************************************************************/

void put_long_date_timespec(enum timestamp_set_resolution res, char *p, struct timespec ts)

{

  NTTIME nt;

  round_timespec(res, &ts);

  nt = unix_timespec_to_nt_time(ts);

  SBVAL(p, 0, nt);

}

void put_long_date_full_timespec(enum timestamp_set_resolution res,

         char *p,

         const struct timespec *_ts)

{

  struct timespec ts = *_ts;

  NTTIME nt;

  round_timespec(res, &ts);

  nt = full_timespec_to_nt_time(&ts);

  SBVAL(p, 0, nt);

}

struct timespec pull_long_date_full_timespec(const char *p)

{

  NTTIME nt = BVAL(p, 0);

  return nt_time_to_full_timespec(nt);

}

void put_long_date(char *p, time_t t)

{

  struct timespec ts;

  ts.tv_sec = t;

  ts.tv_nsec = 0;

  put_long_date_timespec(TIMESTAMP_SET_SECONDS, p, ts);

}

void dos_filetime_timespec(struct timespec *tsp)

{

  tsp->tv_sec &= ~1;

  tsp->tv_nsec = 0;

}

/*******************************************************************

 Create a unix date (int GMT) from a dos date (which is actually in

 localtime).

********************************************************************/

time_t make_unix_date(const void *date_ptr, int zone_offset)

{

  return pull_dos_date(date_ptr, zone_offset);

}

/*******************************************************************

 Like make_unix_date() but the words are reversed.

********************************************************************/

time_t make_unix_date2(const void *date_ptr, int zone_offset)

{

  return pull_dos_date2(date_ptr, zone_offset);

}

/*******************************************************************

 Create a unix GMT date from a dos date in 32 bit "unix like" format

 these generally arrive as localtimes, with corresponding DST.

******************************************************************/

time_t make_unix_date3(const void *date_ptr, int zone_offset)

{

  return pull_dos_date3(date_ptr, zone_offset);

}

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(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);

}

/****************************************************************************

 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(NTTIME nt)

{

  if (nt == (uint64_t)-1) {

    struct timespec ret;

    ret.tv_sec = (time_t)-1;

    ret.tv_nsec = 0;

    return ret;

  }

  return nt_time_to_full_timespec(nt);

}

/*******************************************************************

 Re-read the smb serverzone value.

******************************************************************/

static struct timeval start_time_hires;

void TimeInit(void)

{

  set_server_zone_offset(time(NULL));

  DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));

  /* Save the start time of this process. */

  if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0) {

    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.

***********************************************************************/

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;

  }

}

/**

 * @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".

 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_t d;

  if (*nt == 0) {

    return (time_t)0;

  }

  if (*nt == (uint64_t)-1) {

    return (time_t)-1;

  }

  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 (time_t)d;

}

/****************************************************************************

 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

****************************************************************************/

void unix_to_nt_time_abs(NTTIME *nt, time_t t)

{

  double d;

  if (t==0) {

    *nt = 0;

    return;

  }

  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;

  *nt = (NTTIME)d;

  /* convert to a negative value */

  *nt=~*nt;

}

/****************************************************************************

 Utility function that always returns a const string even if localtime

 and asctime fail.

****************************************************************************/

const char *time_to_asc(const time_t t)

{

  const char *asct;

  struct tm *lt = localtime(&t);

  if (!lt) {

    return "unknown time\n";

  }

  asct = asctime(lt);

  if (!asct) {

    return "unknown time\n";

  }

  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;

}