source3/lib/time.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    time handling functions
   4
   5    Copyright (C) Andrew Tridgell                1992-2004
   6    Copyright (C) Stefan (metze) Metzmacher      2002
   7    Copyright (C) Jeremy Allison                 2007
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24
  25 /**
  26  * @file
  27  * @brief time handling functions
  28  */
  29
  30
  31 #define NTTIME_INFINITY (NTTIME)0x8000000000000000LL
  32
  33 #if (SIZEOF_LONG == 8)
  34 #define TIME_FIXUP_CONSTANT_INT 11644473600L
  35 #elif (SIZEOF_LONG_LONG == 8)
  36 #define TIME_FIXUP_CONSTANT_INT 11644473600LL
  37 #endif
  38
  39 /**************************************************************
  40  Handle conversions between time_t and uint32, taking care to
  41  preserve the "special" values.
  42 **************************************************************/
  43
  44 uint32_t convert_time_t_to_uint32_t(time_t t)
  45 {
  46 #if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
  47         /* time_t is 64-bit. */
  48         if (t == 0x8000000000000000LL) {
  49                 return 0x80000000;
  50         } else if (t == 0x7FFFFFFFFFFFFFFFLL) {
  51                 return 0x7FFFFFFF;
  52         }
  53 #endif
  54         return (uint32_t)t;
  55 }
  56
  57 time_t convert_uint32_t_to_time_t(uint32_t u)
  58 {
  59 #if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
  60         /* time_t is 64-bit. */
  61         if (u == 0x80000000) {
  62                 return (time_t)0x8000000000000000LL;
  63         } else if (u == 0x7FFFFFFF) {
  64                 return (time_t)0x7FFFFFFFFFFFFFFFLL;
  65         }
  66 #endif
  67         return (time_t)u;
  68 }
  69
  70 /****************************************************************************
  71  Check if NTTIME is 0.
  72 ****************************************************************************/
  73
  74 bool nt_time_is_zero(const NTTIME *nt)
  75 {
  76         return (*nt == 0);
  77 }
  78
  79 /****************************************************************************
  80  Convert ASN.1 GeneralizedTime string to unix-time.
  81  Returns 0 on failure; Currently ignores timezone.
  82 ****************************************************************************/
  83
  84 time_t generalized_to_unix_time(const char *str)
  85 {
  86         struct tm tm;
  87
  88         ZERO_STRUCT(tm);
  89
  90         if (sscanf(str, "%4d%2d%2d%2d%2d%2d",
  91                    &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
  92                    &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
  93                 return 0;
  94         }
  95         tm.tm_year -= 1900;
  96         tm.tm_mon -= 1;
  97
  98         return timegm(&tm);
  99 }
 100
 101 /*******************************************************************
 102  Accessor function for the server time zone offset.
 103  set_server_zone_offset() must have been called first.
 104 ******************************************************************/
 105
 106 static int server_zone_offset;
 107
 108 int get_server_zone_offset(void)
 109 {
 110         return server_zone_offset;
 111 }
 112
 113 /*******************************************************************
 114  Initialize the server time zone offset. Called when a client connects.
 115 ******************************************************************/
 116
 117 int set_server_zone_offset(time_t t)
 118 {
 119         server_zone_offset = get_time_zone(t);
 120         return server_zone_offset;
 121 }
 122
 123 /***************************************************************************
 124  Server versions of the above functions.
 125 ***************************************************************************/
 126
 127 void srv_put_dos_date(char *buf,int offset,time_t unixdate)
 128 {
 129         push_dos_date((uint8_t *)buf, offset, unixdate, server_zone_offset);
 130 }
 131
 132 void srv_put_dos_date2(char *buf,int offset, time_t unixdate)
 133 {
 134         push_dos_date2((uint8_t *)buf, offset, unixdate, server_zone_offset);
 135 }
 136
 137 void srv_put_dos_date3(char *buf,int offset,time_t unixdate)
 138 {
 139         push_dos_date3((uint8_t *)buf, offset, unixdate, server_zone_offset);
 140 }
 141
 142 void round_timespec(enum timestamp_set_resolution res, struct timespec *ts)
 143 {
 144         if (is_omit_timespec(ts)) {
 145                 return;
 146         }
 147
 148         switch (res) {
 149                 case TIMESTAMP_SET_SECONDS:
 150                         round_timespec_to_sec(ts);
 151                         break;
 152                 case TIMESTAMP_SET_MSEC:
 153                         round_timespec_to_usec(ts);
 154                         break;
 155                 case TIMESTAMP_SET_NT_OR_BETTER:
 156                         /* No rounding needed. */
 157                         break;
 158         }
 159 }
 160
 161 /****************************************************************************
 162  Take a Unix time and convert to an NTTIME structure and place in buffer
 163  pointed to by p, rounded to the correct resolution.
 164 ****************************************************************************/
 165
 166 void put_long_date_timespec(enum timestamp_set_resolution res, char *p, struct timespec ts)
 167 {
 168         NTTIME nt;
 169         round_timespec(res, &ts);
 170         nt = unix_timespec_to_nt_time(ts);
 171         SBVAL(p, 0, nt);
 172 }
 173
 174 void put_long_date_full_timespec(enum timestamp_set_resolution res,
 175                                  char *p,
 176                                  const struct timespec *_ts)
 177 {
 178         struct timespec ts = *_ts;
 179         NTTIME nt;
 180
 181         round_timespec(res, &ts);
 182         nt = full_timespec_to_nt_time(&ts);
 183         SBVAL(p, 0, nt);
 184 }
 185
 186 struct timespec pull_long_date_full_timespec(const char *p)
 187 {
 188         NTTIME nt = BVAL(p, 0);
 189
 190         return nt_time_to_full_timespec(nt);
 191 }
 192
 193 void put_long_date(char *p, time_t t)
 194 {
 195         struct timespec ts;
 196         ts.tv_sec = t;
 197         ts.tv_nsec = 0;
 198         put_long_date_timespec(TIMESTAMP_SET_SECONDS, p, ts);
 199 }
 200
 201 void dos_filetime_timespec(struct timespec *tsp)
 202 {
 203         tsp->tv_sec &= ~1;
 204         tsp->tv_nsec = 0;
 205 }
 206
 207 /*******************************************************************
 208  Create a unix date (int GMT) from a dos date (which is actually in
 209  localtime).
 210 ********************************************************************/
 211
 212 time_t make_unix_date(const void *date_ptr, int zone_offset)
 213 {
 214         return pull_dos_date(date_ptr, zone_offset);
 215 }
 216
 217 /*******************************************************************
 218  Like make_unix_date() but the words are reversed.
 219 ********************************************************************/
 220
 221 time_t make_unix_date2(const void *date_ptr, int zone_offset)
 222 {
 223         return pull_dos_date2(date_ptr, zone_offset);
 224 }
 225
 226 /*******************************************************************
 227  Create a unix GMT date from a dos date in 32 bit "unix like" format
 228  these generally arrive as localtimes, with corresponding DST.
 229 ******************************************************************/
 230
 231 time_t make_unix_date3(const void *date_ptr, int zone_offset)
 232 {
 233         return pull_dos_date3(date_ptr, zone_offset);
 234 }
 235
 236 time_t srv_make_unix_date(const void *date_ptr)
 237 {
 238         return make_unix_date(date_ptr, server_zone_offset);
 239 }
 240
 241 time_t srv_make_unix_date2(const void *date_ptr)
 242 {
 243         return make_unix_date2(date_ptr, server_zone_offset);
 244 }
 245
 246 time_t srv_make_unix_date3(const void *date_ptr)
 247 {
 248         return make_unix_date3(date_ptr, server_zone_offset);
 249 }
 250
 251 /****************************************************************************
 252  Interprets an nt time into a unix struct timespec.
 253  Differs from nt_time_to_unix in that an 8 byte value of 0xffffffffffffffff
 254  will be returned as (time_t)-1, whereas nt_time_to_unix returns 0 in this case.
 255 ****************************************************************************/
 256
 257 struct timespec interpret_long_date(const char *p)
 258 {
 259         NTTIME nt;
 260         nt = BVAL(p, 0);
 261         if (nt == (uint64_t)-1) {
 262                 struct timespec ret;
 263                 ret.tv_sec = (time_t)-1;
 264                 ret.tv_nsec = 0;
 265                 return ret;
 266         }
 267         return nt_time_to_full_timespec(nt);
 268 }
 269
 270 /*******************************************************************
 271  Re-read the smb serverzone value.
 272 ******************************************************************/
 273
 274 static struct timeval start_time_hires;
 275
 276 void TimeInit(void)
 277 {
 278         set_server_zone_offset(time(NULL));
 279
 280         DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));
 281
 282         /* Save the start time of this process. */
 283         if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0) {
 284                 GetTimeOfDay(&start_time_hires);
 285         }
 286 }
 287
 288 /**********************************************************************
 289  Return a timeval struct of the uptime of this process. As TimeInit is
 290  done before a daemon fork then this is the start time from the parent
 291  daemon start. JRA.
 292 ***********************************************************************/
 293
 294 void get_process_uptime(struct timeval *ret_time)
 295 {
 296         struct timeval time_now_hires;
 297
 298         GetTimeOfDay(&time_now_hires);
 299         ret_time->tv_sec = time_now_hires.tv_sec - start_time_hires.tv_sec;
 300         if (time_now_hires.tv_usec < start_time_hires.tv_usec) {
 301                 ret_time->tv_sec -= 1;
 302                 ret_time->tv_usec = 1000000 + (time_now_hires.tv_usec - start_time_hires.tv_usec);
 303         } else {
 304                 ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
 305         }
 306 }
 307
 308 /**
 309  * @brief Get the startup time of the server.
 310  *
 311  * @param[out] ret_time A pointer to a timveal structure to set the startup
 312  *                      time.
 313  */
 314 void get_startup_time(struct timeval *ret_time)
 315 {
 316         ret_time->tv_sec = start_time_hires.tv_sec;
 317         ret_time->tv_usec = start_time_hires.tv_usec;
 318 }
 319
 320
 321 /****************************************************************************
 322  Convert a NTTIME structure to a time_t.
 323  It's originally in "100ns units".
 324
 325  This is an absolute version of the one above.
 326  By absolute I mean, it doesn't adjust from 1/1/1601 to 1/1/1970
 327  if the NTTIME was 5 seconds, the time_t is 5 seconds. JFM
 328 ****************************************************************************/
 329
 330 time_t nt_time_to_unix_abs(const NTTIME *nt)
 331 {
 332         uint64_t d;
 333
 334         if (*nt == 0) {
 335                 return (time_t)0;
 336         }
 337
 338         if (*nt == (uint64_t)-1) {
 339                 return (time_t)-1;
 340         }
 341
 342         if (*nt == NTTIME_INFINITY) {
 343                 return (time_t)-1;
 344         }
 345
 346         /* reverse the time */
 347         /* it's a negative value, turn it to positive */
 348         d=~*nt;
 349
 350         d += 1000*1000*10/2;
 351         d /= 1000*1000*10;
 352
 353         if (!(TIME_T_MIN <= ((time_t)d) && ((time_t)d) <= TIME_T_MAX)) {
 354                 return (time_t)0;
 355         }
 356
 357         return (time_t)d;
 358 }
 359
 360 /****************************************************************************
 361  Convert a time_t to a NTTIME structure
 362
 363  This is an absolute version of the one above.
 364  By absolute I mean, it doesn't adjust from 1/1/1970 to 1/1/1601
 365  If the time_t was 5 seconds, the NTTIME is 5 seconds. JFM
 366 ****************************************************************************/
 367
 368 void unix_to_nt_time_abs(NTTIME *nt, time_t t)
 369 {
 370         double d;
 371
 372         if (t==0) {
 373                 *nt = 0;
 374                 return;
 375         }
 376
 377         if (t == TIME_T_MAX) {
 378                 *nt = 0x7fffffffffffffffLL;
 379                 return;
 380         }
 381
 382         if (t == (time_t)-1) {
 383                 /* that's what NT uses for infinite */
 384                 *nt = NTTIME_INFINITY;
 385                 return;
 386         }
 387
 388         d = (double)(t);
 389         d *= 1.0e7;
 390
 391         *nt = (NTTIME)d;
 392
 393         /* convert to a negative value */
 394         *nt=~*nt;
 395 }
 396
 397
 398 /****************************************************************************
 399  Utility function that always returns a const string even if localtime
 400  and asctime fail.
 401 ****************************************************************************/
 402
 403 const char *time_to_asc(const time_t t)
 404 {
 405         const char *asct;
 406         struct tm *lt = localtime(&t);
 407
 408         if (!lt) {
 409                 return "unknown time";
 410         }
 411
 412         asct = asctime(lt);
 413         if (!asct) {
 414                 return "unknown time";
 415         }
 416         return asct;
 417 }
 418
 419 const char *display_time(NTTIME nttime)
 420 {
 421         float high;
 422         float low;
 423         int sec;
 424         int days, hours, mins, secs;
 425
 426         if (nttime==0)
 427                 return "Now";
 428
 429         if (nttime==NTTIME_INFINITY)
 430                 return "Never";
 431
 432         high = 65536;
 433         high = high/10000;
 434         high = high*65536;
 435         high = high/1000;
 436         high = high * (~(nttime >> 32));
 437
 438         low = ~(nttime & 0xFFFFFFFF);
 439         low = low/(1000*1000*10);
 440
 441         sec=(int)(high+low);
 442
 443         days=sec/(60*60*24);
 444         hours=(sec - (days*60*60*24)) / (60*60);
 445         mins=(sec - (days*60*60*24) - (hours*60*60) ) / 60;
 446         secs=sec - (days*60*60*24) - (hours*60*60) - (mins*60);
 447
 448         return talloc_asprintf(talloc_tos(), "%u days, %u hours, %u minutes, "
 449                                "%u seconds", days, hours, mins, secs);
 450 }
 451
 452 bool nt_time_is_set(const NTTIME *nt)
 453 {
 454         if (*nt == 0x7FFFFFFFFFFFFFFFLL) {
 455                 return false;
 456         }
 457
 458         if (*nt == NTTIME_INFINITY) {
 459                 return false;
 460         }
 461
 462         return true;
 463 }