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