2 Unix SMB/CIFS implementation.
3 time handling functions
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Stefan (metze) Metzmacher 2002
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 This stuff was largely rewritten by Paul Eggert <eggert@twinsun.com>
29 int extra_time_offset = 0;
36 #define TIME_T_MIN ((time_t)0 < (time_t) -1 ? (time_t) 0 \
37 : ~ (time_t) 0 << (sizeof (time_t) * CHAR_BIT - 1))
40 #define TIME_T_MAX (~ (time_t) 0 - TIME_T_MIN)
43 void get_nttime_max(NTTIME *t)
45 /* FIXME: This is incorrect */
46 unix_to_nt_time(t, get_time_t_max());
49 /*******************************************************************
50 External access to time_t_min and time_t_max.
51 ********************************************************************/
53 time_t get_time_t_max(void)
58 /*******************************************************************
59 A gettimeofday wrapper.
60 ********************************************************************/
62 void GetTimeOfDay(struct timeval *tval)
64 #ifdef HAVE_GETTIMEOFDAY_TZ
65 gettimeofday(tval,NULL);
71 #define TM_YEAR_BASE 1900
73 /*******************************************************************
74 Yield the difference between *A and *B, in seconds, ignoring leap seconds.
75 ********************************************************************/
77 static int tm_diff(struct tm *a, struct tm *b)
79 int ay = a->tm_year + (TM_YEAR_BASE - 1);
80 int by = b->tm_year + (TM_YEAR_BASE - 1);
81 int intervening_leap_days = (ay/4 - by/4) - (ay/100 - by/100) + (ay/400 - by/400);
83 int days = 365*years + intervening_leap_days + (a->tm_yday - b->tm_yday);
84 int hours = 24*days + (a->tm_hour - b->tm_hour);
85 int minutes = 60*hours + (a->tm_min - b->tm_min);
86 int seconds = 60*minutes + (a->tm_sec - b->tm_sec);
91 /*******************************************************************
92 Return the UTC offset in seconds west of UTC, or 0 if it cannot be determined.
93 ******************************************************************/
95 static int TimeZone(time_t t)
97 struct tm *tm = gmtime(&t);
105 return tm_diff(&tm_utc,tm);
108 static BOOL done_serverzone_init;
110 /*******************************************************************
111 Return the smb serverzone value.
112 ******************************************************************/
114 static int get_serverzone(void)
116 static int serverzone;
118 if (!done_serverzone_init) {
119 serverzone = TimeZone(time(NULL));
121 if ((serverzone % 60) != 0) {
122 DEBUG(1,("WARNING: Your timezone is not a multiple of 1 minute.\n"));
125 DEBUG(4,("Serverzone is %d\n",serverzone));
127 done_serverzone_init = True;
133 /*******************************************************************
134 Re-read the smb serverzone value.
135 ******************************************************************/
137 static struct timeval start_time_hires;
141 done_serverzone_init = False;
143 /* Save the start time of this process. */
144 if (start_time_hires.tv_sec == 0 && start_time_hires.tv_usec == 0)
145 GetTimeOfDay(&start_time_hires);
148 /**********************************************************************
149 Return a timeval struct of the uptime of this process. As TimeInit is
150 done before a daemon fork then this is the start time from the parent
152 ***********************************************************************/
154 void get_process_uptime(struct timeval *ret_time)
156 struct timeval time_now_hires;
158 GetTimeOfDay(&time_now_hires);
159 ret_time->tv_sec = time_now_hires.tv_sec - start_time_hires.tv_sec;
160 ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
161 if (time_now_hires.tv_usec < start_time_hires.tv_usec) {
162 ret_time->tv_sec -= 1;
163 ret_time->tv_usec = 1000000 + (time_now_hires.tv_usec - start_time_hires.tv_usec);
165 ret_time->tv_usec = time_now_hires.tv_usec - start_time_hires.tv_usec;
168 /*******************************************************************
169 Return the same value as TimeZone, but it should be more efficient.
171 We keep a table of DST offsets to prevent calling localtime() on each
172 call of this function. This saves a LOT of time on many unixes.
174 Updated by Paul Eggert <eggert@twinsun.com>
175 ********************************************************************/
177 static int TimeZoneFaster(time_t t)
179 static struct dst_table {time_t start,end; int zone;} *tdt, *dst_table = NULL;
180 static int table_size = 0;
187 /* Tunis has a 8 day DST region, we need to be careful ... */
188 #define MAX_DST_WIDTH (365*24*60*60)
189 #define MAX_DST_SKIP (7*24*60*60)
191 for (i=0;i<table_size;i++)
192 if (t >= dst_table[i].start && t <= dst_table[i].end)
196 zone = dst_table[i].zone;
201 tdt = SMB_REALLOC_ARRAY(dst_table, struct dst_table, i+1);
203 DEBUG(0,("TimeZoneFaster: out of memory!\n"));
204 SAFE_FREE(dst_table);
210 dst_table[i].zone = zone;
211 dst_table[i].start = dst_table[i].end = t;
213 /* no entry will cover more than 6 months */
214 low = t - MAX_DST_WIDTH/2;
218 high = t + MAX_DST_WIDTH/2;
222 /* widen the new entry using two bisection searches */
223 while (low+60*60 < dst_table[i].start) {
224 if (dst_table[i].start - low > MAX_DST_SKIP*2)
225 t = dst_table[i].start - MAX_DST_SKIP;
227 t = low + (dst_table[i].start-low)/2;
228 if (TimeZone(t) == zone)
229 dst_table[i].start = t;
234 while (high-60*60 > dst_table[i].end) {
235 if (high - dst_table[i].end > MAX_DST_SKIP*2)
236 t = dst_table[i].end + MAX_DST_SKIP;
238 t = high - (high-dst_table[i].end)/2;
239 if (TimeZone(t) == zone)
240 dst_table[i].end = t;
245 DEBUG(1,("Added DST entry from %s ",
246 asctime(localtime(&dst_table[i].start))));
247 DEBUG(1,("to %s (%d)\n",asctime(localtime(&dst_table[i].end)),
255 /****************************************************************************
256 Return the UTC offset in seconds west of UTC, adjusted for extra time offset.
257 **************************************************************************/
259 int TimeDiff(time_t t)
261 return TimeZoneFaster(t) + 60*extra_time_offset;
264 /****************************************************************************
265 Return the UTC offset in seconds west of UTC, adjusted for extra time
266 offset, for a local time value. If ut = lt + LocTimeDiff(lt), then
267 lt = ut - TimeDiff(ut), but the converse does not necessarily hold near
268 daylight savings transitions because some local times are ambiguous.
269 LocTimeDiff(t) equals TimeDiff(t) except near daylight savings transitions.
270 **************************************************************************/
272 static int LocTimeDiff(time_t lte)
274 time_t lt = lte - 60*extra_time_offset;
275 int d = TimeZoneFaster(lt);
278 /* if overflow occurred, ignore all the adjustments so far */
279 if (((lte < lt) ^ (extra_time_offset < 0)) | ((t < lt) ^ (d < 0)))
282 /* now t should be close enough to the true UTC to yield the right answer */
286 /****************************************************************************
287 Try to optimise the localtime call, it can be quite expensive on some machines.
288 ****************************************************************************/
290 struct tm *LocalTime(time_t *t)
299 #define TIME_FIXUP_CONSTANT (369.0*365.25*24*60*60-(3.0*24*60*60+6.0*60*60))
301 /****************************************************************************
302 Interpret an 8 byte "filetime" structure to a time_t
303 It's originally in "100ns units since jan 1st 1601"
305 An 8 byte value of 0xffffffffffffffff will be returned as (time_t)0.
307 It appears to be kludge-GMT (at least for file listings). This means
308 its the GMT you get by taking a localtime and adding the
309 serverzone. This is NOT the same as GMT in some cases. This routine
310 converts this to real GMT.
311 ****************************************************************************/
313 time_t nt_time_to_unix(NTTIME *nt)
317 /* The next two lines are a fix needed for the
318 broken SCO compiler. JRA. */
319 time_t l_time_min = TIME_T_MIN;
320 time_t l_time_max = TIME_T_MAX;
322 if (nt->high == 0 || (nt->high == 0xffffffff && nt->low == 0xffffffff))
325 d = ((double)nt->high)*4.0*(double)(1<<30);
326 d += (nt->low&0xFFF00000);
329 /* now adjust by 369 years to make the secs since 1970 */
330 d -= TIME_FIXUP_CONSTANT;
338 ret = (time_t)(d+0.5);
340 /* this takes us from kludge-GMT to real GMT */
341 ret -= get_serverzone();
342 ret += LocTimeDiff(ret);
347 /****************************************************************************
348 Convert a NTTIME structure to a time_t.
349 It's originally in "100ns units".
351 This is an absolute version of the one above.
352 By absolute I mean, it doesn't adjust from 1/1/1601 to 1/1/1970
353 if the NTTIME was 5 seconds, the time_t is 5 seconds. JFM
354 ****************************************************************************/
356 time_t nt_time_to_unix_abs(NTTIME *nt)
360 /* The next two lines are a fix needed for the
361 broken SCO compiler. JRA. */
362 time_t l_time_min = TIME_T_MIN;
363 time_t l_time_max = TIME_T_MAX;
368 if (nt->high==0x80000000 && nt->low==0)
371 /* reverse the time */
372 /* it's a negative value, turn it to positive */
376 d = ((double)nt->high)*4.0*(double)(1<<30);
377 d += (nt->low&0xFFF00000);
380 if (!(l_time_min <= d && d <= l_time_max))
383 ret = (time_t)(d+0.5);
388 /****************************************************************************
389 Interprets an nt time into a unix time_t.
390 Differs from nt_time_to_unix in that an 8 byte value of 0xffffffffffffffff
391 will be returned as (time_t)-1, whereas nt_time_to_unix returns 0 in this case.
392 ****************************************************************************/
394 time_t interpret_long_date(char *p)
399 if (nt.low == 0xFFFFFFFF && nt.high == 0xFFFFFFFF) {
402 return nt_time_to_unix(&nt);
405 /****************************************************************************
406 Put a 8 byte filetime from a time_t
407 This takes real GMT as input and converts to kludge-GMT
408 ****************************************************************************/
410 void unix_to_nt_time(NTTIME *nt, time_t t)
419 if (t == TIME_T_MAX) {
420 nt->low = 0xffffffff;
421 nt->high = 0x7fffffff;
424 if (t == (time_t)-1) {
425 nt->low = 0xffffffff;
426 nt->high = 0xffffffff;
430 /* this converts GMT to kludge-GMT */
431 t -= TimeDiff(t) - get_serverzone();
434 d += TIME_FIXUP_CONSTANT;
437 nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
438 nt->low = (uint32)(d - ((double)nt->high)*4.0*(double)(1<<30));
441 /****************************************************************************
442 Convert a time_t to a NTTIME structure
444 This is an absolute version of the one above.
445 By absolute I mean, it doesn't adjust from 1/1/1970 to 1/1/1601
446 If the nttime_t was 5 seconds, the NTTIME is 5 seconds. JFM
447 ****************************************************************************/
449 void unix_to_nt_time_abs(NTTIME *nt, time_t t)
459 if (t == TIME_T_MAX) {
460 nt->low = 0xffffffff;
461 nt->high = 0x7fffffff;
465 if (t == (time_t)-1) {
466 /* that's what NT uses for infinite */
468 nt->high = 0x80000000;
475 nt->high = (uint32)(d * (1.0/(4.0*(double)(1<<30))));
476 nt->low = (uint32)(d - ((double)nt->high)*4.0*(double)(1<<30));
478 /* convert to a negative value */
483 /****************************************************************************
484 Take a Unix time and convert to an NTTIME structure and place in buffer
486 ****************************************************************************/
488 void put_long_date(char *p,time_t t)
491 unix_to_nt_time(&nt, t);
493 SIVAL(p, 4, nt.high);
496 /****************************************************************************
497 Check if it's a null mtime.
498 ****************************************************************************/
500 BOOL null_mtime(time_t mtime)
502 if (mtime == 0 || mtime == (time_t)0xFFFFFFFF || mtime == (time_t)-1)
507 /*******************************************************************
508 Create a 16 bit dos packed date.
509 ********************************************************************/
511 static uint16 make_dos_date1(struct tm *t)
514 ret = (((unsigned)(t->tm_mon+1)) >> 3) | ((t->tm_year-80) << 1);
515 ret = ((ret&0xFF)<<8) | (t->tm_mday | (((t->tm_mon+1) & 0x7) << 5));
519 /*******************************************************************
520 Create a 16 bit dos packed time.
521 ********************************************************************/
523 static uint16 make_dos_time1(struct tm *t)
526 ret = ((((unsigned)t->tm_min >> 3)&0x7) | (((unsigned)t->tm_hour) << 3));
527 ret = ((ret&0xFF)<<8) | ((t->tm_sec/2) | ((t->tm_min & 0x7) << 5));
531 /*******************************************************************
532 Create a 32 bit dos packed date/time from some parameters.
533 This takes a GMT time and returns a packed localtime structure.
534 ********************************************************************/
536 static uint32 make_dos_date(time_t unixdate)
541 t = LocalTime(&unixdate);
545 ret = make_dos_date1(t);
546 ret = ((ret&0xFFFF)<<16) | make_dos_time1(t);
551 /*******************************************************************
552 Put a dos date into a buffer (time/date format).
553 This takes GMT time and puts local time in the buffer.
554 ********************************************************************/
556 void put_dos_date(char *buf,int offset,time_t unixdate)
558 uint32 x = make_dos_date(unixdate);
562 /*******************************************************************
563 Put a dos date into a buffer (date/time format).
564 This takes GMT time and puts local time in the buffer.
565 ********************************************************************/
567 void put_dos_date2(char *buf,int offset,time_t unixdate)
569 uint32 x = make_dos_date(unixdate);
570 x = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
574 /*******************************************************************
575 Put a dos 32 bit "unix like" date into a buffer. This routine takes
576 GMT and converts it to LOCAL time before putting it (most SMBs assume
577 localtime for this sort of date)
578 ********************************************************************/
580 void put_dos_date3(char *buf,int offset,time_t unixdate)
582 if (!null_mtime(unixdate))
583 unixdate -= TimeDiff(unixdate);
584 SIVAL(buf,offset,unixdate);
587 /*******************************************************************
588 Interpret a 32 bit dos packed date/time to some parameters.
589 ********************************************************************/
591 static void interpret_dos_date(uint32 date,int *year,int *month,int *day,int *hour,int *minute,int *second)
595 p0=date&0xFF; p1=((date&0xFF00)>>8)&0xFF;
596 p2=((date&0xFF0000)>>16)&0xFF; p3=((date&0xFF000000)>>24)&0xFF;
598 *second = 2*(p0 & 0x1F);
599 *minute = ((p0>>5)&0xFF) + ((p1&0x7)<<3);
600 *hour = (p1>>3)&0xFF;
602 *month = ((p2>>5)&0xFF) + ((p3&0x1)<<3) - 1;
603 *year = ((p3>>1)&0xFF) + 80;
606 /*******************************************************************
607 Create a unix date (int GMT) from a dos date (which is actually in
609 ********************************************************************/
611 time_t make_unix_date(void *date_ptr)
617 dos_date = IVAL(date_ptr,0);
622 interpret_dos_date(dos_date,&t.tm_year,&t.tm_mon,
623 &t.tm_mday,&t.tm_hour,&t.tm_min,&t.tm_sec);
626 /* mktime() also does the local to GMT time conversion for us */
632 /*******************************************************************
633 Like make_unix_date() but the words are reversed.
634 ********************************************************************/
636 time_t make_unix_date2(void *date_ptr)
640 x = IVAL(date_ptr,0);
641 x2 = ((x&0xFFFF)<<16) | ((x&0xFFFF0000)>>16);
644 return(make_unix_date((void *)&x));
647 /*******************************************************************
648 Create a unix GMT date from a dos date in 32 bit "unix like" format
649 these generally arrive as localtimes, with corresponding DST.
650 ******************************************************************/
652 time_t make_unix_date3(void *date_ptr)
654 time_t t = (time_t)IVAL(date_ptr,0);
660 /***************************************************************************
661 Return a HTTP/1.0 time string.
662 ***************************************************************************/
664 char *http_timestring(time_t t)
667 struct tm *tm = LocalTime(&t);
670 slprintf(buf,sizeof(buf)-1,"%ld seconds since the Epoch",(long)t);
672 #ifndef HAVE_STRFTIME
673 fstrcpy(buf, asctime(tm));
674 if(buf[strlen(buf)-1] == '\n')
675 buf[strlen(buf)-1] = 0;
676 #else /* !HAVE_STRFTIME */
677 strftime(buf, sizeof(buf)-1, "%a, %d %b %Y %H:%M:%S %Z", tm);
678 #endif /* !HAVE_STRFTIME */
682 /****************************************************************************
683 Return the date and time as a string
684 ****************************************************************************/
686 char *timestring(BOOL hires)
688 static fstring TimeBuf;
695 t = (time_t)tp.tv_sec;
704 "%ld.%06ld seconds since the Epoch",
710 "%ld seconds since the Epoch",
716 strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
717 slprintf(TimeBuf+strlen(TimeBuf),
718 sizeof(TimeBuf)-1 - strlen(TimeBuf),
722 strftime(TimeBuf,sizeof(TimeBuf)-1,"%Y/%m/%d %H:%M:%S",tm);
732 fstrcpy(TimeBuf, asctime(tm));
739 /****************************************************************************
740 Return the best approximation to a 'create time' under UNIX from a stat
742 ****************************************************************************/
744 time_t get_create_time(SMB_STRUCT_STAT *st,BOOL fake_dirs)
748 if(S_ISDIR(st->st_mode) && fake_dirs)
749 return (time_t)315493200L; /* 1/1/1980 */
751 ret = MIN(st->st_ctime, st->st_mtime);
752 ret1 = MIN(ret, st->st_atime);
754 if(ret1 != (time_t)0)
758 * One of ctime, mtime or atime was zero (probably atime).
759 * Just return MIN(ctime, mtime).
764 /****************************************************************************
765 Initialise an NTTIME to -1, which means "unknown" or "don't expire".
766 ****************************************************************************/
768 void init_nt_time(NTTIME *nt)
770 nt->high = 0x7FFFFFFF;
771 nt->low = 0xFFFFFFFF;
774 /****************************************************************************
775 Check if NTTIME is 0.
776 ****************************************************************************/
778 BOOL nt_time_is_zero(NTTIME *nt)
785 /****************************************************************************
786 Check if two NTTIMEs are the same.
787 ****************************************************************************/
789 BOOL nt_time_equals(NTTIME *nt1, NTTIME *nt2)
791 return (nt1->high == nt2->high && nt1->low == nt2->low);
794 /****************************************************************************
795 Return a timeval difference in usec.
796 ****************************************************************************/
798 SMB_BIG_INT usec_time_diff(const struct timeval *larget, const struct timeval *smallt)
800 SMB_BIG_INT sec_diff = larget->tv_sec - smallt->tv_sec;
801 return (sec_diff * 1000000) + (SMB_BIG_INT)(larget->tv_usec - smallt->tv_usec);
805 return a timeval struct with the given elements
807 struct timeval timeval_set(uint32_t secs, uint32_t usecs)
816 return a zero timeval
818 struct timeval timeval_zero(void)
820 return timeval_set(0,0);
824 return True if a timeval is zero
826 BOOL timeval_is_zero(const struct timeval *tv)
828 return tv->tv_sec == 0 && tv->tv_usec == 0;
832 return a timeval for the current time
834 struct timeval timeval_current(void)
842 return a timeval ofs microseconds after tv
844 struct timeval timeval_add(const struct timeval *tv,
845 uint32_t secs, uint32_t usecs)
847 struct timeval tv2 = *tv;
849 tv2.tv_usec += usecs;
850 tv2.tv_sec += tv2.tv_usec / 1000000;
851 tv2.tv_usec = tv2.tv_usec % 1000000;
856 return the sum of two timeval structures
858 struct timeval timeval_sum(const struct timeval *tv1,
859 const struct timeval *tv2)
861 return timeval_add(tv1, tv2->tv_sec, tv2->tv_usec);
865 return a timeval secs/usecs into the future
867 struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
869 struct timeval tv = timeval_current();
870 return timeval_add(&tv, secs, usecs);
874 compare two timeval structures.
875 Return -1 if tv1 < tv2
876 Return 0 if tv1 == tv2
877 Return 1 if tv1 > tv2
879 int timeval_compare(const struct timeval *tv1, const struct timeval *tv2)
881 if (tv1->tv_sec > tv2->tv_sec) return 1;
882 if (tv1->tv_sec < tv2->tv_sec) return -1;
883 if (tv1->tv_usec > tv2->tv_usec) return 1;
884 if (tv1->tv_usec < tv2->tv_usec) return -1;
889 return the difference between two timevals as a timeval
890 if tv1 comes after tv2, then return a zero timeval
891 (this is *tv2 - *tv1)
893 struct timeval timeval_until(const struct timeval *tv1,
894 const struct timeval *tv2)
897 if (timeval_compare(tv1, tv2) >= 0) {
898 return timeval_zero();
900 t.tv_sec = tv2->tv_sec - tv1->tv_sec;
901 if (tv1->tv_usec > tv2->tv_usec) {
903 t.tv_usec = 1000000 - (tv1->tv_usec - tv2->tv_usec);
905 t.tv_usec = tv2->tv_usec - tv1->tv_usec;
911 return the lesser of two timevals
913 struct timeval timeval_min(const struct timeval *tv1,
914 const struct timeval *tv2)
916 if (tv1->tv_sec < tv2->tv_sec) return *tv1;
917 if (tv1->tv_sec > tv2->tv_sec) return *tv2;
918 if (tv1->tv_usec < tv2->tv_usec) return *tv1;
923 return the greater of two timevals
925 struct timeval timeval_max(const struct timeval *tv1,
926 const struct timeval *tv2)
928 if (tv1->tv_sec > tv2->tv_sec) return *tv1;
929 if (tv1->tv_sec < tv2->tv_sec) return *tv2;
930 if (tv1->tv_usec > tv2->tv_usec) return *tv1;
934 /****************************************************************************
935 convert ASN.1 GeneralizedTime string to unix-time
936 returns 0 on failure; Currently ignores timezone.
937 ****************************************************************************/
938 time_t generalized_to_unix_time(const char *str)
944 if (sscanf(str, "%4d%2d%2d%2d%2d%2d",
945 &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
946 &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {