Merge branch 'wk/test-gpgrt-estream'
[gnupg.git] / common / gettime.c
1 /* gettime.c - Wrapper for time functions
2  * Copyright (C) 1998, 2002, 2007, 2011 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * This file is free software; you can redistribute it and/or modify
7  * it under the terms of either
8  *
9  *   - the GNU Lesser General Public License as published by the Free
10  *     Software Foundation; either version 3 of the License, or (at
11  *     your option) any later version.
12  *
13  * or
14  *
15  *   - the GNU General Public License as published by the Free
16  *     Software Foundation; either version 2 of the License, or (at
17  *     your option) any later version.
18  *
19  * or both in parallel, as here.
20  *
21  * This file is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  * GNU General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, see <http://www.gnu.org/licenses/>.
28  */
29
30 #include <config.h>
31 #include <stdlib.h>
32 #include <time.h>
33 #include <ctype.h>
34 #ifdef HAVE_LANGINFO_H
35 #include <langinfo.h>
36 #endif
37
38 #include "util.h"
39 #include "i18n.h"
40 #include "gettime.h"
41
42 #ifdef HAVE_UNSIGNED_TIME_T
43 # define IS_INVALID_TIME_T(a) ((a) == (time_t)(-1))
44 #else
45   /* Error or 32 bit time_t and value after 2038-01-19.  */
46 # define IS_INVALID_TIME_T(a) ((a) < 0)
47 #endif
48
49
50 static unsigned long timewarp;
51 static enum { NORMAL = 0, FROZEN, FUTURE, PAST } timemode;
52
53 /* Correction used to map to real Julian days. */
54 #define JD_DIFF 1721060L
55
56
57 /* Wrapper for the time(3).  We use this here so we can fake the time
58    for tests */
59 time_t
60 gnupg_get_time ()
61 {
62   time_t current = time (NULL);
63   if (timemode == NORMAL)
64     return current;
65   else if (timemode == FROZEN)
66     return timewarp;
67   else if (timemode == FUTURE)
68     return current + timewarp;
69   else
70     return current - timewarp;
71 }
72
73
74 /* Return the current time (possibly faked) in ISO format. */
75 void
76 gnupg_get_isotime (gnupg_isotime_t timebuf)
77 {
78   time_t atime = gnupg_get_time ();
79
80   if (atime == (time_t)(-1))
81     *timebuf = 0;
82   else
83     {
84       struct tm *tp;
85 #ifdef HAVE_GMTIME_R
86       struct tm tmbuf;
87
88       tp = gmtime_r (&atime, &tmbuf);
89 #else
90       tp = gmtime (&atime);
91 #endif
92       snprintf (timebuf, 16, "%04d%02d%02dT%02d%02d%02d",
93                 1900 + tp->tm_year, tp->tm_mon+1, tp->tm_mday,
94                 tp->tm_hour, tp->tm_min, tp->tm_sec);
95     }
96 }
97
98
99 /* Set the time to NEWTIME so that gnupg_get_time returns a time
100    starting with this one.  With FREEZE set to 1 the returned time
101    will never change.  Just for completeness, a value of (time_t)-1
102    for NEWTIME gets you back to reality.  Note that this is obviously
103    not thread-safe but this is not required. */
104 void
105 gnupg_set_time (time_t newtime, int freeze)
106 {
107   time_t current = time (NULL);
108
109   if ( newtime == (time_t)-1 || current == newtime)
110     {
111       timemode = NORMAL;
112       timewarp = 0;
113     }
114   else if (freeze)
115     {
116       timemode = FROZEN;
117       timewarp = current;
118     }
119   else if (newtime > current)
120     {
121       timemode = FUTURE;
122       timewarp = newtime - current;
123     }
124   else
125     {
126       timemode = PAST;
127       timewarp = current - newtime;
128     }
129 }
130
131 /* Returns true when we are in timewarp mode */
132 int
133 gnupg_faked_time_p (void)
134 {
135   return timemode;
136 }
137
138
139 /* This function is used by gpg because OpenPGP defines the timestamp
140    as an unsigned 32 bit value. */
141 u32
142 make_timestamp (void)
143 {
144   time_t t = gnupg_get_time ();
145
146   if (t == (time_t)-1)
147     log_fatal ("gnupg_get_time() failed\n");
148   return (u32)t;
149 }
150
151
152
153 /****************
154  * Scan a date string and return a timestamp.
155  * The only supported format is "yyyy-mm-dd"
156  * Returns 0 for an invalid date.
157  */
158 u32
159 scan_isodatestr( const char *string )
160 {
161     int year, month, day;
162     struct tm tmbuf;
163     time_t stamp;
164     int i;
165
166     if( strlen(string) != 10 || string[4] != '-' || string[7] != '-' )
167         return 0;
168     for( i=0; i < 4; i++ )
169         if( !digitp (string+i) )
170             return 0;
171     if( !digitp (string+5) || !digitp(string+6) )
172         return 0;
173     if( !digitp(string+8) || !digitp(string+9) )
174         return 0;
175     year = atoi(string);
176     month = atoi(string+5);
177     day = atoi(string+8);
178     /* some basic checks */
179     if( year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 )
180         return 0;
181     memset( &tmbuf, 0, sizeof tmbuf );
182     tmbuf.tm_mday = day;
183     tmbuf.tm_mon = month-1;
184     tmbuf.tm_year = year - 1900;
185     tmbuf.tm_isdst = -1;
186     stamp = mktime( &tmbuf );
187     if( stamp == (time_t)-1 )
188         return 0;
189     return stamp;
190 }
191
192
193 int
194 isotime_p (const char *string)
195 {
196   const char *s;
197   int i;
198
199   if (!*string)
200     return 0;
201   for (s=string, i=0; i < 8; i++, s++)
202     if (!digitp (s))
203       return 0;
204   if (*s != 'T')
205       return 0;
206   for (s++, i=9; i < 15; i++, s++)
207     if (!digitp (s))
208       return 0;
209   if ( !(!*s || (isascii (*s) && isspace(*s)) || *s == ':' || *s == ','))
210     return 0;  /* Wrong delimiter.  */
211
212   return 1;
213 }
214
215
216 /* Scan a string and return true if the string represents the human
217    readable format of an ISO time.  This format is:
218       yyyy-mm-dd[ hh[:mm[:ss]]]
219    Scanning stops at the second space or at a comma.  */
220 int
221 isotime_human_p (const char *string)
222 {
223   const char *s;
224   int i;
225
226   if (!*string)
227     return 0;
228   for (s=string, i=0; i < 4; i++, s++)
229     if (!digitp (s))
230       return 0;
231   if (*s != '-')
232     return 0;
233   s++;
234   if (!digitp (s) || !digitp (s+1) || s[2] != '-')
235     return 0;
236   i = atoi_2 (s);
237   if (i < 1 || i > 12)
238     return 0;
239   s += 3;
240   if (!digitp (s) || !digitp (s+1))
241     return 0;
242   i = atoi_2 (s);
243   if (i < 1 || i > 31)
244     return 0;
245   s += 2;
246   if (!*s || *s == ',')
247     return 1; /* Okay; only date given.  */
248   if (!spacep (s))
249     return 0;
250   s++;
251   if (spacep (s))
252     return 1; /* Okay, second space stops scanning.  */
253   if (!digitp (s) || !digitp (s+1))
254     return 0;
255   i = atoi_2 (s);
256   if (i < 0 || i > 23)
257     return 0;
258   s += 2;
259   if (!*s || *s == ',')
260     return 1; /* Okay; only date and hour given.  */
261   if (*s != ':')
262     return 0;
263   s++;
264   if (!digitp (s) || !digitp (s+1))
265     return 0;
266   i = atoi_2 (s);
267   if (i < 0 || i > 59)
268     return 0;
269   s += 2;
270   if (!*s || *s == ',')
271     return 1; /* Okay; only date, hour and minute given.  */
272   if (*s != ':')
273     return 0;
274   s++;
275   if (!digitp (s) || !digitp (s+1))
276     return 0;
277   i = atoi_2 (s);
278   if (i < 0 || i > 60)
279     return 0;
280   s += 2;
281   if (!*s || *s == ',' || spacep (s))
282     return 1; /* Okay; date, hour and minute and second given.  */
283
284   return 0; /* Unexpected delimiter.  */
285 }
286
287 /* Convert a standard isotime or a human readable variant into an
288    isotime structure.  The allowed formats are those described by
289    isotime_p and isotime_human_p.  The function returns 0 on failure
290    or the length of the scanned string on success.  */
291 size_t
292 string2isotime (gnupg_isotime_t atime, const char *string)
293 {
294   gnupg_isotime_t dummyatime;
295
296   if (!atime)
297     atime = dummyatime;
298
299   atime[0] = 0;
300   if (isotime_p (string))
301     {
302       memcpy (atime, string, 15);
303       atime[15] = 0;
304       return 15;
305     }
306   if (!isotime_human_p (string))
307     return 0;
308   atime[0] = string[0];
309   atime[1] = string[1];
310   atime[2] = string[2];
311   atime[3] = string[3];
312   atime[4] = string[5];
313   atime[5] = string[6];
314   atime[6] = string[8];
315   atime[7] = string[9];
316   atime[8] = 'T';
317   memset (atime+9, '0', 6);
318   atime[15] = 0;
319   if (!spacep (string+10))
320     return 10;
321   if (spacep (string+11))
322     return 11; /* As per def, second space stops scanning.  */
323   atime[9] = string[11];
324   atime[10] = string[12];
325   if (string[13] != ':')
326     return 13;
327   atime[11] = string[14];
328   atime[12] = string[15];
329   if (string[16] != ':')
330     return 16;
331   atime[13] = string[17];
332   atime[14] = string[18];
333   return 19;
334 }
335
336
337 /* Scan an ISO timestamp and return an Epoch based timestamp.  The only
338    supported format is "yyyymmddThhmmss" delimited by white space, nul, a
339    colon or a comma.  Returns (time_t)(-1) for an invalid string.  */
340 time_t
341 isotime2epoch (const char *string)
342 {
343   int year, month, day, hour, minu, sec;
344   struct tm tmbuf;
345
346   if (!isotime_p (string))
347     return (time_t)(-1);
348
349   year  = atoi_4 (string);
350   month = atoi_2 (string + 4);
351   day   = atoi_2 (string + 6);
352   hour  = atoi_2 (string + 9);
353   minu  = atoi_2 (string + 11);
354   sec   = atoi_2 (string + 13);
355
356   /* Basic checks.  */
357   if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31
358       || hour > 23 || minu > 59 || sec > 61 )
359     return (time_t)(-1);
360
361   memset (&tmbuf, 0, sizeof tmbuf);
362   tmbuf.tm_sec  = sec;
363   tmbuf.tm_min  = minu;
364   tmbuf.tm_hour = hour;
365   tmbuf.tm_mday = day;
366   tmbuf.tm_mon  = month-1;
367   tmbuf.tm_year = year - 1900;
368   tmbuf.tm_isdst = -1;
369   return timegm (&tmbuf);
370 }
371
372
373 /* Convert an Epoch time to an iso time stamp. */
374 void
375 epoch2isotime (gnupg_isotime_t timebuf, time_t atime)
376 {
377   if (atime == (time_t)(-1))
378     *timebuf = 0;
379   else
380     {
381       struct tm *tp;
382 #ifdef HAVE_GMTIME_R
383       struct tm tmbuf;
384
385       tp = gmtime_r (&atime, &tmbuf);
386 #else
387       tp = gmtime (&atime);
388 #endif
389       snprintf (timebuf, 16, "%04d%02d%02dT%02d%02d%02d",
390                 1900 + tp->tm_year, tp->tm_mon+1, tp->tm_mday,
391                 tp->tm_hour, tp->tm_min, tp->tm_sec);
392     }
393 }
394
395
396
397
398 u32
399 add_days_to_timestamp( u32 stamp, u16 days )
400 {
401     return stamp + days*86400L;
402 }
403
404
405 /****************
406  * Return a string with a time value in the form: x Y, n D, n H
407  */
408
409 const char *
410 strtimevalue( u32 value )
411 {
412     static char buffer[30];
413     unsigned int years, days, hours, minutes;
414
415     value /= 60;
416     minutes = value % 60;
417     value /= 60;
418     hours = value % 24;
419     value /= 24;
420     days = value % 365;
421     value /= 365;
422     years = value;
423
424     sprintf(buffer,"%uy%ud%uh%um", years, days, hours, minutes );
425     if( years )
426         return buffer;
427     if( days )
428         return strchr( buffer, 'y' ) + 1;
429     return strchr( buffer, 'd' ) + 1;
430 }
431
432
433
434 /* Return a malloced string with the time elapsed between NOW and
435    SINCE.  May return NULL on error. */
436 char *
437 elapsed_time_string (time_t since, time_t now)
438 {
439   char *result;
440   double diff;
441   unsigned long value;
442   unsigned int days, hours, minutes, seconds;
443
444   if (!now)
445     now = gnupg_get_time ();
446
447   diff = difftime (now, since);
448   if (diff < 0)
449     return xtrystrdup ("time-warp");
450
451   seconds = (unsigned long)diff % 60;
452   value = (unsigned long)(diff / 60);
453   minutes = value % 60;
454   value /= 60;
455   hours = value % 24;
456   value /= 24;
457   days = value % 365;
458
459   if (days)
460     result = xtryasprintf ("%ud%uh%um%us", days, hours, minutes, seconds);
461   else if (hours)
462     result = xtryasprintf ("%uh%um%us", hours, minutes, seconds);
463   else if (minutes)
464     result = xtryasprintf ("%um%us", minutes, seconds);
465   else
466     result = xtryasprintf ("%us", seconds);
467
468   return result;
469 }
470
471
472 /*
473  * Note: this function returns GMT
474  */
475 const char *
476 strtimestamp (u32 stamp)
477 {
478   static char buffer[11+5];
479   struct tm *tp;
480   time_t atime = stamp;
481
482   if (IS_INVALID_TIME_T (atime))
483     {
484       strcpy (buffer, "????" "-??" "-??");
485     }
486   else
487     {
488       tp = gmtime( &atime );
489       snprintf (buffer, sizeof buffer, "%04d-%02d-%02d",
490                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
491     }
492   return buffer;
493 }
494
495
496 /*
497  * Note: this function returns GMT
498  */
499 const char *
500 isotimestamp (u32 stamp)
501 {
502   static char buffer[25+5];
503   struct tm *tp;
504   time_t atime = stamp;
505
506   if (IS_INVALID_TIME_T (atime))
507     {
508       strcpy (buffer, "????" "-??" "-??" " " "??" ":" "??" ":" "??");
509     }
510   else
511     {
512       tp = gmtime ( &atime );
513       snprintf (buffer, sizeof buffer, "%04d-%02d-%02d %02d:%02d:%02d",
514                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
515                 tp->tm_hour, tp->tm_min, tp->tm_sec);
516     }
517   return buffer;
518 }
519
520
521 /****************
522  * Note: this function returns local time
523  */
524 const char *
525 asctimestamp (u32 stamp)
526 {
527   static char buffer[50];
528 #if defined (HAVE_STRFTIME) && defined (HAVE_NL_LANGINFO)
529   static char fmt[50];
530 #endif
531   struct tm *tp;
532   time_t atime = stamp;
533
534   if (IS_INVALID_TIME_T (atime))
535     {
536       strcpy (buffer, "????" "-??" "-??");
537       return buffer;
538     }
539
540   tp = localtime( &atime );
541 #ifdef HAVE_STRFTIME
542 # if defined(HAVE_NL_LANGINFO)
543   mem2str( fmt, nl_langinfo(D_T_FMT), DIM(fmt)-3 );
544   if (!strstr( fmt, "%Z" ))
545     strcat( fmt, " %Z");
546   /* NOTE: gcc -Wformat-noliteral will complain here.  I have found no
547      way to suppress this warning.  */
548   strftime (buffer, DIM(buffer)-1, fmt, tp);
549 # elif defined(HAVE_W32CE_SYSTEM)
550   /* tzset is not available but %Z nevertheless prints a default
551      nonsense timezone ("WILDABBR").  Thus we don't print the time
552      zone at all.  */
553   strftime (buffer, DIM(buffer)-1, "%c", tp);
554 # else
555    /* FIXME: we should check whether the locale appends a " %Z" These
556     * locales from glibc don't put the " %Z": fi_FI hr_HR ja_JP lt_LT
557     * lv_LV POSIX ru_RU ru_SU sv_FI sv_SE zh_CN.  */
558   strftime (buffer, DIM(buffer)-1, "%c %Z", tp);
559 # endif
560   buffer[DIM(buffer)-1] = 0;
561 #else
562   mem2str( buffer, asctime(tp), DIM(buffer) );
563 #endif
564   return buffer;
565 }
566
567
568
569 static int
570 days_per_year (int y)
571 {
572   int s ;
573
574   s = !(y % 4);
575   if ( !(y % 100))
576     if ((y%400))
577       s = 0;
578   return s ? 366 : 365;
579 }
580
581 static int
582 days_per_month (int y, int m)
583 {
584   int s;
585
586   switch(m)
587     {
588     case 1: case 3: case 5: case 7: case 8: case 10: case 12:
589       return 31 ;
590     case 2:
591       s = !(y % 4);
592       if (!(y % 100))
593         if ((y % 400))
594           s = 0;
595       return s? 29 : 28 ;
596     case 4: case 6: case 9: case 11:
597       return 30;
598     }
599   BUG();
600 }
601
602
603 /* Convert YEAR, MONTH and DAY into the Julian date.  We assume that
604    it is already noon.  We do not support dates before 1582-10-15. */
605 static unsigned long
606 date2jd (int year, int month, int day)
607 {
608   unsigned long jd;
609
610   jd = 365L * year + 31 * (month-1) + day + JD_DIFF;
611   if (month < 3)
612     year-- ;
613   else
614     jd -= (4 * month + 23) / 10;
615
616   jd += year / 4 - ((year / 100 + 1) *3) / 4;
617
618   return jd ;
619 }
620
621 /* Convert a Julian date back to YEAR, MONTH and DAY.  Return day of
622    the year or 0 on error.  This function uses some more or less
623    arbitrary limits, most important is that days before 1582 are not
624    supported. */
625 static int
626 jd2date (unsigned long jd, int *year, int *month, int *day)
627 {
628   int y, m, d;
629   long delta;
630
631   if (!jd)
632     return 0 ;
633   if (jd < 1721425 || jd > 2843085)
634     return 0;
635
636   y = (jd - JD_DIFF) / 366;
637   d = m = 1;
638
639   while ((delta = jd - date2jd (y, m, d)) > days_per_year (y))
640     y++;
641
642   m = (delta / 31) + 1;
643   while( (delta = jd - date2jd (y, m, d)) > days_per_month (y,m))
644     if (++m > 12)
645       {
646         m = 1;
647         y++;
648       }
649
650   d = delta + 1 ;
651   if (d > days_per_month (y, m))
652     {
653       d = 1;
654       m++;
655     }
656   if (m > 12)
657     {
658       m = 1;
659       y++;
660     }
661
662   if (year)
663     *year = y;
664   if (month)
665     *month = m;
666   if (day)
667     *day = d ;
668
669   return (jd - date2jd (y, 1, 1)) + 1;
670 }
671
672
673 /* Check that the 15 bytes in ATIME represent a valid ISO time.  Note
674    that this function does not expect a string but a plain 15 byte
675    isotime buffer. */
676 gpg_error_t
677 check_isotime (const gnupg_isotime_t atime)
678 {
679   int i;
680   const char *s;
681
682   if (!*atime)
683     return gpg_error (GPG_ERR_NO_VALUE);
684
685   for (s=atime, i=0; i < 8; i++, s++)
686     if (!digitp (s))
687       return gpg_error (GPG_ERR_INV_TIME);
688   if (*s != 'T')
689       return gpg_error (GPG_ERR_INV_TIME);
690   for (s++, i=9; i < 15; i++, s++)
691     if (!digitp (s))
692       return gpg_error (GPG_ERR_INV_TIME);
693   return 0;
694 }
695
696
697 /* Dump the ISO time T to the log stream without a LF.  */
698 void
699 dump_isotime (const gnupg_isotime_t t)
700 {
701   if (!t || !*t)
702     log_printf ("%s", _("[none]"));
703   else
704     log_printf ("%.4s-%.2s-%.2s %.2s:%.2s:%s",
705                 t, t+4, t+6, t+9, t+11, t+13);
706 }
707
708
709 /* Copy one ISO date to another, this is inline so that we can do a
710    minimal sanity check.  A null date (empty string) is allowed.  */
711 void
712 gnupg_copy_time (gnupg_isotime_t d, const gnupg_isotime_t s)
713 {
714   if (*s)
715     {
716       if ((strlen (s) != 15 || s[8] != 'T'))
717         BUG();
718       memcpy (d, s, 15);
719       d[15] = 0;
720     }
721   else
722     *d = 0;
723 }
724
725
726 /* Add SECONDS to ATIME.  SECONDS may not be negative and is limited
727    to about the equivalent of 62 years which should be more then
728    enough for our purposes. */
729 gpg_error_t
730 add_seconds_to_isotime (gnupg_isotime_t atime, int nseconds)
731 {
732   gpg_error_t err;
733   int year, month, day, hour, minute, sec, ndays;
734   unsigned long jd;
735
736   err = check_isotime (atime);
737   if (err)
738     return err;
739
740   if (nseconds < 0 || nseconds >= (0x7fffffff - 61) )
741     return gpg_error (GPG_ERR_INV_VALUE);
742
743   year  = atoi_4 (atime+0);
744   month = atoi_2 (atime+4);
745   day   = atoi_2 (atime+6);
746   hour  = atoi_2 (atime+9);
747   minute= atoi_2 (atime+11);
748   sec   = atoi_2 (atime+13);
749
750   if (year <= 1582) /* The julian date functions don't support this. */
751     return gpg_error (GPG_ERR_INV_VALUE);
752
753   sec    += nseconds;
754   minute += sec/60;
755   sec    %= 60;
756   hour   += minute/60;
757   minute %= 60;
758   ndays  = hour/24;
759   hour   %= 24;
760
761   jd = date2jd (year, month, day) + ndays;
762   jd2date (jd, &year, &month, &day);
763
764   if (year > 9999 || month > 12 || day > 31
765       || year < 0 || month < 1 || day < 1)
766     return gpg_error (GPG_ERR_INV_VALUE);
767
768   snprintf (atime, 16, "%04d%02d%02dT%02d%02d%02d",
769             year, month, day, hour, minute, sec);
770   return 0;
771 }
772
773
774 gpg_error_t
775 add_days_to_isotime (gnupg_isotime_t atime, int ndays)
776 {
777   gpg_error_t err;
778   int year, month, day, hour, minute, sec;
779   unsigned long jd;
780
781   err = check_isotime (atime);
782   if (err)
783     return err;
784
785   if (ndays < 0 || ndays >= 9999*366 )
786     return gpg_error (GPG_ERR_INV_VALUE);
787
788   year  = atoi_4 (atime+0);
789   month = atoi_2 (atime+4);
790   day   = atoi_2 (atime+6);
791   hour  = atoi_2 (atime+9);
792   minute= atoi_2 (atime+11);
793   sec   = atoi_2 (atime+13);
794
795   if (year <= 1582) /* The julian date functions don't support this. */
796     return gpg_error (GPG_ERR_INV_VALUE);
797
798   jd = date2jd (year, month, day) + ndays;
799   jd2date (jd, &year, &month, &day);
800
801   if (year > 9999 || month > 12 || day > 31
802       || year < 0 || month < 1 || day < 1)
803     return gpg_error (GPG_ERR_INV_VALUE);
804
805   snprintf (atime, 16, "%04d%02d%02dT%02d%02d%02d",
806             year, month, day, hour, minute, sec);
807   return 0;
808 }