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