2 Unix SMB/CIFS implementation.
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/>.
24 #ifndef _SAMBA_TIME_H_
25 #define _SAMBA_TIME_H_
33 /* we use 0 here, because (time_t)-1 means error */
38 * we use the INT32_MAX here as on 64 bit systems,
39 * gmtime() fails with INT64_MAX
42 #define TIME_T_MAX MIN(INT32_MAX,_TYPE_MAXIMUM(time_t))
46 * According to Windows API FileTimeToSystemTime() documentation the highest
47 * allowed value " ... must be less than 0x8000000000000000.".
49 #define NTTIME_MAX INT64_MAX
52 * The lowest possible value when NTTIME=0 is used as sentinel value.
57 * NTTIME_OMIT in a setinfo tells us to not modify the corresponding on-disk
63 * Disable automatic timestamp updates, as described in MS-FSA. Samba doesn't
66 #define NTTIME_FREEZE UINT64_MAX
67 #define NTTIME_THAW (UINT64_MAX - 1)
69 #define SAMBA_UTIME_NOW UTIME_NOW
70 #define SAMBA_UTIME_OMIT UTIME_OMIT
72 /* 64 bit time (100 nanosec) 1601 - cifs6.txt, section 3.5, page 30, 4 byte aligned */
73 typedef uint64_t NTTIME
;
75 #define NTTIME_USEC (10UL)
76 #define NTTIME_MSEC (1000UL * NTTIME_USEC)
79 External access to time_t_min and time_t_max.
81 time_t get_time_t_max(void);
84 a gettimeofday wrapper
86 void GetTimeOfDay(struct timeval
*tval
);
89 a wrapper to preferably get the monotonic time
91 void clock_gettime_mono(struct timespec
*tp
);
94 a wrapper to preferably get the monotonic time in s
96 time_t time_mono(time_t *t
);
99 interpret an 8 byte "filetime" structure to a time_t
100 It's originally in "100ns units since jan 1st 1601"
102 time_t nt_time_to_unix(NTTIME nt
);
105 put a 8 byte filetime from a time_t
106 This takes GMT as input
108 void unix_to_nt_time(NTTIME
*nt
, time_t t
);
111 check if it's a null unix time
113 bool null_time(time_t t
);
116 check if it's a null NTTIME
118 bool null_nttime(NTTIME t
);
121 put a dos date into a buffer (time/date format)
122 This takes GMT time and puts local time in the buffer
124 void push_dos_date(uint8_t *buf
, int offset
, time_t unixdate
, int zone_offset
);
127 put a dos date into a buffer (date/time format)
128 This takes GMT time and puts local time in the buffer
130 void push_dos_date2(uint8_t *buf
,int offset
,time_t unixdate
, int zone_offset
);
133 put a dos 32 bit "unix like" date into a buffer. This routine takes
134 GMT and converts it to LOCAL time before putting it (most SMBs assume
135 localtime for this sort of date)
137 void push_dos_date3(uint8_t *buf
,int offset
,time_t unixdate
, int zone_offset
);
140 create a unix date (int GMT) from a dos date (which is actually in
143 time_t pull_dos_date(const uint8_t *date_ptr
, int zone_offset
);
146 like make_unix_date() but the words are reversed
148 time_t pull_dos_date2(const uint8_t *date_ptr
, int zone_offset
);
151 create a unix GMT date from a dos date in 32 bit "unix like" format
152 these generally arrive as localtimes, with corresponding DST
154 time_t pull_dos_date3(const uint8_t *date_ptr
, int zone_offset
);
157 Return a date and time as a string (optionally with microseconds)
159 format is %Y/%m/%d %H:%M:%S if strftime is available
162 char *timeval_string(TALLOC_CTX
*ctx
, const struct timeval
*tp
, bool hires
);
165 const char *timespec_string_buf(const struct timespec
*tp
,
167 struct timeval_buf
*buf
);
170 Return the current date and time as a string (optionally with microseconds)
172 format is %Y/%m/%d %H:%M:%S if strftime is available
174 char *current_timestring(TALLOC_CTX
*ctx
, bool hires
);
177 Return a date and time as a string (optionally with microseconds)
179 format is %Y%m%d_%H%M%S or %Y%m%d_%H%M%S_%us
182 char *minimal_timeval_string(TALLOC_CTX
*ctx
, const struct timeval
*tp
, bool hires
);
185 Return the current date and time as a string (optionally with microseconds)
187 format is %Y%m%d_%H%M%S or %Y%m%d_%H%M%S_%us
189 char *current_minimal_timestring(TALLOC_CTX
*ctx
, bool hires
);
192 return a HTTP/1.0 time string
194 char *http_timestring(TALLOC_CTX
*mem_ctx
, time_t t
);
197 Return the date and time as a string
199 format is %a %b %e %X %Y %Z
201 char *timestring(TALLOC_CTX
*mem_ctx
, time_t t
);
204 return a talloced string representing a NTTIME for human consumption
206 const char *nt_time_string(TALLOC_CTX
*mem_ctx
, NTTIME nt
);
209 put a NTTIME into a packet
211 void push_nttime(uint8_t *base
, uint16_t offset
, NTTIME t
);
214 pull a NTTIME from a packet
216 NTTIME
pull_nttime(uint8_t *base
, uint16_t offset
);
219 return (tv1 - tv2) in microseconds
221 int64_t usec_time_diff(const struct timeval
*tv1
, const struct timeval
*tv2
);
224 return (tp1 - tp2) in nanoseconds
226 int64_t nsec_time_diff(const struct timespec
*tp1
, const struct timespec
*tp2
);
229 return a zero timeval
231 struct timeval
timeval_zero(void);
234 return true if a timeval is zero
236 bool timeval_is_zero(const struct timeval
*tv
);
239 return a timeval for the current time
241 struct timeval
timeval_current(void);
244 return a timeval struct with the given elements
246 struct timeval
timeval_set(uint32_t secs
, uint32_t usecs
);
249 return a timeval ofs microseconds after tv
251 struct timeval
timeval_add(const struct timeval
*tv
,
252 uint32_t secs
, uint32_t usecs
);
255 return the sum of two timeval structures
257 struct timeval
timeval_sum(const struct timeval
*tv1
,
258 const struct timeval
*tv2
);
261 return a timeval secs/usecs into the future
263 struct timeval
timeval_current_ofs(uint32_t secs
, uint32_t usecs
);
266 return a timeval milliseconds into the future
268 struct timeval
timeval_current_ofs_msec(uint32_t msecs
);
271 return a timeval microseconds into the future
273 struct timeval
timeval_current_ofs_usec(uint32_t usecs
);
276 compare two timeval structures.
277 Return -1 if tv1 < tv2
278 Return 0 if tv1 == tv2
279 Return 1 if tv1 > tv2
281 int timeval_compare(const struct timeval
*tv1
, const struct timeval
*tv2
);
284 return true if a timer is in the past
286 bool timeval_expired(const struct timeval
*tv
);
289 return the number of seconds elapsed between two times
291 double timeval_elapsed2(const struct timeval
*tv1
, const struct timeval
*tv2
);
294 return the number of seconds elapsed since a given time
296 double timeval_elapsed(const struct timeval
*tv
);
299 return the number of seconds elapsed between two times
301 double timespec_elapsed2(const struct timespec
*ts1
,
302 const struct timespec
*ts2
);
304 return the number of seconds elapsed since a given time
306 double timespec_elapsed(const struct timespec
*ts
);
309 return the lesser of two timevals
311 struct timeval
timeval_min(const struct timeval
*tv1
,
312 const struct timeval
*tv2
);
315 return the greater of two timevals
317 struct timeval
timeval_max(const struct timeval
*tv1
,
318 const struct timeval
*tv2
);
321 return the difference between two timevals as a timeval
322 if tv1 comes after tv2, then return a zero timeval
323 (this is *tv2 - *tv1)
325 struct timeval
timeval_until(const struct timeval
*tv1
,
326 const struct timeval
*tv2
);
329 convert a timeval to a NTTIME
331 NTTIME
timeval_to_nttime(const struct timeval
*tv
);
334 convert a NTTIME to a timeval
336 void nttime_to_timeval(struct timeval
*tv
, NTTIME t
);
339 return the UTC offset in seconds west of UTC, or 0 if it cannot be determined
341 int get_time_zone(time_t t
);
344 check if 2 NTTIMEs are equal.
346 bool nt_time_equal(NTTIME
*t1
, NTTIME
*t2
);
348 void interpret_dos_date(uint32_t date
,int *year
,int *month
,int *day
,int *hour
,int *minute
,int *second
);
350 struct timespec
nt_time_to_unix_timespec_raw(NTTIME nt
);
352 struct timespec
nt_time_to_unix_timespec(NTTIME nt
);
354 time_t convert_timespec_to_time_t(struct timespec ts
);
356 struct timespec
convert_time_t_to_timespec(time_t t
);
358 bool null_timespec(struct timespec ts
);
360 struct timespec
convert_timeval_to_timespec(const struct timeval tv
);
361 struct timeval
convert_timespec_to_timeval(const struct timespec ts
);
362 struct timespec
timespec_current(void);
363 struct timespec
timespec_min(const struct timespec
*ts1
,
364 const struct timespec
*ts2
);
365 int timespec_compare(const struct timespec
*ts1
, const struct timespec
*ts2
);
366 void round_timespec_to_sec(struct timespec
*ts
);
367 void round_timespec_to_usec(struct timespec
*ts
);
368 void round_timespec_to_nttime(struct timespec
*ts
);
369 NTTIME
unix_timespec_to_nt_time(struct timespec ts
);
370 void normalize_timespec(struct timespec
*ts
);
373 * Functions supporting the full range of time_t and struct timespec values,
374 * including 0, -1 and all other negative values. These functions don't use 0 or
375 * -1 values as sentinel to denote "unset" variables, but use the POSIX 2008
376 * define UTIME_OMIT from utimensat(2).
378 bool is_omit_timespec(const struct timespec
*ts
);
379 struct timespec
make_omit_timespec(void);
380 NTTIME
full_timespec_to_nt_time(const struct timespec
*ts
);
381 struct timespec
nt_time_to_full_timespec(NTTIME nt
);
382 time_t full_timespec_to_time_t(const struct timespec
*ts
);
383 time_t nt_time_to_full_time_t(NTTIME nt
);
384 struct timespec
time_t_to_full_timespec(time_t t
);
387 * Functions to get and set the number of nanoseconds for times in a stat field.
388 * If the stat has timestamp granularity less than nanosecond, then the set_*
389 * operations will be lossy.
392 time_t get_atimensec(const struct stat
*);
393 time_t get_mtimensec(const struct stat
*);
394 time_t get_ctimensec(const struct stat
*);
395 void set_atimensec(struct stat
*, time_t);
396 void set_mtimensec(struct stat
*, time_t);
397 void set_ctimensec(struct stat
*, time_t);
399 /* These are convenience wrappers for the above getters. */
400 struct timespec
get_atimespec(const struct stat
*);
401 struct timespec
get_mtimespec(const struct stat
*);
402 struct timespec
get_ctimespec(const struct stat
*);
404 #endif /* _SAMBA_TIME_H_ */