2 Unix SMB/CIFS implementation.
3 time handling functions
5 Copyright (C) Andrew Tridgell 1992-2004
6 Copyright (C) Stefan (metze) Metzmacher 2002
7 Copyright (C) Jeremy Allison 2007
8 Copyright (C) Andrew Bartlett 2011
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "system/time.h"
26 #include "byteorder.h"
27 #include "time_basic.h"
28 #include "lib/util/time.h" /* Avoid /usr/include/time.h */
32 * @brief time handling functions
35 #if (SIZEOF_LONG == 8)
36 #define TIME_FIXUP_CONSTANT_INT 11644473600L
37 #elif (SIZEOF_LONG_LONG == 8)
38 #define TIME_FIXUP_CONSTANT_INT 11644473600LL
44 External access to time_t_min and time_t_max.
46 _PUBLIC_
time_t get_time_t_max(void)
52 a wrapper to preferably get the monotonic time
54 _PUBLIC_
void clock_gettime_mono(struct timespec
*tp
)
56 /* prefer a suspend aware monotonic CLOCK_BOOTTIME: */
58 if (clock_gettime(CLOCK_BOOTTIME
,tp
) == 0) {
62 /* then try the monotonic clock: */
63 #ifndef CUSTOM_CLOCK_MONOTONIC_IS_REALTIME
64 if (clock_gettime(CUSTOM_CLOCK_MONOTONIC
,tp
) == 0) {
68 clock_gettime(CLOCK_REALTIME
,tp
);
72 a wrapper to preferably get the monotonic time in seconds
74 _PUBLIC_
time_t time_mono(time_t *t
)
78 clock_gettime_mono(&tp
);
86 #define TIME_FIXUP_CONSTANT 11644473600LL
88 time_t convert_timespec_to_time_t(struct timespec ts
)
90 /* Ensure tv_nsec is less than 1sec. */
91 while (ts
.tv_nsec
> 1000000000) {
93 ts
.tv_nsec
-= 1000000000;
96 /* 1 ns == 1,000,000,000 - one thousand millionths of a second.
97 increment if it's greater than 500 millionth of a second. */
99 if (ts
.tv_nsec
> 500000000) {
100 return ts
.tv_sec
+ 1;
105 struct timespec
convert_time_t_to_timespec(time_t t
)
116 Interpret an 8 byte "filetime" structure to a time_t
117 It's originally in "100ns units since jan 1st 1601"
119 An 8 byte value of 0xffffffffffffffff will be returned as a timespec of
126 time_t nt_time_to_unix(NTTIME nt
)
128 return convert_timespec_to_time_t(nt_time_to_unix_timespec(nt
));
133 put a 8 byte filetime from a time_t
134 This takes GMT as input
136 _PUBLIC_
void unix_to_nt_time(NTTIME
*nt
, time_t t
)
140 if (t
== (time_t)-1) {
145 if (t
== TIME_T_MAX
|| t
== INT64_MAX
) {
146 *nt
= 0x7fffffffffffffffLL
;
156 t2
+= TIME_FIXUP_CONSTANT_INT
;
164 check if it's a null unix time
166 _PUBLIC_
bool null_time(time_t t
)
169 t
== (time_t)0xFFFFFFFF ||
175 check if it's a null NTTIME
177 _PUBLIC_
bool null_nttime(NTTIME t
)
179 return t
== 0 || t
== (NTTIME
)-1;
182 /*******************************************************************
183 create a 16 bit dos packed date
184 ********************************************************************/
185 static uint16_t make_dos_date1(struct tm
*t
)
188 ret
= (((unsigned int)(t
->tm_mon
+1)) >> 3) | ((t
->tm_year
-80) << 1);
189 ret
= ((ret
&0xFF)<<8) | (t
->tm_mday
| (((t
->tm_mon
+1) & 0x7) << 5));
193 /*******************************************************************
194 create a 16 bit dos packed time
195 ********************************************************************/
196 static uint16_t make_dos_time1(struct tm
*t
)
199 ret
= ((((unsigned int)t
->tm_min
>> 3)&0x7) | (((unsigned int)t
->tm_hour
) << 3));
200 ret
= ((ret
&0xFF)<<8) | ((t
->tm_sec
/2) | ((t
->tm_min
& 0x7) << 5));
204 /*******************************************************************
205 create a 32 bit dos packed date/time from some parameters
206 This takes a GMT time and returns a packed localtime structure
207 ********************************************************************/
208 static uint32_t make_dos_date(time_t unixdate
, int zone_offset
)
217 unixdate
-= zone_offset
;
219 t
= gmtime(&unixdate
);
224 ret
= make_dos_date1(t
);
225 ret
= ((ret
&0xFFFF)<<16) | make_dos_time1(t
);
231 put a dos date into a buffer (time/date format)
232 This takes GMT time and puts local time in the buffer
234 _PUBLIC_
void push_dos_date(uint8_t *buf
, int offset
, time_t unixdate
, int zone_offset
)
236 uint32_t x
= make_dos_date(unixdate
, zone_offset
);
241 put a dos date into a buffer (date/time format)
242 This takes GMT time and puts local time in the buffer
244 _PUBLIC_
void push_dos_date2(uint8_t *buf
,int offset
,time_t unixdate
, int zone_offset
)
247 x
= make_dos_date(unixdate
, zone_offset
);
248 x
= ((x
&0xFFFF)<<16) | ((x
&0xFFFF0000)>>16);
253 put a dos 32 bit "unix like" date into a buffer. This routine takes
254 GMT and converts it to LOCAL time before putting it (most SMBs assume
255 localtime for this sort of date)
257 _PUBLIC_
void push_dos_date3(uint8_t *buf
,int offset
,time_t unixdate
, int zone_offset
)
259 if (!null_time(unixdate
)) {
260 unixdate
-= zone_offset
;
262 SIVAL(buf
,offset
,unixdate
);
265 /*******************************************************************
266 interpret a 32 bit dos packed date/time to some parameters
267 ********************************************************************/
268 void interpret_dos_date(uint32_t date
,int *year
,int *month
,int *day
,int *hour
,int *minute
,int *second
)
270 uint32_t p0
,p1
,p2
,p3
;
272 p0
=date
&0xFF; p1
=((date
&0xFF00)>>8)&0xFF;
273 p2
=((date
&0xFF0000)>>16)&0xFF; p3
=((date
&0xFF000000)>>24)&0xFF;
275 *second
= 2*(p0
& 0x1F);
276 *minute
= ((p0
>>5)&0xFF) + ((p1
&0x7)<<3);
277 *hour
= (p1
>>3)&0xFF;
279 *month
= ((p2
>>5)&0xFF) + ((p3
&0x1)<<3) - 1;
280 *year
= ((p3
>>1)&0xFF) + 80;
284 create a unix date (int GMT) from a dos date (which is actually in
287 _PUBLIC_
time_t pull_dos_date(const uint8_t *date_ptr
, int zone_offset
)
293 dos_date
= IVAL(date_ptr
,0);
295 if (dos_date
== 0) return (time_t)0;
297 interpret_dos_date(dos_date
,&t
.tm_year
,&t
.tm_mon
,
298 &t
.tm_mday
,&t
.tm_hour
,&t
.tm_min
,&t
.tm_sec
);
309 like make_unix_date() but the words are reversed
311 _PUBLIC_
time_t pull_dos_date2(const uint8_t *date_ptr
, int zone_offset
)
315 x
= IVAL(date_ptr
,0);
316 x2
= ((x
&0xFFFF)<<16) | ((x
&0xFFFF0000)>>16);
319 return pull_dos_date((const uint8_t *)&x
, zone_offset
);
323 create a unix GMT date from a dos date in 32 bit "unix like" format
324 these generally arrive as localtimes, with corresponding DST
326 _PUBLIC_
time_t pull_dos_date3(const uint8_t *date_ptr
, int zone_offset
)
328 time_t t
= (time_t)IVAL(date_ptr
,0);
335 /****************************************************************************
336 Return the date and time as a string
337 ****************************************************************************/
339 char *timeval_string(TALLOC_CTX
*ctx
, const struct timeval
*tp
, bool hires
)
341 struct timeval_buf tmp
;
344 result
= talloc_strdup(ctx
, timeval_str_buf(tp
, false, hires
, &tmp
));
345 if (result
== NULL
) {
350 * beautify the talloc_report output
352 * This is not just cosmetics. A C compiler might in theory make the
353 * talloc_strdup call above a tail call with the tail call
354 * optimization. This would render "tmp" invalid while talloc_strdup
355 * tries to duplicate it. The talloc_set_name_const call below puts
356 * the talloc_strdup call into non-tail position.
358 talloc_set_name_const(result
, result
);
362 char *current_timestring(TALLOC_CTX
*ctx
, bool hires
)
367 return timeval_string(ctx
, &tv
, hires
);
371 * Return date and time as a minimal string avoiding funny characters
372 * that may cause trouble in file names. We only use digits and
373 * underscore ... or a minus/hyphen if we got negative time.
375 char *minimal_timeval_string(TALLOC_CTX
*ctx
, const struct timeval
*tp
, bool hires
)
380 t
= (time_t)tp
->tv_sec
;
384 return talloc_asprintf(ctx
, "%ld_%06ld",
388 return talloc_asprintf(ctx
, "%ld", (long)t
);
392 return talloc_asprintf(ctx
,
393 "%04d%02d%02d_%02d%02d%02d_%06ld",
402 return talloc_asprintf(ctx
,
403 "%04d%02d%02d_%02d%02d%02d",
414 char *current_minimal_timestring(TALLOC_CTX
*ctx
, bool hires
)
419 return minimal_timeval_string(ctx
, &tv
, hires
);
423 return a HTTP/1.0 time string
425 _PUBLIC_
char *http_timestring(TALLOC_CTX
*mem_ctx
, time_t t
)
429 struct tm
*tm
= localtime(&t
);
431 if (t
== TIME_T_MAX
) {
432 return talloc_strdup(mem_ctx
, "never");
436 return talloc_asprintf(mem_ctx
,"%ld seconds since the Epoch",(long)t
);
439 #ifndef HAVE_STRFTIME
440 buf
= talloc_strdup(mem_ctx
, asctime(tm
));
441 if (buf
[strlen(buf
)-1] == '\n') {
442 buf
[strlen(buf
)-1] = 0;
445 strftime(tempTime
, sizeof(tempTime
)-1, "%a, %d %b %Y %H:%M:%S %Z", tm
);
446 buf
= talloc_strdup(mem_ctx
, tempTime
);
447 #endif /* !HAVE_STRFTIME */
453 Return the date and time as a string
455 _PUBLIC_
char *timestring(TALLOC_CTX
*mem_ctx
, time_t t
)
463 return talloc_asprintf(mem_ctx
,
464 "%ld seconds since the Epoch",
469 /* Some versions of gcc complain about using some special format
470 * specifiers. This is a bug in gcc, not a bug in this code. See a
471 * recent strftime() manual page for details. */
472 strftime(tempTime
,sizeof(tempTime
)-1,"%a %b %e %X %Y %Z",tm
);
473 TimeBuf
= talloc_strdup(mem_ctx
, tempTime
);
475 TimeBuf
= talloc_strdup(mem_ctx
, asctime(tm
));
476 if (TimeBuf
== NULL
) {
479 if (TimeBuf
[0] != '\0') {
480 size_t len
= strlen(TimeBuf
);
481 if (TimeBuf
[len
- 1] == '\n') {
482 TimeBuf
[len
- 1] = '\0';
491 return a talloced string representing a NTTIME for human consumption
493 _PUBLIC_
const char *nt_time_string(TALLOC_CTX
*mem_ctx
, NTTIME nt
)
499 t
= nt_time_to_unix(nt
);
500 return timestring(mem_ctx
, t
);
505 put a NTTIME into a packet
507 _PUBLIC_
void push_nttime(uint8_t *base
, uint16_t offset
, NTTIME t
)
509 SBVAL(base
, offset
, t
);
513 pull a NTTIME from a packet
515 _PUBLIC_ NTTIME
pull_nttime(uint8_t *base
, uint16_t offset
)
517 NTTIME ret
= BVAL(base
, offset
);
522 return (tv1 - tv2) in microseconds
524 _PUBLIC_
int64_t usec_time_diff(const struct timeval
*tv1
, const struct timeval
*tv2
)
526 int64_t sec_diff
= tv1
->tv_sec
- tv2
->tv_sec
;
527 return (sec_diff
* 1000000) + (int64_t)(tv1
->tv_usec
- tv2
->tv_usec
);
531 return (tp1 - tp2) in nanoseconds
533 _PUBLIC_
int64_t nsec_time_diff(const struct timespec
*tp1
, const struct timespec
*tp2
)
535 int64_t sec_diff
= tp1
->tv_sec
- tp2
->tv_sec
;
536 return (sec_diff
* 1000000000) + (int64_t)(tp1
->tv_nsec
- tp2
->tv_nsec
);
541 return a zero timeval
543 _PUBLIC_
struct timeval
timeval_zero(void)
552 return true if a timeval is zero
554 _PUBLIC_
bool timeval_is_zero(const struct timeval
*tv
)
556 return tv
->tv_sec
== 0 && tv
->tv_usec
== 0;
560 return a timeval for the current time
562 _PUBLIC_
struct timeval
timeval_current(void)
570 return a timeval struct with the given elements
572 _PUBLIC_
struct timeval
timeval_set(uint32_t secs
, uint32_t usecs
)
582 return a timeval ofs microseconds after tv
584 _PUBLIC_
struct timeval
timeval_add(const struct timeval
*tv
,
585 uint32_t secs
, uint32_t usecs
)
587 struct timeval tv2
= *tv
;
588 const unsigned int million
= 1000000;
590 tv2
.tv_usec
+= usecs
;
591 tv2
.tv_sec
+= tv2
.tv_usec
/ million
;
592 tv2
.tv_usec
= tv2
.tv_usec
% million
;
597 return the sum of two timeval structures
599 struct timeval
timeval_sum(const struct timeval
*tv1
,
600 const struct timeval
*tv2
)
602 return timeval_add(tv1
, tv2
->tv_sec
, tv2
->tv_usec
);
606 return a timeval secs/usecs into the future
608 _PUBLIC_
struct timeval
timeval_current_ofs(uint32_t secs
, uint32_t usecs
)
610 struct timeval tv
= timeval_current();
611 return timeval_add(&tv
, secs
, usecs
);
615 return a timeval milliseconds into the future
617 _PUBLIC_
struct timeval
timeval_current_ofs_msec(uint32_t msecs
)
619 struct timeval tv
= timeval_current();
620 return timeval_add(&tv
, msecs
/ 1000, (msecs
% 1000) * 1000);
624 return a timeval microseconds into the future
626 _PUBLIC_
struct timeval
timeval_current_ofs_usec(uint32_t usecs
)
628 struct timeval tv
= timeval_current();
629 return timeval_add(&tv
, usecs
/ 1000000, usecs
% 1000000);
633 compare two timeval structures.
634 Return -1 if tv1 < tv2
635 Return 0 if tv1 == tv2
636 Return 1 if tv1 > tv2
638 _PUBLIC_
int timeval_compare(const struct timeval
*tv1
, const struct timeval
*tv2
)
640 if (tv1
->tv_sec
> tv2
->tv_sec
) return 1;
641 if (tv1
->tv_sec
< tv2
->tv_sec
) return -1;
642 if (tv1
->tv_usec
> tv2
->tv_usec
) return 1;
643 if (tv1
->tv_usec
< tv2
->tv_usec
) return -1;
648 return true if a timer is in the past
650 _PUBLIC_
bool timeval_expired(const struct timeval
*tv
)
652 struct timeval tv2
= timeval_current();
653 if (tv2
.tv_sec
> tv
->tv_sec
) return true;
654 if (tv2
.tv_sec
< tv
->tv_sec
) return false;
655 return (tv2
.tv_usec
>= tv
->tv_usec
);
659 return the number of seconds elapsed between two times
661 _PUBLIC_
double timeval_elapsed2(const struct timeval
*tv1
, const struct timeval
*tv2
)
663 return (tv2
->tv_sec
- tv1
->tv_sec
) +
664 (tv2
->tv_usec
- tv1
->tv_usec
)*1.0e-6;
668 return the number of seconds elapsed since a given time
670 _PUBLIC_
double timeval_elapsed(const struct timeval
*tv
)
672 struct timeval tv2
= timeval_current();
673 return timeval_elapsed2(tv
, &tv2
);
676 * return the number of seconds elapsed between two times
678 _PUBLIC_
double timespec_elapsed2(const struct timespec
*ts1
,
679 const struct timespec
*ts2
)
681 return (ts2
->tv_sec
- ts1
->tv_sec
) +
682 (ts2
->tv_nsec
- ts1
->tv_nsec
)*1.0e-9;
686 * return the number of seconds elapsed since a given time
688 _PUBLIC_
double timespec_elapsed(const struct timespec
*ts
)
690 struct timespec ts2
= timespec_current();
691 return timespec_elapsed2(ts
, &ts2
);
695 return the lesser of two timevals
697 _PUBLIC_
struct timeval
timeval_min(const struct timeval
*tv1
,
698 const struct timeval
*tv2
)
700 if (tv1
->tv_sec
< tv2
->tv_sec
) return *tv1
;
701 if (tv1
->tv_sec
> tv2
->tv_sec
) return *tv2
;
702 if (tv1
->tv_usec
< tv2
->tv_usec
) return *tv1
;
707 return the greater of two timevals
709 _PUBLIC_
struct timeval
timeval_max(const struct timeval
*tv1
,
710 const struct timeval
*tv2
)
712 if (tv1
->tv_sec
> tv2
->tv_sec
) return *tv1
;
713 if (tv1
->tv_sec
< tv2
->tv_sec
) return *tv2
;
714 if (tv1
->tv_usec
> tv2
->tv_usec
) return *tv1
;
719 return the difference between two timevals as a timeval
720 if tv1 comes after tv2, then return a zero timeval
721 (this is *tv2 - *tv1)
723 _PUBLIC_
struct timeval
timeval_until(const struct timeval
*tv1
,
724 const struct timeval
*tv2
)
727 if (timeval_compare(tv1
, tv2
) >= 0) {
728 return timeval_zero();
730 t
.tv_sec
= tv2
->tv_sec
- tv1
->tv_sec
;
731 if (tv1
->tv_usec
> tv2
->tv_usec
) {
733 t
.tv_usec
= 1000000 - (tv1
->tv_usec
- tv2
->tv_usec
);
735 t
.tv_usec
= tv2
->tv_usec
- tv1
->tv_usec
;
742 convert a timeval to a NTTIME
744 _PUBLIC_ NTTIME
timeval_to_nttime(const struct timeval
*tv
)
746 return 10*(tv
->tv_usec
+
747 ((TIME_FIXUP_CONSTANT
+ (uint64_t)tv
->tv_sec
) * 1000000));
751 convert a NTTIME to a timeval
753 _PUBLIC_
void nttime_to_timeval(struct timeval
*tv
, NTTIME t
)
755 if (tv
== NULL
) return;
759 t
-= TIME_FIXUP_CONSTANT
*1000*1000;
761 tv
->tv_sec
= t
/ 1000000;
763 if (TIME_T_MIN
> tv
->tv_sec
|| tv
->tv_sec
> TIME_T_MAX
) {
769 tv
->tv_usec
= t
- tv
->tv_sec
*1000000;
772 /*******************************************************************
773 yield the difference between *A and *B, in seconds, ignoring leap seconds
774 ********************************************************************/
775 static int tm_diff(struct tm
*a
, struct tm
*b
)
777 int ay
= a
->tm_year
+ (1900 - 1);
778 int by
= b
->tm_year
+ (1900 - 1);
779 int intervening_leap_days
=
780 (ay
/4 - by
/4) - (ay
/100 - by
/100) + (ay
/400 - by
/400);
782 int days
= 365*years
+ intervening_leap_days
+ (a
->tm_yday
- b
->tm_yday
);
783 int hours
= 24*days
+ (a
->tm_hour
- b
->tm_hour
);
784 int minutes
= 60*hours
+ (a
->tm_min
- b
->tm_min
);
785 int seconds
= 60*minutes
+ (a
->tm_sec
- b
->tm_sec
);
792 return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
794 _PUBLIC_
int get_time_zone(time_t t
)
796 struct tm
*tm
= gmtime(&t
);
804 return tm_diff(&tm_utc
,tm
);
807 struct timespec
nt_time_to_unix_timespec(NTTIME nt
)
812 if (nt
== 0 || nt
== (int64_t)-1) {
819 /* d is now in 100ns units, since jan 1st 1601".
820 Save off the ns fraction. */
823 * Take the last seven decimal digits and multiply by 100.
824 * to convert from 100ns units to 1ns units.
826 ret
.tv_nsec
= (long) ((d
% (1000 * 1000 * 10)) * 100);
828 /* Convert to seconds */
831 /* Now adjust by 369 years to make the secs since 1970 */
832 d
-= TIME_FIXUP_CONSTANT_INT
;
834 if (d
<= (int64_t)TIME_T_MIN
) {
835 ret
.tv_sec
= TIME_T_MIN
;
840 if (d
>= (int64_t)TIME_T_MAX
) {
841 ret
.tv_sec
= TIME_T_MAX
;
846 ret
.tv_sec
= (time_t)d
;
852 check if 2 NTTIMEs are equal.
854 bool nt_time_equal(NTTIME
*t1
, NTTIME
*t2
)
860 Check if it's a null timespec.
863 bool null_timespec(struct timespec ts
)
865 return ts
.tv_sec
== 0 ||
866 ts
.tv_sec
== (time_t)0xFFFFFFFF ||
867 ts
.tv_sec
== (time_t)-1;
870 /****************************************************************************
871 Convert a normalized timeval to a timespec.
872 ****************************************************************************/
874 struct timespec
convert_timeval_to_timespec(const struct timeval tv
)
877 ts
.tv_sec
= tv
.tv_sec
;
878 ts
.tv_nsec
= tv
.tv_usec
* 1000;
882 /****************************************************************************
883 Convert a normalized timespec to a timeval.
884 ****************************************************************************/
886 struct timeval
convert_timespec_to_timeval(const struct timespec ts
)
889 tv
.tv_sec
= ts
.tv_sec
;
890 tv
.tv_usec
= ts
.tv_nsec
/ 1000;
894 /****************************************************************************
895 Return a timespec for the current time
896 ****************************************************************************/
898 _PUBLIC_
struct timespec
timespec_current(void)
901 clock_gettime(CLOCK_REALTIME
, &ts
);
905 /****************************************************************************
906 Return the lesser of two timespecs.
907 ****************************************************************************/
909 struct timespec
timespec_min(const struct timespec
*ts1
,
910 const struct timespec
*ts2
)
912 if (ts1
->tv_sec
< ts2
->tv_sec
) return *ts1
;
913 if (ts1
->tv_sec
> ts2
->tv_sec
) return *ts2
;
914 if (ts1
->tv_nsec
< ts2
->tv_nsec
) return *ts1
;
918 /****************************************************************************
919 compare two timespec structures.
920 Return -1 if ts1 < ts2
921 Return 0 if ts1 == ts2
922 Return 1 if ts1 > ts2
923 ****************************************************************************/
925 _PUBLIC_
int timespec_compare(const struct timespec
*ts1
, const struct timespec
*ts2
)
927 if (ts1
->tv_sec
> ts2
->tv_sec
) return 1;
928 if (ts1
->tv_sec
< ts2
->tv_sec
) return -1;
929 if (ts1
->tv_nsec
> ts2
->tv_nsec
) return 1;
930 if (ts1
->tv_nsec
< ts2
->tv_nsec
) return -1;
934 /****************************************************************************
935 Round up a timespec if nsec > 500000000, round down if lower,
937 ****************************************************************************/
939 void round_timespec_to_sec(struct timespec
*ts
)
941 ts
->tv_sec
= convert_timespec_to_time_t(*ts
);
945 /****************************************************************************
946 Round a timespec to usec value.
947 ****************************************************************************/
949 void round_timespec_to_usec(struct timespec
*ts
)
951 struct timeval tv
= convert_timespec_to_timeval(*ts
);
952 *ts
= convert_timeval_to_timespec(tv
);
953 while (ts
->tv_nsec
> 1000000000) {
955 ts
->tv_nsec
-= 1000000000;
959 /****************************************************************************
960 Round a timespec to NTTIME resolution.
961 ****************************************************************************/
963 void round_timespec_to_nttime(struct timespec
*ts
)
965 ts
->tv_nsec
= (ts
->tv_nsec
/ 100) * 100;
968 /****************************************************************************
969 Put a 8 byte filetime from a struct timespec. Uses GMT.
970 ****************************************************************************/
972 _PUBLIC_ NTTIME
unix_timespec_to_nt_time(struct timespec ts
)
976 if (ts
.tv_sec
==0 && ts
.tv_nsec
== 0) {
979 if (ts
.tv_sec
== TIME_T_MAX
) {
980 return 0x7fffffffffffffffLL
;
982 if (ts
.tv_sec
== (time_t)-1) {
987 d
+= TIME_FIXUP_CONSTANT_INT
;
989 /* d is now in 100ns units. */
990 d
+= (ts
.tv_nsec
/ 100);