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