source/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 #ifndef TIME_T_MIN
  32 #define TIME_T_MIN ((time_t)0 < (time_t) -1 ? (time_t) 0 \
  33                     : ~ (time_t) 0 << (sizeof (time_t) * CHAR_BIT - 1))
  34 #endif
  35 #ifndef TIME_T_MAX
  36 #define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
  37 #endif
  38
  39 #define NTTIME_INFINITY (NTTIME)0x8000000000000000LL
  40
  41 /***************************************************************************
  42  External access to time_t_min and time_t_max.
  43 ****************************************************************************/
  44
  45 time_t get_time_t_max(void)
  46 {
  47         return TIME_T_MAX;
  48 }
  49
  50 /***************************************************************************
  51  A gettimeofday wrapper.
  52 ****************************************************************************/
  53
  54 void GetTimeOfDay(struct timeval *tval)
  55 {
  56 #ifdef HAVE_GETTIMEOFDAY_TZ
  57         gettimeofday(tval,NULL);
  58 #else
  59         gettimeofday(tval);
  60 #endif
  61 }
  62
  63 #if (SIZEOF_LONG == 8)
  64 #define TIME_FIXUP_CONSTANT_INT 11644473600L
  65 #elif (SIZEOF_LONG_LONG == 8)
  66 #define TIME_FIXUP_CONSTANT_INT 11644473600LL
  67 #endif
  68
  69 /****************************************************************************
  70  Interpret an 8 byte "filetime" structure to a time_t
  71  It's originally in "100ns units since jan 1st 1601"
  72
  73  An 8 byte value of 0xffffffffffffffff will be returned as a timespec of
  74
  75         tv_sec = 0
  76         tv_nsec = 0;
  77
  78  Returns GMT.
  79 ****************************************************************************/
  80
  81 time_t nt_time_to_unix(NTTIME nt)
  82 {
  83         return convert_timespec_to_time_t(nt_time_to_unix_timespec(&nt));
  84 }
  85
  86 /****************************************************************************
  87  Put a 8 byte filetime from a time_t. Uses GMT.
  88 ****************************************************************************/
  89
  90 void unix_to_nt_time(NTTIME *nt, time_t t)
  91 {
  92         uint64_t t2;
  93
  94         if (t == (time_t)-1) {
  95                 *nt = (NTTIME)-1LL;
  96                 return;
  97         }
  98
  99         if (t == TIME_T_MAX) {
 100                 *nt = 0x7fffffffffffffffLL;
 101                 return;
 102         }
 103
 104         if (t == 0) {
 105                 *nt = 0;
 106                 return;
 107         }
 108
 109         t2 = t;
 110         t2 += TIME_FIXUP_CONSTANT_INT;
 111         t2 *= 1000*1000*10;
 112
 113         *nt = t2;
 114 }
 115
 116 /****************************************************************************
 117  Check if it's a null unix time.
 118 ****************************************************************************/
 119
 120 bool null_time(time_t t)
 121 {
 122         return t == 0 ||
 123                 t == (time_t)0xFFFFFFFF ||
 124                 t == (time_t)-1;
 125 }
 126
 127 /****************************************************************************
 128  Check if it's a null NTTIME.
 129 ****************************************************************************/
 130
 131 bool null_nttime(NTTIME t)
 132 {
 133         return t == 0 || t == (NTTIME)-1;
 134 }
 135
 136 /****************************************************************************
 137  Check if it's a null timespec.
 138 ****************************************************************************/
 139
 140 bool null_timespec(struct timespec ts)
 141 {
 142         return ts.tv_sec == 0 ||
 143                 ts.tv_sec == (time_t)0xFFFFFFFF ||
 144                 ts.tv_sec == (time_t)-1;
 145 }
 146
 147 /*******************************************************************
 148   create a 16 bit dos packed date
 149 ********************************************************************/
 150 static uint16_t make_dos_date1(struct tm *t)
 151 {
 152         uint16_t ret=0;
 153         ret = (((unsigned int)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
 154         ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5));
 155         return ret;
 156 }
 157
 158 /*******************************************************************
 159   create a 16 bit dos packed time
 160 ********************************************************************/
 161 static uint16_t make_dos_time1(struct tm *t)
 162 {
 163         uint16_t ret=0;
 164         ret = ((((unsigned int)t->tm_min >> 3)&0x7) | (((unsigned int)t->tm_hour) << 3));
 165         ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
 166         return ret;
 167 }
 168
 169 /*******************************************************************
 170   create a 32 bit dos packed date/time from some parameters
 171   This takes a GMT time and returns a packed localtime structure
 172 ********************************************************************/
 173 static uint32_t make_dos_date(time_t unixdate, int zone_offset)
 174 {
 175         struct tm *t;
 176         uint32_t ret=0;
 177
 178         if (unixdate == 0) {
 179                 return 0;
 180         }
 181
 182         unixdate -= zone_offset;
 183
 184         t = gmtime(&unixdate);
 185         if (!t) {
 186                 return 0xFFFFFFFF;
 187         }
 188
 189         ret = make_dos_date1(t);
 190         ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
 191
 192         return ret;
 193 }
 194
 195 /**
 196 put a dos date into a buffer (time/date format)
 197 This takes GMT time and puts local time in the buffer
 198 **/
 199 void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
 200 {
 201         uint32_t x = make_dos_date(unixdate, zone_offset);
 202         SIVAL(buf,offset,x);
 203 }
 204
 205 /**
 206 put a dos date into a buffer (date/time format)
 207 This takes GMT time and puts local time in the buffer
 208 **/
 209 void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 210 {
 211         uint32_t x;
 212         x = make_dos_date(unixdate, zone_offset);
 213         x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
 214         SIVAL(buf,offset,x);
 215 }
 216
 217 /**
 218 put a dos 32 bit "unix like" date into a buffer. This routine takes
 219 GMT and converts it to LOCAL time before putting it (most SMBs assume
 220 localtime for this sort of date)
 221 **/
 222 void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 223 {
 224         if (!null_time(unixdate)) {
 225                 unixdate -= zone_offset;
 226         }
 227         SIVAL(buf,offset,unixdate);
 228 }
 229
 230 /*******************************************************************
 231   interpret a 32 bit dos packed date/time to some parameters
 232 ********************************************************************/
 233 static void interpret_dos_date(uint32_t date,int *year,int *month,int *day,int *hour,int *minute,int *second)
 234 {
 235         uint32_t p0,p1,p2,p3;
 236
 237         p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF;
 238         p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF;
 239
 240         *second = 2*(p0 & 0x1F);
 241         *minute = ((p0>>5)&0xFF) + ((p1&0x7)<<3);
 242         *hour = (p1>>3)&0xFF;
 243         *day = (p2&0x1F);
 244         *month = ((p2>>5)&0xFF) + ((p3&0x1)<<3) - 1;
 245         *year = ((p3>>1)&0xFF) + 80;
 246 }
 247
 248 /**
 249   create a unix date (int GMT) from a dos date (which is actually in
 250   localtime)
 251 **/
 252 time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
 253 {
 254         uint32_t dos_date=0;
 255         struct tm t;
 256         time_t ret;
 257
 258         dos_date = IVAL(date_ptr,0);
 259
 260         if (dos_date == 0) return (time_t)0;
 261
 262         interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
 263                            &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
 264         t.tm_isdst = -1;
 265
 266         ret = timegm(&t);
 267
 268         ret += zone_offset;
 269
 270         return ret;
 271 }
 272
 273 /**
 274 like make_unix_date() but the words are reversed
 275 **/
 276 time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
 277 {
 278         uint32_t x,x2;
 279
 280         x = IVAL(date_ptr,0);
 281         x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
 282         SIVAL(&x,0,x2);
 283
 284         return pull_dos_date((const uint8_t *)&x, zone_offset);
 285 }
 286
 287 /**
 288   create a unix GMT date from a dos date in 32 bit "unix like" format
 289   these generally arrive as localtimes, with corresponding DST
 290 **/
 291 time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
 292 {
 293         time_t t = (time_t)IVAL(date_ptr,0);
 294         if (!null_time(t)) {
 295                 t += zone_offset;
 296         }
 297         return t;
 298 }
 299
 300 /***************************************************************************
 301  Return a HTTP/1.0 time string.
 302 ***************************************************************************/
 303
 304 char *http_timestring(time_t t)
 305 {
 306         fstring buf;
 307         struct tm *tm = localtime(&t);
 308
 309         if (t == TIME_T_MAX) {
 310                 fstrcpy(buf, "never");
 311         } else if (!tm) {
 312                 fstr_sprintf(buf, "%ld seconds since the Epoch", (long)t);
 313         } else {
 314 #ifndef HAVE_STRFTIME
 315                 const char *asct = asctime(tm);
 316                 fstrcpy(buf, asct ? asct : "unknown");
 317         }
 318         if(buf[strlen(buf)-1] == '\n') {
 319                 buf[strlen(buf)-1] = 0;
 320 #else /* !HAVE_STRFTIME */
 321                 strftime(buf, sizeof(buf)-1, "%a, %d %b %Y %H:%M:%S %Z", tm);
 322 #endif /* !HAVE_STRFTIME */
 323         }
 324         return talloc_strdup(talloc_tos(), buf);
 325 }
 326
 327
 328 /**
 329  Return the date and time as a string
 330 **/
 331 char *timestring(TALLOC_CTX *mem_ctx, time_t t)
 332 {
 333         char *TimeBuf;
 334         char tempTime[80];
 335         struct tm *tm;
 336
 337         tm = localtime(&t);
 338         if (!tm) {
 339                 return talloc_asprintf(mem_ctx,
 340                                        "%ld seconds since the Epoch",
 341                                        (long)t);
 342         }
 343
 344 #ifdef HAVE_STRFTIME
 345         /* some versions of gcc complain about using %c. This is a bug
 346            in the gcc warning, not a bug in this code. See a recent
 347            strftime() manual page for details.
 348          */
 349         strftime(tempTime,sizeof(tempTime)-1,"%c %Z",tm);
 350         TimeBuf = talloc_strdup(mem_ctx, tempTime);
 351 #else
 352         TimeBuf = talloc_strdup(mem_ctx, asctime(tm));
 353 #endif
 354
 355         return TimeBuf;
 356 }
 357
 358 /**
 359   return a talloced string representing a NTTIME for human consumption
 360 */
 361 const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
 362 {
 363         time_t t;
 364         if (nt == 0) {
 365                 return "NTTIME(0)";
 366         }
 367         t = nt_time_to_unix(nt);
 368         return timestring(mem_ctx, t);
 369 }
 370
 371
 372 /**
 373   parse a nttime as a large integer in a string and return a NTTIME
 374 */
 375 NTTIME nttime_from_string(const char *s)
 376 {
 377         return strtoull(s, NULL, 0);
 378 }
 379
 380 /**
 381   return (tv1 - tv2) in microseconds
 382 */
 383 int64_t usec_time_diff(struct timeval *tv1, struct timeval *tv2)
 384 {
 385         int64_t sec_diff = tv1->tv_sec - tv2->tv_sec;
 386         return (sec_diff * 1000000) + (int64_t)(tv1->tv_usec - tv2->tv_usec);
 387 }
 388
 389
 390 /**
 391   return a zero timeval
 392 */
 393 struct timeval timeval_zero(void)
 394 {
 395         struct timeval tv;
 396         tv.tv_sec = 0;
 397         tv.tv_usec = 0;
 398         return tv;
 399 }
 400
 401 /**
 402   return True if a timeval is zero
 403 */
 404 bool timeval_is_zero(const struct timeval *tv)
 405 {
 406         return tv->tv_sec == 0 && tv->tv_usec == 0;
 407 }
 408
 409 /**
 410   return a timeval for the current time
 411 */
 412 struct timeval timeval_current(void)
 413 {
 414         struct timeval tv;
 415         GetTimeOfDay(&tv);
 416         return tv;
 417 }
 418
 419 /**
 420   return a timeval struct with the given elements
 421 */
 422 struct timeval timeval_set(uint32_t secs, uint32_t usecs)
 423 {
 424         struct timeval tv;
 425         tv.tv_sec = secs;
 426         tv.tv_usec = usecs;
 427         return tv;
 428 }
 429
 430
 431 /**
 432   return a timeval ofs microseconds after tv
 433 */
 434 struct timeval timeval_add(const struct timeval *tv,
 435                            uint32_t secs, uint32_t usecs)
 436 {
 437         struct timeval tv2 = *tv;
 438         const unsigned int million = 1000000;
 439         tv2.tv_sec += secs;
 440         tv2.tv_usec += usecs;
 441         tv2.tv_sec += tv2.tv_usec / million;
 442         tv2.tv_usec = tv2.tv_usec % million;
 443         return tv2;
 444 }
 445
 446 /**
 447   return the sum of two timeval structures
 448 */
 449 struct timeval timeval_sum(const struct timeval *tv1,
 450                            const struct timeval *tv2)
 451 {
 452         return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
 453 }
 454
 455 /**
 456   return a timeval secs/usecs into the future
 457 */
 458 struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
 459 {
 460         struct timeval tv = timeval_current();
 461         return timeval_add(&tv, secs, usecs);
 462 }
 463
 464 /**
 465   compare two timeval structures.
 466   Return -1 if tv1 < tv2
 467   Return 0 if tv1 == tv2
 468   Return 1 if tv1 > tv2
 469 */
 470 int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
 471 {
 472         if (tv1->tv_sec  > tv2->tv_sec)  return 1;
 473         if (tv1->tv_sec  < tv2->tv_sec)  return -1;
 474         if (tv1->tv_usec > tv2->tv_usec) return 1;
 475         if (tv1->tv_usec < tv2->tv_usec) return -1;
 476         return 0;
 477 }
 478
 479 /**
 480   return True if a timer is in the past
 481 */
 482 bool timeval_expired(const struct timeval *tv)
 483 {
 484         struct timeval tv2 = timeval_current();
 485         if (tv2.tv_sec > tv->tv_sec) return True;
 486         if (tv2.tv_sec < tv->tv_sec) return False;
 487         return (tv2.tv_usec >= tv->tv_usec);
 488 }
 489
 490 /**
 491   return the number of seconds elapsed between two times
 492 */
 493 double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
 494 {
 495         return (tv2->tv_sec - tv1->tv_sec) +
 496                (tv2->tv_usec - tv1->tv_usec)*1.0e-6;
 497 }
 498
 499 /**
 500   return the number of seconds elapsed since a given time
 501 */
 502 double timeval_elapsed(const struct timeval *tv)
 503 {
 504         struct timeval tv2 = timeval_current();
 505         return timeval_elapsed2(tv, &tv2);
 506 }
 507
 508 /**
 509   return the lesser of two timevals
 510 */
 511 struct timeval timeval_min(const struct timeval *tv1,
 512                            const struct timeval *tv2)
 513 {
 514         if (tv1->tv_sec < tv2->tv_sec) return *tv1;
 515         if (tv1->tv_sec > tv2->tv_sec) return *tv2;
 516         if (tv1->tv_usec < tv2->tv_usec) return *tv1;
 517         return *tv2;
 518 }
 519
 520 /**
 521   return the greater of two timevals
 522 */
 523 struct timeval timeval_max(const struct timeval *tv1,
 524                            const struct timeval *tv2)
 525 {
 526         if (tv1->tv_sec > tv2->tv_sec) return *tv1;
 527         if (tv1->tv_sec < tv2->tv_sec) return *tv2;
 528         if (tv1->tv_usec > tv2->tv_usec) return *tv1;
 529         return *tv2;
 530 }
 531
 532 /**
 533   return the difference between two timevals as a timeval
 534   if tv1 comes after tv2, then return a zero timeval
 535   (this is *tv2 - *tv1)
 536 */
 537 struct timeval timeval_until(const struct timeval *tv1,
 538                              const struct timeval *tv2)
 539 {
 540         struct timeval t;
 541         if (timeval_compare(tv1, tv2) >= 0) {
 542                 return timeval_zero();
 543         }
 544         t.tv_sec = tv2->tv_sec - tv1->tv_sec;
 545         if (tv1->tv_usec > tv2->tv_usec) {
 546                 t.tv_sec--;
 547                 t.tv_usec = 1000000 - (tv1->tv_usec - tv2->tv_usec);
 548         } else {
 549                 t.tv_usec = tv2->tv_usec - tv1->tv_usec;
 550         }
 551         return t;
 552 }
 553
 554
 555 /**
 556   convert a timeval to a NTTIME
 557 */
 558 NTTIME timeval_to_nttime(const struct timeval *tv)
 559 {
 560         return 10*(tv->tv_usec +
 561                   ((TIME_FIXUP_CONSTANT_INT + (uint64_t)tv->tv_sec) * 1000000));
 562 }
 563
 564 /**************************************************************
 565  Handle conversions between time_t and uint32, taking care to
 566  preserve the "special" values.
 567 **************************************************************/
 568
 569 uint32 convert_time_t_to_uint32(time_t t)
 570 {
 571 #if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
 572         /* time_t is 64-bit. */
 573         if (t == 0x8000000000000000LL) {
 574                 return 0x80000000;
 575         } else if (t == 0x7FFFFFFFFFFFFFFFLL) {
 576                 return 0x7FFFFFFF;
 577         }
 578 #endif
 579         return (uint32)t;
 580 }
 581
 582 time_t convert_uint32_to_time_t(uint32 u)
 583 {
 584 #if (defined(SIZEOF_TIME_T) && (SIZEOF_TIME_T == 8))
 585         /* time_t is 64-bit. */
 586         if (u == 0x80000000) {
 587                 return (time_t)0x8000000000000000LL;
 588         } else if (u == 0x7FFFFFFF) {
 589                 return (time_t)0x7FFFFFFFFFFFFFFFLL;
 590         }
 591 #endif
 592         return (time_t)u;
 593 }
 594
 595 /*******************************************************************
 596  Yield the difference between *A and *B, in seconds, ignoring leap seconds.
 597 ********************************************************************/
 598
 599 static int tm_diff(struct tm *a, struct tm *b)
 600 {
 601         int ay = a->tm_year + (1900 - 1);
 602         int by = b->tm_year + (1900 - 1);
 603         int intervening_leap_days =
 604                 (ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400);
 605         int years = ay - by;
 606         int days = 365*years + intervening_leap_days + (a->tm_yday - b->tm_yday);
 607         int hours = 24*days + (a->tm_hour - b->tm_hour);
 608         int minutes = 60*hours + (a->tm_min - b->tm_min);
 609         int seconds = 60*minutes + (a->tm_sec - b->tm_sec);
 610
 611         return seconds;
 612 }
 613
 614 int extra_time_offset=0;
 615
 616 /*******************************************************************
 617  Return the UTC offset in seconds west of UTC, or 0 if it cannot be determined.
 618 ********************************************************************/
 619
 620 int get_time_zone(time_t t)
 621 {
 622         struct tm *tm = gmtime(&t);
 623         struct tm tm_utc;
 624         if (!tm)
 625                 return 0;
 626         tm_utc = *tm;
 627         tm = localtime(&t);
 628         if (!tm)
 629                 return 0;
 630         return tm_diff(&tm_utc,tm)+60*extra_time_offset;
 631 }
 632
 633 /****************************************************************************
 634  Check if NTTIME is 0.
 635 ****************************************************************************/
 636
 637 bool nt_time_is_zero(const NTTIME *nt)
 638 {
 639         return (*nt == 0);
 640 }
 641
 642 /****************************************************************************
 643  Convert ASN.1 GeneralizedTime string to unix-time.
 644  Returns 0 on failure; Currently ignores timezone.
 645 ****************************************************************************/
 646
 647 time_t generalized_to_unix_time(const char *str)
 648 {
 649         struct tm tm;
 650
 651         ZERO_STRUCT(tm);
 652
 653         if (sscanf(str, "%4d%2d%2d%2d%2d%2d",
 654                    &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
 655                    &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
 656                 return 0;
 657         }
 658         tm.tm_year -= 1900;
 659         tm.tm_mon -= 1;
 660
 661         return timegm(&tm);
 662 }
 663
 664 /*******************************************************************
 665  Accessor function for the server time zone offset.
 666  set_server_zone_offset() must have been called first.
 667 ******************************************************************/
 668
 669 static int server_zone_offset;
 670
 671 int get_server_zone_offset(void)
 672 {
 673         return server_zone_offset;
 674 }
 675
 676 /*******************************************************************
 677  Initialize the server time zone offset. Called when a client connects.
 678 ******************************************************************/
 679
 680 int set_server_zone_offset(time_t t)
 681 {
 682         server_zone_offset = get_time_zone(t);
 683         return server_zone_offset;
 684 }
 685
 686 /****************************************************************************
 687  Return the date and time as a string
 688 ****************************************************************************/
 689
 690 char *current_timestring(TALLOC_CTX *ctx, bool hires)
 691 {
 692         fstring TimeBuf;
 693         struct timeval tp;
 694         time_t t;
 695         struct tm *tm;
 696
 697         if (hires) {
 698                 GetTimeOfDay(&tp);
 699                 t = (time_t)tp.tv_sec;
 700         } else {
 701                 t = time(NULL);
 702         }
 703         tm = localtime(&t);
 704         if (!tm) {
 705                 if (hires) {
 706                         slprintf(TimeBuf,
 707                                  sizeof(TimeBuf)-1,
 708                                  "%ld.%06ld seconds since the Epoch",
 709                                  (long)tp.tv_sec,
 710                                  (long)tp.tv_usec);
 711                 } else {
 712                         slprintf(TimeBuf,
 713                                  sizeof(TimeBuf)-1,
 714                                  "%ld seconds since the Epoch",
 715                                  (long)t);
 716                 }
 717         } else {
 718 #ifdef HAVE_STRFTIME
 719                 if (hires) {
 720                         strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
 721                         slprintf(TimeBuf+strlen(TimeBuf),
 722                                  sizeof(TimeBuf)-1 - strlen(TimeBuf),
 723                                  ".%06ld",
 724                                  (long)tp.tv_usec);
 725                 } else {
 726                         strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
 727                 }
 728 #else
 729                 if (hires) {
 730                         const char *asct = asctime(tm);
 731                         slprintf(TimeBuf,
 732                                  sizeof(TimeBuf)-1,
 733                                  "%s.%06ld",
 734                                  asct ? asct : "unknown",
 735                                  (long)tp.tv_usec);
 736                 } else {
 737                         const char *asct = asctime(tm);
 738                         fstrcpy(TimeBuf, asct ? asct : "unknown");
 739                 }
 740 #endif
 741         }
 742         return talloc_strdup(ctx, TimeBuf);
 743 }
 744
 745
 746 /*******************************************************************
 747  Put a dos date into a buffer (time/date format).
 748  This takes GMT time and puts local time in the buffer.
 749 ********************************************************************/
 750
 751 static void put_dos_date(char *buf,int offset,time_t unixdate, int zone_offset)
 752 {
 753         uint32 x = make_dos_date(unixdate, zone_offset);
 754         SIVAL(buf,offset,x);
 755 }
 756
 757 /*******************************************************************
 758  Put a dos date into a buffer (date/time format).
 759  This takes GMT time and puts local time in the buffer.
 760 ********************************************************************/
 761
 762 static void put_dos_date2(char *buf,int offset,time_t unixdate, int zone_offset)
 763 {
 764         uint32 x = make_dos_date(unixdate, zone_offset);
 765         x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
 766         SIVAL(buf,offset,x);
 767 }
 768
 769 /*******************************************************************
 770  Put a dos 32 bit "unix like" date into a buffer. This routine takes
 771  GMT and converts it to LOCAL time before putting it (most SMBs assume
 772  localtime for this sort of date)
 773 ********************************************************************/
 774
 775 static void put_dos_date3(char *buf,int offset,time_t unixdate, int zone_offset)
 776 {
 777         if (!null_mtime(unixdate)) {
 778                 unixdate -= zone_offset;
 779         }
 780         SIVAL(buf,offset,unixdate);
 781 }
 782
 783
 784 /***************************************************************************
 785  Server versions of the above functions.
 786 ***************************************************************************/
 787
 788 void srv_put_dos_date(char *buf,int offset,time_t unixdate)
 789 {
 790         put_dos_date(buf, offset, unixdate, server_zone_offset);
 791 }
 792
 793 void srv_put_dos_date2(char *buf,int offset, time_t unixdate)
 794 {
 795         put_dos_date2(buf, offset, unixdate, server_zone_offset);
 796 }
 797
 798 void srv_put_dos_date3(char *buf,int offset,time_t unixdate)
 799 {
 800         put_dos_date3(buf, offset, unixdate, server_zone_offset);
 801 }
 802
 803 /****************************************************************************
 804  Take a Unix time and convert to an NTTIME structure and place in buffer
 805  pointed to by p.
 806 ****************************************************************************/
 807
 808 void put_long_date_timespec(char *p, struct timespec ts)
 809 {
 810         NTTIME nt;
 811         unix_timespec_to_nt_time(&nt, ts);
 812         SIVAL(p, 0, nt & 0xFFFFFFFF);
 813         SIVAL(p, 4, nt >> 32);
 814 }
 815
 816 void put_long_date(char *p, time_t t)
 817 {
 818         struct timespec ts;
 819         ts.tv_sec = t;
 820         ts.tv_nsec = 0;
 821         put_long_date_timespec(p, ts);
 822 }
 823
 824 /****************************************************************************
 825  Return the best approximation to a 'create time' under UNIX from a stat
 826  structure.
 827 ****************************************************************************/
 828
 829 static time_t calc_create_time(const SMB_STRUCT_STAT *st)
 830 {
 831         time_t ret, ret1;
 832
 833         ret = MIN(st->st_ctime, st->st_mtime);
 834         ret1 = MIN(ret, st->st_atime);
 835
 836         if(ret1 != (time_t)0) {
 837                 return ret1;
 838         }
 839
 840         /*
 841          * One of ctime, mtime or atime was zero (probably atime).
 842          * Just return MIN(ctime, mtime).
 843          */
 844         return ret;
 845 }
 846
 847 /****************************************************************************
 848  Return the 'create time' from a stat struct if it exists (birthtime) or else
 849  use the best approximation.
 850 ****************************************************************************/
 851
 852 struct timespec get_create_timespec(const SMB_STRUCT_STAT *pst,bool fake_dirs)
 853 {
 854         struct timespec ret;
 855
 856         if(S_ISDIR(pst->st_mode) && fake_dirs) {
 857                 ret.tv_sec = 315493200L;          /* 1/1/1980 */
 858                 ret.tv_nsec = 0;
 859                 return ret;
 860         }
 861
 862 #if defined(HAVE_STAT_ST_BIRTHTIMESPEC)
 863         ret = pst->st_birthtimespec;
 864 #elif defined(HAVE_STAT_ST_BIRTHTIMENSEC)
 865         ret.tv_sec = pst->st_birthtime;
 866         ret.tv_nsec = pst->st_birthtimenspec;
 867 #elif defined(HAVE_STAT_ST_BIRTHTIME)
 868         ret.tv_sec = pst->st_birthtime;
 869         ret.tv_nsec = 0;
 870 #else
 871         ret.tv_sec = calc_create_time(pst);
 872         ret.tv_nsec = 0;
 873 #endif
 874
 875         /* Deal with systems that don't initialize birthtime correctly.
 876          * Pointed out by SATOH Fumiyasu <fumiyas@osstech.jp>.
 877          */
 878         if (null_timespec(ret)) {
 879                 ret.tv_sec = calc_create_time(pst);
 880                 ret.tv_nsec = 0;
 881         }
 882         return ret;
 883 }
 884
 885 /****************************************************************************
 886  Get/Set all the possible time fields from a stat struct as a timespec.
 887 ****************************************************************************/
 888
 889 struct timespec get_atimespec(const SMB_STRUCT_STAT *pst)
 890 {
 891 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
 892         struct timespec ret;
 893
 894         /* Old system - no ns timestamp. */
 895         ret.tv_sec = pst->st_atime;
 896         ret.tv_nsec = 0;
 897         return ret;
 898 #else
 899 #if defined(HAVE_STAT_ST_ATIM)
 900         return pst->st_atim;
 901 #elif defined(HAVE_STAT_ST_ATIMENSEC)
 902         struct timespec ret;
 903         ret.tv_sec = pst->st_atime;
 904         ret.tv_nsec = pst->st_atimensec;
 905         return ret;
 906 #elif defined(HAVE_STAT_ST_ATIME_N)
 907         struct timespec ret;
 908         ret.tv_sec = pst->st_atime;
 909         ret.tv_nsec = pst->st_atime_n;
 910         return ret;
 911 #elif defined(HAVE_STAT_ST_ATIMESPEC)
 912         return pst->st_atimespec;
 913 #else
 914 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
 915 #endif
 916 #endif
 917 }
 918
 919 void set_atimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
 920 {
 921 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
 922         /* Old system - no ns timestamp. */
 923         pst->st_atime = ts.tv_sec;
 924 #else
 925 #if defined(HAVE_STAT_ST_ATIM)
 926         pst->st_atim = ts;
 927 #elif defined(HAVE_STAT_ST_ATIMENSEC)
 928         pst->st_atime = ts.tv_sec;
 929         pst->st_atimensec = ts.tv_nsec;
 930 #elif defined(HAVE_STAT_ST_ATIME_N)
 931         pst->st_atime = ts.tv_sec;
 932         pst->st_atime_n = ts.tv_nsec;
 933 #elif defined(HAVE_STAT_ST_ATIMESPEC)
 934         pst->st_atimespec = ts;
 935 #else
 936 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
 937 #endif
 938 #endif
 939 }
 940
 941 struct timespec get_mtimespec(const SMB_STRUCT_STAT *pst)
 942 {
 943 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
 944         struct timespec ret;
 945
 946         /* Old system - no ns timestamp. */
 947         ret.tv_sec = pst->st_mtime;
 948         ret.tv_nsec = 0;
 949         return ret;
 950 #else
 951 #if defined(HAVE_STAT_ST_MTIM)
 952         return pst->st_mtim;
 953 #elif defined(HAVE_STAT_ST_MTIMENSEC)
 954         struct timespec ret;
 955         ret.tv_sec = pst->st_mtime;
 956         ret.tv_nsec = pst->st_mtimensec;
 957         return ret;
 958 #elif defined(HAVE_STAT_ST_MTIME_N)
 959         struct timespec ret;
 960         ret.tv_sec = pst->st_mtime;
 961         ret.tv_nsec = pst->st_mtime_n;
 962         return ret;
 963 #elif defined(HAVE_STAT_ST_MTIMESPEC)
 964         return pst->st_mtimespec;
 965 #else
 966 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
 967 #endif
 968 #endif
 969 }
 970
 971 void set_mtimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
 972 {
 973 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
 974         /* Old system - no ns timestamp. */
 975         pst->st_mtime = ts.tv_sec;
 976 #else
 977 #if defined(HAVE_STAT_ST_MTIM)
 978         pst->st_mtim = ts;
 979 #elif defined(HAVE_STAT_ST_MTIMENSEC)
 980         pst->st_mtime = ts.tv_sec;
 981         pst->st_mtimensec = ts.tv_nsec;
 982 #elif defined(HAVE_STAT_ST_MTIME_N)
 983         pst->st_mtime = ts.tv_sec;
 984         pst->st_mtime_n = ts.tv_nsec;
 985 #elif defined(HAVE_STAT_ST_MTIMESPEC)
 986         pst->st_mtimespec = ts;
 987 #else
 988 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
 989 #endif
 990 #endif
 991 }
 992
 993 struct timespec get_ctimespec(const SMB_STRUCT_STAT *pst)
 994 {
 995 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
 996         struct timespec ret;
 997
 998         /* Old system - no ns timestamp. */
 999         ret.tv_sec = pst->st_ctime;
1000         ret.tv_nsec = 0;
1001         return ret;
1002 #else
1003 #if defined(HAVE_STAT_ST_CTIM)
1004         return pst->st_ctim;
1005 #elif defined(HAVE_STAT_ST_CTIMENSEC)
1006         struct timespec ret;
1007         ret.tv_sec = pst->st_ctime;
1008         ret.tv_nsec = pst->st_ctimensec;
1009         return ret;
1010 #elif defined(HAVE_STAT_ST_CTIME_N)
1011         struct timespec ret;
1012         ret.tv_sec = pst->st_ctime;
1013         ret.tv_nsec = pst->st_ctime_n;
1014         return ret;
1015 #elif defined(HAVE_STAT_ST_CTIMESPEC)
1016         return pst->st_ctimespec;
1017 #else
1018 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
1019 #endif
1020 #endif
1021 }
1022
1023 void set_ctimespec(SMB_STRUCT_STAT *pst, struct timespec ts)
1024 {
1025 #if !defined(HAVE_STAT_HIRES_TIMESTAMPS)
1026         /* Old system - no ns timestamp. */
1027         pst->st_ctime = ts.tv_sec;
1028 #else
1029 #if defined(HAVE_STAT_ST_CTIM)
1030         pst->st_ctim = ts;
1031 #elif defined(HAVE_STAT_ST_CTIMENSEC)
1032         pst->st_ctime = ts.tv_sec;
1033         pst->st_ctimensec = ts.tv_nsec;
1034 #elif defined(HAVE_STAT_ST_CTIME_N)
1035         pst->st_ctime = ts.tv_sec;
1036         pst->st_ctime_n = ts.tv_nsec;
1037 #elif defined(HAVE_STAT_ST_CTIMESPEC)
1038         pst->st_ctimespec = ts;
1039 #else
1040 #error  CONFIGURE_ERROR_IN_DETECTING_TIMESPEC_IN_STAT
1041 #endif
1042 #endif
1043 }
1044
1045 void dos_filetime_timespec(struct timespec *tsp)
1046 {
1047         tsp->tv_sec &= ~1;
1048         tsp->tv_nsec = 0;
1049 }
1050
1051 /*******************************************************************
1052  Create a unix date (int GMT) from a dos date (which is actually in
1053  localtime).
1054 ********************************************************************/
1055
1056 static time_t make_unix_date(const void *date_ptr, int zone_offset)
1057 {
1058         uint32 dos_date=0;
1059         struct tm t;
1060         time_t ret;
1061
1062         dos_date = IVAL(date_ptr,0);
1063
1064         if (dos_date == 0) {
1065                 return 0;
1066         }
1067
1068         interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
1069                         &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
1070         t.tm_isdst = -1;
1071
1072         ret = timegm(&t);
1073
1074         ret += zone_offset;
1075
1076         return(ret);
1077 }
1078
1079 /*******************************************************************
1080  Like make_unix_date() but the words are reversed.
1081 ********************************************************************/
1082
1083 static time_t make_unix_date2(const void *date_ptr, int zone_offset)
1084 {
1085         uint32 x,x2;
1086
1087         x = IVAL(date_ptr,0);
1088         x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
1089         SIVAL(&x,0,x2);
1090
1091         return(make_unix_date((const void *)&x, zone_offset));
1092 }
1093
1094 /*******************************************************************
1095  Create a unix GMT date from a dos date in 32 bit "unix like" format
1096  these generally arrive as localtimes, with corresponding DST.
1097 ******************************************************************/
1098
1099 static time_t make_unix_date3(const void *date_ptr, int zone_offset)
1100 {
1101         time_t t = (time_t)IVAL(date_ptr,0);
1102         if (!null_mtime(t)) {
1103                 t += zone_offset;
1104         }
1105         return(t);
1106 }
1107
1108 time_t srv_make_unix_date(const void *date_ptr)
1109 {
1110         return make_unix_date(date_ptr, server_zone_offset);
1111 }
1112
1113 time_t srv_make_unix_date2(const void *date_ptr)
1114 {
1115         return make_unix_date2(date_ptr, server_zone_offset);
1116 }
1117
1118 time_t srv_make_unix_date3(const void *date_ptr)
1119 {
1120         return make_unix_date3(date_ptr, server_zone_offset);
1121 }
1122
1123 time_t convert_timespec_to_time_t(struct timespec ts)
1124 {
1125         /* 1 ns == 1,000,000,000 - one thousand millionths of a second.
1126            increment if it's greater than 500 millionth of a second. */
1127         if (ts.tv_nsec > 500000000) {
1128                 return ts.tv_sec + 1;
1129         }
1130         return ts.tv_sec;
1131 }
1132
1133 struct timespec convert_time_t_to_timespec(time_t t)
1134 {
1135         struct timespec ts;
1136         ts.tv_sec = t;
1137         ts.tv_nsec = 0;
1138         return ts;
1139 }
1140
1141 /****************************************************************************
1142  Convert a normalized timeval to a timespec.
1143 ****************************************************************************/
1144
1145 struct timespec convert_timeval_to_timespec(const struct timeval tv)
1146 {
1147         struct timespec ts;
1148         ts.tv_sec = tv.tv_sec;
1149         ts.tv_nsec = tv.tv_usec * 1000;
1150         return ts;
1151 }
1152
1153 /****************************************************************************
1154  Convert a normalized timespec to a timeval.
1155 ****************************************************************************/
1156
1157 struct timeval convert_timespec_to_timeval(const struct timespec ts)
1158 {
1159         struct timeval tv;
1160         tv.tv_sec = ts.tv_sec;
1161         tv.tv_usec = ts.tv_nsec / 1000;
1162         return tv;
1163 }
1164
1165 /****************************************************************************
1166  Return a timespec for the current time
1167 ****************************************************************************/
1168
1169 struct timespec timespec_current(void)
1170 {
1171         struct timeval tv;
1172         struct timespec ts;
1173         GetTimeOfDay(&tv);
1174         ts.tv_sec = tv.tv_sec;
1175         ts.tv_nsec = tv.tv_usec * 1000;
1176         return ts;
1177 }
1178
1179 /****************************************************************************
1180  Return the lesser of two timespecs.
1181 ****************************************************************************/
1182
1183 struct timespec timespec_min(const struct timespec *ts1,
1184                            const struct timespec *ts2)
1185 {
1186         if (ts1->tv_sec < ts2->tv_sec) return *ts1;
1187         if (ts1->tv_sec > ts2->tv_sec) return *ts2;
1188         if (ts1->tv_nsec < ts2->tv_nsec) return *ts1;
1189         return *ts2;
1190 }
1191
1192 /****************************************************************************
1193   compare two timespec structures.
1194   Return -1 if ts1 < ts2
1195   Return 0 if ts1 == ts2
1196   Return 1 if ts1 > ts2
1197 ****************************************************************************/
1198
1199 int timespec_compare(const struct timespec *ts1, const struct timespec *ts2)
1200 {
1201         if (ts1->tv_sec  > ts2->tv_sec)  return 1;
1202         if (ts1->tv_sec  < ts2->tv_sec)  return -1;
1203         if (ts1->tv_nsec > ts2->tv_nsec) return 1;
1204         if (ts1->tv_nsec < ts2->tv_nsec) return -1;
1205         return 0;
1206 }
1207
1208 /****************************************************************************
1209  Interprets an nt time into a unix struct timespec.
1210  Differs from nt_time_to_unix in that an 8 byte value of 0xffffffffffffffff
1211  will be returned as (time_t)-1, whereas nt_time_to_unix returns 0 in this case.
1212 ****************************************************************************/
1213
1214 struct timespec interpret_long_date(const char *p)
1215 {
1216         NTTIME nt;
1217         nt = IVAL(p,0) + ((uint64_t)IVAL(p,4) << 32);
1218         if (nt == (uint64_t)-1) {
1219                 struct timespec ret;
1220                 ret.tv_sec = (time_t)-1;
1221                 ret.tv_nsec = 0;
1222                 return ret;
1223         }
1224         return nt_time_to_unix_timespec(&nt);
1225 }
1226
1227 /***************************************************************************
1228  Client versions of the above functions.
1229 ***************************************************************************/
1230
1231 void cli_put_dos_date(struct cli_state *cli, char *buf, int offset, time_t unixdate)
1232 {
1233         put_dos_date(buf, offset, unixdate, cli->serverzone);
1234 }
1235
1236 void cli_put_dos_date2(struct cli_state *cli, char *buf, int offset, time_t unixdate)
1237 {
1238         put_dos_date2(buf, offset, unixdate, cli->serverzone);
1239 }
1240
1241 void cli_put_dos_date3(struct cli_state *cli, char *buf, int offset, time_t unixdate)
1242 {
1243         put_dos_date3(buf, offset, unixdate, cli->serverzone);
1244 }
1245
1246 time_t cli_make_unix_date(struct cli_state *cli, const void *date_ptr)
1247 {
1248         return make_unix_date(date_ptr, cli->serverzone);
1249 }
1250
1251 time_t cli_make_unix_date2(struct cli_state *cli, const void *date_ptr)
1252 {
1253         return make_unix_date2(date_ptr, cli->serverzone);
1254 }
1255
1256 time_t cli_make_unix_date3(struct cli_state *cli, const void *date_ptr)
1257 {
1258         return make_unix_date3(date_ptr, cli->serverzone);
1259 }
1260
1261 /* Large integer version. */
1262 struct timespec nt_time_to_unix_timespec(NTTIME *nt)
1263 {
1264         int64 d;
1265         struct timespec ret;
1266
1267         if (*nt == 0 || *nt == (int64)-1) {
1268                 ret.tv_sec = 0;
1269                 ret.tv_nsec = 0;
1270                 return ret;
1271         }
1272
1273         d = (int64)*nt;
1274         /* d is now in 100ns units, since jan 1st 1601".
1275            Save off the ns fraction. */
1276
1277         /*
1278          * Take the last seven decimal digits and multiply by 100.
1279          * to convert from 100ns units to 1ns units.
1280          */
1281         ret.tv_nsec = (long) ((d % (1000 * 1000 * 10)) * 100);
1282
1283         /* Convert to seconds */
1284         d /= 1000*1000*10;
1285
1286         /* Now adjust by 369 years to make the secs since 1970 */
1287         d -= TIME_FIXUP_CONSTANT_INT;
1288
1289         if (d <= (int64)TIME_T_MIN) {
1290                 ret.tv_sec = TIME_T_MIN;
1291                 ret.tv_nsec = 0;
1292                 return ret;
1293         }
1294
1295         if (d >= (int64)TIME_T_MAX) {
1296                 ret.tv_sec = TIME_T_MAX;
1297                 ret.tv_nsec = 0;
1298                 return ret;
1299         }
1300
1301         ret.tv_sec = (time_t)d;
1302         return ret;
1303 }
1304 /****************************************************************************
1305  Check if two NTTIMEs are the same.
1306 ****************************************************************************/
1307
1308 bool nt_time_equals(const NTTIME *nt1, const NTTIME *nt2)
1309 {
1310         return (*nt1 == *nt2);
1311 }
1312
1313 /*******************************************************************
1314  Re-read the smb serverzone value.
1315 ******************************************************************/
1316
1317 static struct timeval start_time_hires;
1318
1319 void TimeInit(void)
1320 {
1321         set_server_zone_offset(time(NULL));
1322
1323         DEBUG(4,("TimeInit: Serverzone is %d\n", server_zone_offset));
1324
1325         /* Save the start time of this process. */
1326         if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0) {
1327                 GetTimeOfDay(&start_time_hires);
1328         }
1329 }
1330
1331 /**********************************************************************
1332  Return a timeval struct of the uptime of this process. As TimeInit is
1333  done before a daemon fork then this is the start time from the parent
1334  daemon start. JRA.
1335 ***********************************************************************/
1336
1337 void get_process_uptime(struct timeval *ret_time)
1338 {
1339         struct timeval time_now_hires;
1340
1341         GetTimeOfDay(&time_now_hires);
1342         ret_time->tv_sec = time_now_hires.tv_sec - start_time_hires.tv_sec;
1343         if (time_now_hires.tv_usec < start_time_hires.tv_usec) {
1344                 ret_time->tv_sec -= 1;
1345                 ret_time->tv_usec = 1000000 + (time_now_hires.tv_usec - start_time_hires.tv_usec);
1346         } else {
1347                 ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
1348         }
1349 }
1350
1351 /****************************************************************************
1352  Convert a NTTIME structure to a time_t.
1353  It's originally in "100ns units".
1354
1355  This is an absolute version of the one above.
1356  By absolute I mean, it doesn't adjust from 1/1/1601 to 1/1/1970
1357  if the NTTIME was 5 seconds, the time_t is 5 seconds. JFM
1358 ****************************************************************************/
1359
1360 time_t nt_time_to_unix_abs(const NTTIME *nt)
1361 {
1362         uint64 d;
1363
1364         if (*nt == 0) {
1365                 return (time_t)0;
1366         }
1367
1368         if (*nt == (uint64)-1) {
1369                 return (time_t)-1;
1370         }
1371
1372         if (*nt == NTTIME_INFINITY) {
1373                 return (time_t)-1;
1374         }
1375
1376         /* reverse the time */
1377         /* it's a negative value, turn it to positive */
1378         d=~*nt;
1379
1380         d += 1000*1000*10/2;
1381         d /= 1000*1000*10;
1382
1383         if (!(TIME_T_MIN <= ((time_t)d) && ((time_t)d) <= TIME_T_MAX)) {
1384                 return (time_t)0;
1385         }
1386
1387         return (time_t)d;
1388 }
1389
1390 /****************************************************************************
1391  Put a 8 byte filetime from a struct timespec. Uses GMT.
1392 ****************************************************************************/
1393
1394 void unix_timespec_to_nt_time(NTTIME *nt, struct timespec ts)
1395 {
1396         uint64 d;
1397
1398         if (ts.tv_sec ==0 && ts.tv_nsec == 0) {
1399                 *nt = 0;
1400                 return;
1401         }
1402         if (ts.tv_sec == TIME_T_MAX) {
1403                 *nt = 0x7fffffffffffffffLL;
1404                 return;
1405         }
1406         if (ts.tv_sec == (time_t)-1) {
1407                 *nt = (uint64)-1;
1408                 return;
1409         }
1410
1411         d = ts.tv_sec;
1412         d += TIME_FIXUP_CONSTANT_INT;
1413         d *= 1000*1000*10;
1414         /* d is now in 100ns units. */
1415         d += (ts.tv_nsec / 100);
1416
1417         *nt = d;
1418 }
1419
1420 /****************************************************************************
1421  Convert a time_t to a NTTIME structure
1422
1423  This is an absolute version of the one above.
1424  By absolute I mean, it doesn't adjust from 1/1/1970 to 1/1/1601
1425  If the time_t was 5 seconds, the NTTIME is 5 seconds. JFM
1426 ****************************************************************************/
1427
1428 void unix_to_nt_time_abs(NTTIME *nt, time_t t)
1429 {
1430         double d;
1431
1432         if (t==0) {
1433                 *nt = 0;
1434                 return;
1435         }
1436
1437         if (t == TIME_T_MAX) {
1438                 *nt = 0x7fffffffffffffffLL;
1439                 return;
1440         }
1441
1442         if (t == (time_t)-1) {
1443                 /* that's what NT uses for infinite */
1444                 *nt = NTTIME_INFINITY;
1445                 return;
1446         }
1447
1448         d = (double)(t);
1449         d *= 1.0e7;
1450
1451         *nt = (NTTIME)d;
1452
1453         /* convert to a negative value */
1454         *nt=~*nt;
1455 }
1456
1457
1458 /****************************************************************************
1459  Check if it's a null mtime.
1460 ****************************************************************************/
1461
1462 bool null_mtime(time_t mtime)
1463 {
1464         if (mtime == 0 || mtime == (time_t)0xFFFFFFFF || mtime == (time_t)-1)
1465                 return(True);
1466         return(False);
1467 }
1468
1469 /****************************************************************************
1470  Utility function that always returns a const string even if localtime
1471  and asctime fail.
1472 ****************************************************************************/
1473
1474 const char *time_to_asc(const time_t t)
1475 {
1476         const char *asct;
1477         struct tm *lt = localtime(&t);
1478
1479         if (!lt) {
1480                 return "unknown time";
1481         }
1482
1483         asct = asctime(lt);
1484         if (!asct) {
1485                 return "unknown time";
1486         }
1487         return asct;
1488 }
1489
1490 const char *display_time(NTTIME nttime)
1491 {
1492         float high;
1493         float low;
1494         int sec;
1495         int days, hours, mins, secs;
1496
1497         if (nttime==0)
1498                 return "Now";
1499
1500         if (nttime==NTTIME_INFINITY)
1501                 return "Never";
1502
1503         high = 65536;
1504         high = high/10000;
1505         high = high*65536;
1506         high = high/1000;
1507         high = high * (~(nttime >> 32));
1508
1509         low = ~(nttime & 0xFFFFFFFF);
1510         low = low/(1000*1000*10);
1511
1512         sec=(int)(high+low);
1513
1514         days=sec/(60*60*24);
1515         hours=(sec - (days*60*60*24)) / (60*60);
1516         mins=(sec - (days*60*60*24) - (hours*60*60) ) / 60;
1517         secs=sec - (days*60*60*24) - (hours*60*60) - (mins*60);
1518
1519         return talloc_asprintf(talloc_tos(), "%u days, %u hours, %u minutes, "
1520                                "%u seconds", days, hours, mins, secs);
1521 }
1522
1523 bool nt_time_is_set(const NTTIME *nt)
1524 {
1525         if (*nt == 0x7FFFFFFFFFFFFFFFLL) {
1526                 return False;
1527         }
1528
1529         if (*nt == NTTIME_INFINITY) {
1530                 return False;
1531         }
1532
1533         return True;
1534 }