Merge branch 'master' into keyserver-via-dirmngr
[gnupg.git] / common / gettime.c
1 /* gettime.c - Wrapper for time functions
2  *      Copyright (C) 1998, 2002, 2007 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 /* Scan am ISO timestamp and return an Epoch based timestamp.  The only
183    supported format is "yyyymmddThhmmss" delimited by white space, nul, a
184    colon or a comma.  Returns (time_t)(-1) for an invalid string.  */
185 time_t
186 isotime2epoch (const char *string)
187 {
188   const char *s;
189   int year, month, day, hour, minu, sec;
190   struct tm tmbuf;
191   int i;
192
193   if (!*string)
194     return (time_t)(-1);
195   for (s=string, i=0; i < 8; i++, s++)
196     if (!digitp (s))
197       return (time_t)(-1);
198   if (*s != 'T')
199       return (time_t)(-1);
200   for (s++, i=9; i < 15; i++, s++)
201     if (!digitp (s))
202       return (time_t)(-1);
203   if ( !(!*s || (isascii (*s) && isspace(*s)) || *s == ':' || *s == ','))
204     return (time_t)(-1);  /* Wrong delimiter.  */
205
206   year  = atoi_4 (string);
207   month = atoi_2 (string + 4);
208   day   = atoi_2 (string + 6);
209   hour  = atoi_2 (string + 9);
210   minu  = atoi_2 (string + 11);
211   sec   = atoi_2 (string + 13);
212
213   /* Basic checks.  */
214   if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31
215       || hour > 23 || minu > 59 || sec > 61 )
216     return (time_t)(-1);
217
218   memset (&tmbuf, 0, sizeof tmbuf);
219   tmbuf.tm_sec  = sec;
220   tmbuf.tm_min  = minu;
221   tmbuf.tm_hour = hour;
222   tmbuf.tm_mday = day;
223   tmbuf.tm_mon  = month-1;
224   tmbuf.tm_year = year - 1900;
225   tmbuf.tm_isdst = -1;
226   return timegm (&tmbuf);
227 }
228
229
230 /* Convert an Epoch time to an iso time stamp. */
231 void
232 epoch2isotime (gnupg_isotime_t timebuf, time_t atime)
233 {
234   if (atime == (time_t)(-1))
235     *timebuf = 0;
236   else 
237     {
238       struct tm *tp;
239 #ifdef HAVE_GMTIME_R
240       struct tm tmbuf;
241       
242       tp = gmtime_r (&atime, &tmbuf);
243 #else
244       tp = gmtime (&atime);
245 #endif
246       snprintf (timebuf, 16, "%04d%02d%02dT%02d%02d%02d",
247                 1900 + tp->tm_year, tp->tm_mon+1, tp->tm_mday,
248                 tp->tm_hour, tp->tm_min, tp->tm_sec);
249     }
250 }
251
252
253
254
255 u32
256 add_days_to_timestamp( u32 stamp, u16 days )
257 {
258     return stamp + days*86400L;
259 }
260
261
262 /****************
263  * Return a string with a time value in the form: x Y, n D, n H
264  */
265
266 const char *
267 strtimevalue( u32 value )
268 {
269     static char buffer[30];
270     unsigned int years, days, hours, minutes;
271
272     value /= 60;
273     minutes = value % 60;
274     value /= 60;
275     hours = value % 24;
276     value /= 24;
277     days = value % 365;
278     value /= 365;
279     years = value;
280
281     sprintf(buffer,"%uy%ud%uh%um", years, days, hours, minutes );
282     if( years )
283         return buffer;
284     if( days )
285         return strchr( buffer, 'y' ) + 1;
286     return strchr( buffer, 'd' ) + 1;
287 }
288
289
290 /*
291  * Note: this function returns GMT
292  */
293 const char *
294 strtimestamp (u32 stamp)
295 {
296   static char buffer[11+5];
297   struct tm *tp;
298   time_t atime = stamp;
299     
300   if (IS_INVALID_TIME_T (atime))
301     {
302       strcpy (buffer, "????" "-??" "-??");
303     }
304   else
305     {
306       tp = gmtime( &atime );
307       snprintf (buffer, sizeof buffer, "%04d-%02d-%02d",
308                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
309     }
310   return buffer;
311 }
312
313
314 /*
315  * Note: this function returns GMT
316  */
317 const char *
318 isotimestamp (u32 stamp)
319 {
320   static char buffer[25+5];
321   struct tm *tp;
322   time_t atime = stamp;
323   
324   if (IS_INVALID_TIME_T (atime))
325     {
326       strcpy (buffer, "????" "-??" "-??" " " "??" ":" "??" ":" "??");
327     }
328   else
329     {
330       tp = gmtime ( &atime );
331       snprintf (buffer, sizeof buffer, "%04d-%02d-%02d %02d:%02d:%02d",
332                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
333                 tp->tm_hour, tp->tm_min, tp->tm_sec);
334     }
335   return buffer;
336 }
337
338
339 /****************
340  * Note: this function returns local time
341  */
342 const char *
343 asctimestamp (u32 stamp)
344 {
345   static char buffer[50];
346 #if defined (HAVE_STRFTIME) && defined (HAVE_NL_LANGINFO)
347   static char fmt[50];
348 #endif
349   struct tm *tp;
350   time_t atime = stamp;
351
352   if (IS_INVALID_TIME_T (atime))
353     {
354       strcpy (buffer, "????" "-??" "-??");
355       return buffer;
356     }
357
358   tp = localtime( &atime );
359 #ifdef HAVE_STRFTIME
360 # if defined(HAVE_NL_LANGINFO)
361   mem2str( fmt, nl_langinfo(D_T_FMT), DIM(fmt)-3 );
362   if (!strstr( fmt, "%Z" ))
363     strcat( fmt, " %Z");
364   /* NOTE: gcc -Wformat-noliteral will complain here.  I have found no
365      way to suppress this warning.  */
366   strftime (buffer, DIM(buffer)-1, fmt, tp);
367 # elif defined(HAVE_W32CE_SYSTEM) 
368   /* tzset is not available but %Z nevertheless prints a default
369      nonsense timezone ("WILDABBR").  Thus we don't print the time
370      zone at all.  */
371   strftime (buffer, DIM(buffer)-1, "%c", tp);
372 # else
373    /* FIXME: we should check whether the locale appends a " %Z" These
374     * locales from glibc don't put the " %Z": fi_FI hr_HR ja_JP lt_LT
375     * lv_LV POSIX ru_RU ru_SU sv_FI sv_SE zh_CN.  */
376   strftime (buffer, DIM(buffer)-1, "%c %Z", tp);
377 # endif
378   buffer[DIM(buffer)-1] = 0;
379 #else
380   mem2str( buffer, asctime(tp), DIM(buffer) );
381 #endif
382   return buffer;
383 }
384
385
386
387 static int
388 days_per_year (int y)
389 {
390   int s ;
391
392   s = !(y % 4);
393   if ( !(y % 100))
394     if ((y%400))
395       s = 0;
396   return s ? 366 : 365;
397 }
398
399 static int
400 days_per_month (int y, int m)
401 {
402   int s;
403     
404   switch(m)
405     {
406     case 1: case 3: case 5: case 7: case 8: case 10: case 12:
407       return 31 ;
408     case 2:
409       s = !(y % 4);
410       if (!(y % 100))
411         if ((y % 400))
412           s = 0;
413       return s? 29 : 28 ;
414     case 4: case 6: case 9: case 11:
415       return 30;
416     }
417   BUG();
418 }
419
420
421 /* Convert YEAR, MONTH and DAY into the Julian date.  We assume that
422    it is already noon.  We do not support dates before 1582-10-15. */
423 static unsigned long
424 date2jd (int year, int month, int day)
425 {
426   unsigned long jd;
427
428   jd = 365L * year + 31 * (month-1) + day + JD_DIFF;
429   if (month < 3)
430     year-- ;
431   else
432     jd -= (4 * month + 23) / 10;
433
434   jd += year / 4 - ((year / 100 + 1) *3) / 4;
435
436   return jd ;
437 }
438
439 /* Convert a Julian date back to YEAR, MONTH and DAY.  Return day of
440    the year or 0 on error.  This function uses some more or less
441    arbitrary limits, most important is that days before 1582 are not
442    supported. */
443 static int
444 jd2date (unsigned long jd, int *year, int *month, int *day)
445 {
446   int y, m, d;
447   long delta;
448
449   if (!jd)
450     return 0 ;
451   if (jd < 1721425 || jd > 2843085)
452     return 0;
453
454   y = (jd - JD_DIFF) / 366;
455   d = m = 1;
456
457   while ((delta = jd - date2jd (y, m, d)) > days_per_year (y))
458     y++;
459
460   m = (delta / 31) + 1;
461   while( (delta = jd - date2jd (y, m, d)) > days_per_month (y,m))
462     if (++m > 12)
463       { 
464         m = 1;
465         y++;
466       }
467
468   d = delta + 1 ;
469   if (d > days_per_month (y, m))
470     { 
471       d = 1;
472       m++;
473     }
474   if (m > 12)
475     { 
476       m = 1;
477       y++;
478     }
479
480   if (year)
481     *year = y;
482   if (month)
483     *month = m;
484   if (day)
485     *day = d ;
486
487   return (jd - date2jd (y, 1, 1)) + 1;
488 }
489
490
491 /* Check that the 15 bytes in ATIME represent a valid ISO time.  Note
492    that this function does not expect a string but a plain 15 byte
493    isotime buffer. */
494 gpg_error_t
495 check_isotime (const gnupg_isotime_t atime)
496 {
497   int i;
498   const char *s;
499
500   if (!*atime)
501     return gpg_error (GPG_ERR_NO_VALUE);
502   
503   for (s=atime, i=0; i < 8; i++, s++)
504     if (!digitp (s))
505       return gpg_error (GPG_ERR_INV_TIME);
506   if (*s != 'T')
507       return gpg_error (GPG_ERR_INV_TIME);
508   for (s++, i=9; i < 15; i++, s++)
509     if (!digitp (s))
510       return gpg_error (GPG_ERR_INV_TIME);
511   return 0;
512 }
513
514
515 /* Dump the ISO time T to the log stream without a LF.  */
516 void
517 dump_isotime (const gnupg_isotime_t t)
518 {
519   if (!t || !*t)
520     log_printf ("%s", _("[none]"));
521   else
522     log_printf ("%.4s-%.2s-%.2s %.2s:%.2s:%s",
523                 t, t+4, t+6, t+9, t+11, t+13);
524 }
525
526
527 /* Copy one ISO date to another, this is inline so that we can do a
528    minimal sanity check.  A null date (empty string) is allowed.  */
529 void
530 gnupg_copy_time (gnupg_isotime_t d, const gnupg_isotime_t s)
531 {
532   if (*s)
533     {
534       if ((strlen (s) != 15 || s[8] != 'T'))
535         BUG();
536       memcpy (d, s, 15);
537       d[15] = 0;
538     }
539   else
540     *d = 0;
541 }
542
543
544 /* Add SECONDS to ATIME.  SECONDS may not be negative and is limited
545    to about the equivalent of 62 years which should be more then
546    enough for our purposes. */
547 gpg_error_t
548 add_seconds_to_isotime (gnupg_isotime_t atime, int nseconds)
549 {
550   gpg_error_t err;
551   int year, month, day, hour, minute, sec, ndays;
552   unsigned long jd;
553
554   err = check_isotime (atime);
555   if (err)
556     return err;
557
558   if (nseconds < 0 || nseconds >= (0x7fffffff - 61) )
559     return gpg_error (GPG_ERR_INV_VALUE);
560
561   year  = atoi_4 (atime+0);
562   month = atoi_2 (atime+4);
563   day   = atoi_2 (atime+6);
564   hour  = atoi_2 (atime+9);
565   minute= atoi_2 (atime+11);
566   sec   = atoi_2 (atime+13);
567
568   if (year <= 1582) /* The julian date functions don't support this. */
569     return gpg_error (GPG_ERR_INV_VALUE); 
570
571   sec    += nseconds;
572   minute += sec/60;
573   sec    %= 60;
574   hour   += minute/60;
575   minute %= 60;
576   ndays  = hour/24;
577   hour   %= 24;
578   
579   jd = date2jd (year, month, day) + ndays;
580   jd2date (jd, &year, &month, &day);
581
582   if (year > 9999 || month > 12 || day > 31
583       || year < 0 || month < 1 || day < 1)
584     return gpg_error (GPG_ERR_INV_VALUE); 
585     
586   snprintf (atime, 16, "%04d%02d%02dT%02d%02d%02d",
587             year, month, day, hour, minute, sec);
588   return 0;
589 }
590
591
592 gpg_error_t
593 add_days_to_isotime (gnupg_isotime_t atime, int ndays)
594 {
595   gpg_error_t err;
596   int year, month, day, hour, minute, sec;
597   unsigned long jd;
598
599   err = check_isotime (atime);
600   if (err)
601     return err;
602
603   if (ndays < 0 || ndays >= 9999*366 )
604     return gpg_error (GPG_ERR_INV_VALUE);
605
606   year  = atoi_4 (atime+0);
607   month = atoi_2 (atime+4);
608   day   = atoi_2 (atime+6);
609   hour  = atoi_2 (atime+9);
610   minute= atoi_2 (atime+11);
611   sec   = atoi_2 (atime+13);
612
613   if (year <= 1582) /* The julian date functions don't support this. */
614     return gpg_error (GPG_ERR_INV_VALUE); 
615
616   jd = date2jd (year, month, day) + ndays;
617   jd2date (jd, &year, &month, &day);
618
619   if (year > 9999 || month > 12 || day > 31
620       || year < 0 || month < 1 || day < 1)
621     return gpg_error (GPG_ERR_INV_VALUE); 
622     
623   snprintf (atime, 16, "%04d%02d%02dT%02d%02d%02d",
624             year, month, day, hour, minute, sec);
625   return 0;
626 }