lib/util/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
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "system/time.h"
  24
  25 /**
  26  * @file
  27  * @brief time handling functions
  28  */
  29
  30 #if (SIZEOF_LONG == 8)
  31 #define TIME_FIXUP_CONSTANT_INT 11644473600L
  32 #elif (SIZEOF_LONG_LONG == 8)
  33 #define TIME_FIXUP_CONSTANT_INT 11644473600LL
  34 #endif
  35
  36
  37
  38 /**
  39  External access to time_t_min and time_t_max.
  40 **/
  41 _PUBLIC_ time_t get_time_t_max(void)
  42 {
  43         return TIME_T_MAX;
  44 }
  45
  46 /**
  47 a gettimeofday wrapper
  48 **/
  49 _PUBLIC_ void GetTimeOfDay(struct timeval *tval)
  50 {
  51 #ifdef HAVE_GETTIMEOFDAY_TZ
  52         gettimeofday(tval,NULL);
  53 #else
  54         gettimeofday(tval);
  55 #endif
  56 }
  57
  58 /**
  59 a wrapper to preferably get the monotonic time
  60 **/
  61 _PUBLIC_ void clock_gettime_mono(struct timespec *tp)
  62 {
  63         if (clock_gettime(CUSTOM_CLOCK_MONOTONIC,tp) != 0) {
  64                 clock_gettime(CLOCK_REALTIME,tp);
  65         }
  66 }
  67
  68 /**
  69 a wrapper to preferably get the monotonic time in seconds
  70 as this is only second resolution we can use the cached
  71 (and much faster) COARSE clock variant
  72 **/
  73 _PUBLIC_ time_t time_mono(time_t *t)
  74 {
  75         struct timespec tp;
  76         int rc = -1;
  77 #ifdef CLOCK_MONOTONIC_COARSE
  78         rc = clock_gettime(CLOCK_MONOTONIC_COARSE,&tp);
  79 #endif
  80         if (rc != 0) {
  81                 clock_gettime_mono(&tp);
  82         }
  83         if (t != NULL) {
  84                 *t = tp.tv_sec;
  85         }
  86         return tp.tv_sec;
  87 }
  88
  89
  90 #define TIME_FIXUP_CONSTANT 11644473600LL
  91
  92 time_t convert_timespec_to_time_t(struct timespec ts)
  93 {
  94         /* Ensure tv_nsec is less than 1sec. */
  95         while (ts.tv_nsec > 1000000000) {
  96                 ts.tv_sec += 1;
  97                 ts.tv_nsec -= 1000000000;
  98         }
  99
 100         /* 1 ns == 1,000,000,000 - one thousand millionths of a second.
 101            increment if it's greater than 500 millionth of a second. */
 102
 103         if (ts.tv_nsec > 500000000) {
 104                 return ts.tv_sec + 1;
 105         }
 106         return ts.tv_sec;
 107 }
 108
 109 struct timespec convert_time_t_to_timespec(time_t t)
 110 {
 111         struct timespec ts;
 112         ts.tv_sec = t;
 113         ts.tv_nsec = 0;
 114         return ts;
 115 }
 116
 117
 118
 119 /**
 120  Interpret an 8 byte "filetime" structure to a time_t
 121  It's originally in "100ns units since jan 1st 1601"
 122
 123  An 8 byte value of 0xffffffffffffffff will be returned as a timespec of
 124
 125         tv_sec = 0
 126         tv_nsec = 0;
 127
 128  Returns GMT.
 129 **/
 130 time_t nt_time_to_unix(NTTIME nt)
 131 {
 132         return convert_timespec_to_time_t(nt_time_to_unix_timespec(&nt));
 133 }
 134
 135
 136 /**
 137 put a 8 byte filetime from a time_t
 138 This takes GMT as input
 139 **/
 140 _PUBLIC_ void unix_to_nt_time(NTTIME *nt, time_t t)
 141 {
 142         uint64_t t2;
 143
 144         if (t == (time_t)-1) {
 145                 *nt = (NTTIME)-1LL;
 146                 return;
 147         }
 148
 149         if (t == TIME_T_MAX) {
 150                 *nt = 0x7fffffffffffffffLL;
 151                 return;
 152         }
 153
 154         if (t == 0) {
 155                 *nt = 0;
 156                 return;
 157         }
 158
 159         t2 = t;
 160         t2 += TIME_FIXUP_CONSTANT_INT;
 161         t2 *= 1000*1000*10;
 162
 163         *nt = t2;
 164 }
 165
 166
 167 /**
 168 check if it's a null unix time
 169 **/
 170 _PUBLIC_ bool null_time(time_t t)
 171 {
 172         return t == 0 ||
 173                 t == (time_t)0xFFFFFFFF ||
 174                 t == (time_t)-1;
 175 }
 176
 177
 178 /**
 179 check if it's a null NTTIME
 180 **/
 181 _PUBLIC_ bool null_nttime(NTTIME t)
 182 {
 183         return t == 0 || t == (NTTIME)-1;
 184 }
 185
 186 /*******************************************************************
 187   create a 16 bit dos packed date
 188 ********************************************************************/
 189 static uint16_t make_dos_date1(struct tm *t)
 190 {
 191         uint16_t ret=0;
 192         ret = (((unsigned int)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
 193         ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5));
 194         return ret;
 195 }
 196
 197 /*******************************************************************
 198   create a 16 bit dos packed time
 199 ********************************************************************/
 200 static uint16_t make_dos_time1(struct tm *t)
 201 {
 202         uint16_t ret=0;
 203         ret = ((((unsigned int)t->tm_min >> 3)&0x7) | (((unsigned int)t->tm_hour) << 3));
 204         ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
 205         return ret;
 206 }
 207
 208 /*******************************************************************
 209   create a 32 bit dos packed date/time from some parameters
 210   This takes a GMT time and returns a packed localtime structure
 211 ********************************************************************/
 212 static uint32_t make_dos_date(time_t unixdate, int zone_offset)
 213 {
 214         struct tm *t;
 215         uint32_t ret=0;
 216
 217         if (unixdate == 0) {
 218                 return 0;
 219         }
 220
 221         unixdate -= zone_offset;
 222
 223         t = gmtime(&unixdate);
 224         if (!t) {
 225                 return 0xFFFFFFFF;
 226         }
 227
 228         ret = make_dos_date1(t);
 229         ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
 230
 231         return ret;
 232 }
 233
 234 /**
 235 put a dos date into a buffer (time/date format)
 236 This takes GMT time and puts local time in the buffer
 237 **/
 238 _PUBLIC_ void push_dos_date(uint8_t *buf, int offset, time_t unixdate, int zone_offset)
 239 {
 240         uint32_t x = make_dos_date(unixdate, zone_offset);
 241         SIVAL(buf,offset,x);
 242 }
 243
 244 /**
 245 put a dos date into a buffer (date/time format)
 246 This takes GMT time and puts local time in the buffer
 247 **/
 248 _PUBLIC_ void push_dos_date2(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 249 {
 250         uint32_t x;
 251         x = make_dos_date(unixdate, zone_offset);
 252         x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
 253         SIVAL(buf,offset,x);
 254 }
 255
 256 /**
 257 put a dos 32 bit "unix like" date into a buffer. This routine takes
 258 GMT and converts it to LOCAL time before putting it (most SMBs assume
 259 localtime for this sort of date)
 260 **/
 261 _PUBLIC_ void push_dos_date3(uint8_t *buf,int offset,time_t unixdate, int zone_offset)
 262 {
 263         if (!null_time(unixdate)) {
 264                 unixdate -= zone_offset;
 265         }
 266         SIVAL(buf,offset,unixdate);
 267 }
 268
 269 /*******************************************************************
 270   interpret a 32 bit dos packed date/time to some parameters
 271 ********************************************************************/
 272 void interpret_dos_date(uint32_t date,int *year,int *month,int *day,int *hour,int *minute,int *second)
 273 {
 274         uint32_t p0,p1,p2,p3;
 275
 276         p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF;
 277         p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF;
 278
 279         *second = 2*(p0 & 0x1F);
 280         *minute = ((p0>>5)&0xFF) + ((p1&0x7)<<3);
 281         *hour = (p1>>3)&0xFF;
 282         *day = (p2&0x1F);
 283         *month = ((p2>>5)&0xFF) + ((p3&0x1)<<3) - 1;
 284         *year = ((p3>>1)&0xFF) + 80;
 285 }
 286
 287 /**
 288   create a unix date (int GMT) from a dos date (which is actually in
 289   localtime)
 290 **/
 291 _PUBLIC_ time_t pull_dos_date(const uint8_t *date_ptr, int zone_offset)
 292 {
 293         uint32_t dos_date=0;
 294         struct tm t;
 295         time_t ret;
 296
 297         dos_date = IVAL(date_ptr,0);
 298
 299         if (dos_date == 0) return (time_t)0;
 300
 301         interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
 302                            &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
 303         t.tm_isdst = -1;
 304
 305         ret = timegm(&t);
 306
 307         ret += zone_offset;
 308
 309         return ret;
 310 }
 311
 312 /**
 313 like make_unix_date() but the words are reversed
 314 **/
 315 _PUBLIC_ time_t pull_dos_date2(const uint8_t *date_ptr, int zone_offset)
 316 {
 317         uint32_t x,x2;
 318
 319         x = IVAL(date_ptr,0);
 320         x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
 321         SIVAL(&x,0,x2);
 322
 323         return pull_dos_date((const uint8_t *)&x, zone_offset);
 324 }
 325
 326 /**
 327   create a unix GMT date from a dos date in 32 bit "unix like" format
 328   these generally arrive as localtimes, with corresponding DST
 329 **/
 330 _PUBLIC_ time_t pull_dos_date3(const uint8_t *date_ptr, int zone_offset)
 331 {
 332         time_t t = (time_t)IVAL(date_ptr,0);
 333         if (!null_time(t)) {
 334                 t += zone_offset;
 335         }
 336         return t;
 337 }
 338
 339
 340 /**
 341 return a HTTP/1.0 time string
 342 **/
 343 _PUBLIC_ char *http_timestring(TALLOC_CTX *mem_ctx, time_t t)
 344 {
 345         char *buf;
 346         char tempTime[60];
 347         struct tm *tm = localtime(&t);
 348
 349         if (t == TIME_T_MAX) {
 350                 return talloc_strdup(mem_ctx, "never");
 351         }
 352
 353         if (!tm) {
 354                 return talloc_asprintf(mem_ctx,"%ld seconds since the Epoch",(long)t);
 355         }
 356
 357 #ifndef HAVE_STRFTIME
 358         buf = talloc_strdup(mem_ctx, asctime(tm));
 359         if (buf[strlen(buf)-1] == '\n') {
 360                 buf[strlen(buf)-1] = 0;
 361         }
 362 #else
 363         strftime(tempTime, sizeof(tempTime)-1, "%a, %d %b %Y %H:%M:%S %Z", tm);
 364         buf = talloc_strdup(mem_ctx, tempTime);
 365 #endif /* !HAVE_STRFTIME */
 366
 367         return buf;
 368 }
 369
 370 /**
 371  Return the date and time as a string
 372 **/
 373 _PUBLIC_ char *timestring(TALLOC_CTX *mem_ctx, time_t t)
 374 {
 375         char *TimeBuf;
 376         char tempTime[80];
 377         struct tm *tm;
 378
 379         tm = localtime(&t);
 380         if (!tm) {
 381                 return talloc_asprintf(mem_ctx,
 382                                        "%ld seconds since the Epoch",
 383                                        (long)t);
 384         }
 385
 386 #ifdef HAVE_STRFTIME
 387         /* Some versions of gcc complain about using some special format
 388          * specifiers. This is a bug in gcc, not a bug in this code. See a
 389          * recent strftime() manual page for details. */
 390         strftime(tempTime,sizeof(tempTime)-1,"%a %b %e %X %Y %Z",tm);
 391         TimeBuf = talloc_strdup(mem_ctx, tempTime);
 392 #else
 393         TimeBuf = talloc_strdup(mem_ctx, asctime(tm));
 394 #endif
 395
 396         return TimeBuf;
 397 }
 398
 399 /**
 400   return a talloced string representing a NTTIME for human consumption
 401 */
 402 _PUBLIC_ const char *nt_time_string(TALLOC_CTX *mem_ctx, NTTIME nt)
 403 {
 404         time_t t;
 405         if (nt == 0) {
 406                 return "NTTIME(0)";
 407         }
 408         t = nt_time_to_unix(nt);
 409         return timestring(mem_ctx, t);
 410 }
 411
 412
 413 /**
 414   put a NTTIME into a packet
 415 */
 416 _PUBLIC_ void push_nttime(uint8_t *base, uint16_t offset, NTTIME t)
 417 {
 418         SBVAL(base, offset,   t);
 419 }
 420
 421 /**
 422   pull a NTTIME from a packet
 423 */
 424 _PUBLIC_ NTTIME pull_nttime(uint8_t *base, uint16_t offset)
 425 {
 426         NTTIME ret = BVAL(base, offset);
 427         return ret;
 428 }
 429
 430 /**
 431   return (tv1 - tv2) in microseconds
 432 */
 433 _PUBLIC_ int64_t usec_time_diff(const struct timeval *tv1, const struct timeval *tv2)
 434 {
 435         int64_t sec_diff = tv1->tv_sec - tv2->tv_sec;
 436         return (sec_diff * 1000000) + (int64_t)(tv1->tv_usec - tv2->tv_usec);
 437 }
 438
 439 /**
 440   return (tp1 - tp2) in microseconds
 441 */
 442 _PUBLIC_ int64_t nsec_time_diff(const struct timespec *tp1, const struct timespec *tp2)
 443 {
 444         int64_t sec_diff = tp1->tv_sec - tp2->tv_sec;
 445         return (sec_diff * 1000000000) + (int64_t)(tp1->tv_nsec - tp2->tv_nsec);
 446 }
 447
 448
 449 /**
 450   return a zero timeval
 451 */
 452 _PUBLIC_ struct timeval timeval_zero(void)
 453 {
 454         struct timeval tv;
 455         tv.tv_sec = 0;
 456         tv.tv_usec = 0;
 457         return tv;
 458 }
 459
 460 /**
 461   return true if a timeval is zero
 462 */
 463 _PUBLIC_ bool timeval_is_zero(const struct timeval *tv)
 464 {
 465         return tv->tv_sec == 0 && tv->tv_usec == 0;
 466 }
 467
 468 /**
 469   return a timeval for the current time
 470 */
 471 _PUBLIC_ struct timeval timeval_current(void)
 472 {
 473         struct timeval tv;
 474         GetTimeOfDay(&tv);
 475         return tv;
 476 }
 477
 478 /**
 479   return a timeval struct with the given elements
 480 */
 481 _PUBLIC_ struct timeval timeval_set(uint32_t secs, uint32_t usecs)
 482 {
 483         struct timeval tv;
 484         tv.tv_sec = secs;
 485         tv.tv_usec = usecs;
 486         return tv;
 487 }
 488
 489
 490 /**
 491   return a timeval ofs microseconds after tv
 492 */
 493 _PUBLIC_ struct timeval timeval_add(const struct timeval *tv,
 494                            uint32_t secs, uint32_t usecs)
 495 {
 496         struct timeval tv2 = *tv;
 497         const unsigned int million = 1000000;
 498         tv2.tv_sec += secs;
 499         tv2.tv_usec += usecs;
 500         tv2.tv_sec += tv2.tv_usec / million;
 501         tv2.tv_usec = tv2.tv_usec % million;
 502         return tv2;
 503 }
 504
 505 /**
 506   return the sum of two timeval structures
 507 */
 508 struct timeval timeval_sum(const struct timeval *tv1,
 509                            const struct timeval *tv2)
 510 {
 511         return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
 512 }
 513
 514 /**
 515   return a timeval secs/usecs into the future
 516 */
 517 _PUBLIC_ struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
 518 {
 519         struct timeval tv = timeval_current();
 520         return timeval_add(&tv, secs, usecs);
 521 }
 522
 523 /**
 524   compare two timeval structures.
 525   Return -1 if tv1 < tv2
 526   Return 0 if tv1 == tv2
 527   Return 1 if tv1 > tv2
 528 */
 529 _PUBLIC_ int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
 530 {
 531         if (tv1->tv_sec  > tv2->tv_sec)  return 1;
 532         if (tv1->tv_sec  < tv2->tv_sec)  return -1;
 533         if (tv1->tv_usec > tv2->tv_usec) return 1;
 534         if (tv1->tv_usec < tv2->tv_usec) return -1;
 535         return 0;
 536 }
 537
 538 /**
 539   return true if a timer is in the past
 540 */
 541 _PUBLIC_ bool timeval_expired(const struct timeval *tv)
 542 {
 543         struct timeval tv2 = timeval_current();
 544         if (tv2.tv_sec > tv->tv_sec) return true;
 545         if (tv2.tv_sec < tv->tv_sec) return false;
 546         return (tv2.tv_usec >= tv->tv_usec);
 547 }
 548
 549 /**
 550   return the number of seconds elapsed between two times
 551 */
 552 _PUBLIC_ double timeval_elapsed2(const struct timeval *tv1, const struct timeval *tv2)
 553 {
 554         return (tv2->tv_sec - tv1->tv_sec) +
 555                (tv2->tv_usec - tv1->tv_usec)*1.0e-6;
 556 }
 557
 558 /**
 559   return the number of seconds elapsed since a given time
 560 */
 561 _PUBLIC_ double timeval_elapsed(const struct timeval *tv)
 562 {
 563         struct timeval tv2 = timeval_current();
 564         return timeval_elapsed2(tv, &tv2);
 565 }
 566
 567 /**
 568   return the lesser of two timevals
 569 */
 570 _PUBLIC_ struct timeval timeval_min(const struct timeval *tv1,
 571                            const struct timeval *tv2)
 572 {
 573         if (tv1->tv_sec < tv2->tv_sec) return *tv1;
 574         if (tv1->tv_sec > tv2->tv_sec) return *tv2;
 575         if (tv1->tv_usec < tv2->tv_usec) return *tv1;
 576         return *tv2;
 577 }
 578
 579 /**
 580   return the greater of two timevals
 581 */
 582 _PUBLIC_ struct timeval timeval_max(const struct timeval *tv1,
 583                            const struct timeval *tv2)
 584 {
 585         if (tv1->tv_sec > tv2->tv_sec) return *tv1;
 586         if (tv1->tv_sec < tv2->tv_sec) return *tv2;
 587         if (tv1->tv_usec > tv2->tv_usec) return *tv1;
 588         return *tv2;
 589 }
 590
 591 /**
 592   return the difference between two timevals as a timeval
 593   if tv1 comes after tv2, then return a zero timeval
 594   (this is *tv2 - *tv1)
 595 */
 596 _PUBLIC_ struct timeval timeval_until(const struct timeval *tv1,
 597                              const struct timeval *tv2)
 598 {
 599         struct timeval t;
 600         if (timeval_compare(tv1, tv2) >= 0) {
 601                 return timeval_zero();
 602         }
 603         t.tv_sec = tv2->tv_sec - tv1->tv_sec;
 604         if (tv1->tv_usec > tv2->tv_usec) {
 605                 t.tv_sec--;
 606                 t.tv_usec = 1000000 - (tv1->tv_usec - tv2->tv_usec);
 607         } else {
 608                 t.tv_usec = tv2->tv_usec - tv1->tv_usec;
 609         }
 610         return t;
 611 }
 612
 613
 614 /**
 615   convert a timeval to a NTTIME
 616 */
 617 _PUBLIC_ NTTIME timeval_to_nttime(const struct timeval *tv)
 618 {
 619         return 10*(tv->tv_usec +
 620                   ((TIME_FIXUP_CONSTANT + (uint64_t)tv->tv_sec) * 1000000));
 621 }
 622
 623 /**
 624   convert a NTTIME to a timeval
 625 */
 626 _PUBLIC_ void nttime_to_timeval(struct timeval *tv, NTTIME t)
 627 {
 628         if (tv == NULL) return;
 629
 630         t += 10/2;
 631         t /= 10;
 632         t -= TIME_FIXUP_CONSTANT*1000*1000;
 633
 634         tv->tv_sec  = t / 1000000;
 635
 636         if (TIME_T_MIN > tv->tv_sec || tv->tv_sec > TIME_T_MAX) {
 637                 tv->tv_sec  = 0;
 638                 tv->tv_usec = 0;
 639                 return;
 640         }
 641
 642         tv->tv_usec = t - tv->tv_sec*1000000;
 643 }
 644
 645 /*******************************************************************
 646 yield the difference between *A and *B, in seconds, ignoring leap seconds
 647 ********************************************************************/
 648 static int tm_diff(struct tm *a, struct tm *b)
 649 {
 650         int ay = a->tm_year + (1900 - 1);
 651         int by = b->tm_year + (1900 - 1);
 652         int intervening_leap_days =
 653                 (ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400);
 654         int years = ay - by;
 655         int days = 365*years + intervening_leap_days + (a->tm_yday - b->tm_yday);
 656         int hours = 24*days + (a->tm_hour - b->tm_hour);
 657         int minutes = 60*hours + (a->tm_min - b->tm_min);
 658         int seconds = 60*minutes + (a->tm_sec - b->tm_sec);
 659
 660         return seconds;
 661 }
 662
 663
 664 int extra_time_offset=0;
 665
 666 /**
 667   return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
 668  */
 669 _PUBLIC_ int get_time_zone(time_t t)
 670 {
 671         struct tm *tm = gmtime(&t);
 672         struct tm tm_utc;
 673         if (!tm)
 674                 return 0;
 675         tm_utc = *tm;
 676         tm = localtime(&t);
 677         if (!tm)
 678                 return 0;
 679         return tm_diff(&tm_utc,tm)+60*extra_time_offset;
 680 }
 681
 682 struct timespec nt_time_to_unix_timespec(NTTIME *nt)
 683 {
 684         int64_t d;
 685         struct timespec ret;
 686
 687         if (*nt == 0 || *nt == (int64_t)-1) {
 688                 ret.tv_sec = 0;
 689                 ret.tv_nsec = 0;
 690                 return ret;
 691         }
 692
 693         d = (int64_t)*nt;
 694         /* d is now in 100ns units, since jan 1st 1601".
 695            Save off the ns fraction. */
 696
 697         /*
 698          * Take the last seven decimal digits and multiply by 100.
 699          * to convert from 100ns units to 1ns units.
 700          */
 701         ret.tv_nsec = (long) ((d % (1000 * 1000 * 10)) * 100);
 702
 703         /* Convert to seconds */
 704         d /= 1000*1000*10;
 705
 706         /* Now adjust by 369 years to make the secs since 1970 */
 707         d -= TIME_FIXUP_CONSTANT_INT;
 708
 709         if (d <= (int64_t)TIME_T_MIN) {
 710                 ret.tv_sec = TIME_T_MIN;
 711                 ret.tv_nsec = 0;
 712                 return ret;
 713         }
 714
 715         if (d >= (int64_t)TIME_T_MAX) {
 716                 ret.tv_sec = TIME_T_MAX;
 717                 ret.tv_nsec = 0;
 718                 return ret;
 719         }
 720
 721         ret.tv_sec = (time_t)d;
 722         return ret;
 723 }
 724
 725
 726 /**
 727   check if 2 NTTIMEs are equal.
 728 */
 729 bool nt_time_equal(NTTIME *t1, NTTIME *t2)
 730 {
 731         return *t1 == *t2;
 732 }
 733
 734 /**
 735  Check if it's a null timespec.
 736 **/
 737
 738 bool null_timespec(struct timespec ts)
 739 {
 740         return ts.tv_sec == 0 ||
 741                 ts.tv_sec == (time_t)0xFFFFFFFF ||
 742                 ts.tv_sec == (time_t)-1;
 743 }
 744
 745