common: Add new function isodate_human_to_tm
[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.  If DATE_ONLY is
220    true the time part is not expected and the scanning stops at the
221    first space or at a comma. */
222 int
223 isotime_human_p (const char *string, int date_only)
224 {
225   const char *s;
226   int i;
227
228   if (!*string)
229     return 0;
230   for (s=string, i=0; i < 4; i++, s++)
231     if (!digitp (s))
232       return 0;
233   if (*s != '-')
234     return 0;
235   s++;
236   if (!digitp (s) || !digitp (s+1) || s[2] != '-')
237     return 0;
238   i = atoi_2 (s);
239   if (i < 1 || i > 12)
240     return 0;
241   s += 3;
242   if (!digitp (s) || !digitp (s+1))
243     return 0;
244   i = atoi_2 (s);
245   if (i < 1 || i > 31)
246     return 0;
247   s += 2;
248   if (!*s || *s == ',')
249     return 1; /* Okay; only date given.  */
250   if (!spacep (s))
251     return 0;
252   if (date_only)
253     return 1; /* Okay; only date was requested.  */
254   s++;
255   if (spacep (s))
256     return 1; /* Okay, second space stops scanning.  */
257   if (!digitp (s) || !digitp (s+1))
258     return 0;
259   i = atoi_2 (s);
260   if (i < 0 || i > 23)
261     return 0;
262   s += 2;
263   if (!*s || *s == ',')
264     return 1; /* Okay; only date and hour given.  */
265   if (*s != ':')
266     return 0;
267   s++;
268   if (!digitp (s) || !digitp (s+1))
269     return 0;
270   i = atoi_2 (s);
271   if (i < 0 || i > 59)
272     return 0;
273   s += 2;
274   if (!*s || *s == ',')
275     return 1; /* Okay; only date, hour and minute given.  */
276   if (*s != ':')
277     return 0;
278   s++;
279   if (!digitp (s) || !digitp (s+1))
280     return 0;
281   i = atoi_2 (s);
282   if (i < 0 || i > 60)
283     return 0;
284   s += 2;
285   if (!*s || *s == ',' || spacep (s))
286     return 1; /* Okay; date, hour and minute and second given.  */
287
288   return 0; /* Unexpected delimiter.  */
289 }
290
291 /* Convert a standard isotime or a human readable variant into an
292    isotime structure.  The allowed formats are those described by
293    isotime_p and isotime_human_p.  The function returns 0 on failure
294    or the length of the scanned string on success.  */
295 size_t
296 string2isotime (gnupg_isotime_t atime, const char *string)
297 {
298   gnupg_isotime_t dummyatime;
299
300   if (!atime)
301     atime = dummyatime;
302
303   atime[0] = 0;
304   if (isotime_p (string))
305     {
306       memcpy (atime, string, 15);
307       atime[15] = 0;
308       return 15;
309     }
310   if (!isotime_human_p (string, 0))
311     return 0;
312   atime[0] = string[0];
313   atime[1] = string[1];
314   atime[2] = string[2];
315   atime[3] = string[3];
316   atime[4] = string[5];
317   atime[5] = string[6];
318   atime[6] = string[8];
319   atime[7] = string[9];
320   atime[8] = 'T';
321   memset (atime+9, '0', 6);
322   atime[15] = 0;
323   if (!spacep (string+10))
324     return 10;
325   if (spacep (string+11))
326     return 11; /* As per def, second space stops scanning.  */
327   atime[9] = string[11];
328   atime[10] = string[12];
329   if (string[13] != ':')
330     return 13;
331   atime[11] = string[14];
332   atime[12] = string[15];
333   if (string[16] != ':')
334     return 16;
335   atime[13] = string[17];
336   atime[14] = string[18];
337   return 19;
338 }
339
340
341 /* Scan an ISO timestamp and return an Epoch based timestamp.  The only
342    supported format is "yyyymmddThhmmss" delimited by white space, nul, a
343    colon or a comma.  Returns (time_t)(-1) for an invalid string.  */
344 time_t
345 isotime2epoch (const char *string)
346 {
347   int year, month, day, hour, minu, sec;
348   struct tm tmbuf;
349
350   if (!isotime_p (string))
351     return (time_t)(-1);
352
353   year  = atoi_4 (string);
354   month = atoi_2 (string + 4);
355   day   = atoi_2 (string + 6);
356   hour  = atoi_2 (string + 9);
357   minu  = atoi_2 (string + 11);
358   sec   = atoi_2 (string + 13);
359
360   /* Basic checks.  */
361   if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31
362       || hour > 23 || minu > 59 || sec > 61 )
363     return (time_t)(-1);
364
365   memset (&tmbuf, 0, sizeof tmbuf);
366   tmbuf.tm_sec  = sec;
367   tmbuf.tm_min  = minu;
368   tmbuf.tm_hour = hour;
369   tmbuf.tm_mday = day;
370   tmbuf.tm_mon  = month-1;
371   tmbuf.tm_year = year - 1900;
372   tmbuf.tm_isdst = -1;
373   return timegm (&tmbuf);
374 }
375
376
377 /* Convert an Epoch time to an iso time stamp. */
378 void
379 epoch2isotime (gnupg_isotime_t timebuf, time_t atime)
380 {
381   if (atime == (time_t)(-1))
382     *timebuf = 0;
383   else
384     {
385       struct tm *tp;
386 #ifdef HAVE_GMTIME_R
387       struct tm tmbuf;
388
389       tp = gmtime_r (&atime, &tmbuf);
390 #else
391       tp = gmtime (&atime);
392 #endif
393       snprintf (timebuf, 16, "%04d%02d%02dT%02d%02d%02d",
394                 1900 + tp->tm_year, tp->tm_mon+1, tp->tm_mday,
395                 tp->tm_hour, tp->tm_min, tp->tm_sec);
396     }
397 }
398
399
400 /* Parse a short ISO date string (YYYY-MM-DD) into a TM structure.
401    Returns 0 on success.  */
402 int
403 isodate_human_to_tm (const char *string, struct tm *t)
404 {
405   int year, month, day;
406
407   if (!isotime_human_p (string, 1))
408     return -1;
409
410   year  = atoi_4 (string);
411   month = atoi_2 (string + 5);
412   day   = atoi_2 (string + 8);
413
414   /* Basic checks.  */
415   if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31)
416     return -1;
417
418   memset (t, 0, sizeof *t);
419   t->tm_sec  = 0;
420   t->tm_min  = 0;
421   t->tm_hour = 0;
422   t->tm_mday = day;
423   t->tm_mon  = month-1;
424   t->tm_year = year - 1900;
425   t->tm_isdst = -1;
426   return 0;
427 }
428
429
430 /* This function is a copy of gpgme/src/conversion.c:_gpgme_timegm.
431    If you change it, then update the other one too.  */
432 #ifdef HAVE_W32_SYSTEM
433 static time_t
434 _win32_timegm (struct tm *tm)
435 {
436   /* This one is thread safe.  */
437   SYSTEMTIME st;
438   FILETIME ft;
439   unsigned long long cnsecs;
440
441   st.wYear   = tm->tm_year + 1900;
442   st.wMonth  = tm->tm_mon  + 1;
443   st.wDay    = tm->tm_mday;
444   st.wHour   = tm->tm_hour;
445   st.wMinute = tm->tm_min;
446   st.wSecond = tm->tm_sec;
447   st.wMilliseconds = 0; /* Not available.  */
448   st.wDayOfWeek = 0;    /* Ignored.  */
449
450   /* System time is UTC thus the conversion is pretty easy.  */
451   if (!SystemTimeToFileTime (&st, &ft))
452     {
453       gpg_err_set_errno (EINVAL);
454       return (time_t)(-1);
455     }
456
457   cnsecs = (((unsigned long long)ft.dwHighDateTime << 32)
458             | ft.dwLowDateTime);
459   cnsecs -= 116444736000000000ULL; /* The filetime epoch is 1601-01-01.  */
460   return (time_t)(cnsecs / 10000000ULL);
461 }
462 #endif
463
464
465 /* Parse the string TIMESTAMP into a time_t.  The string may either be
466    seconds since Epoch or in the ISO 8601 format like
467    "20390815T143012".  Returns 0 for an empty string or seconds since
468    Epoch. Leading spaces are skipped. If ENDP is not NULL, it will
469    point to the next non-parsed character in TIMESTRING.
470
471    This function is a copy of
472    gpgme/src/conversion.c:_gpgme_parse_timestamp.  If you change it,
473    then update the other one too.  */
474 time_t
475 parse_timestamp (const char *timestamp, char **endp)
476 {
477   /* Need to skip leading spaces, because that is what strtoul does
478      but not our ISO 8601 checking code. */
479   while (*timestamp && *timestamp== ' ')
480     timestamp++;
481   if (!*timestamp)
482     return 0;
483
484   if (strlen (timestamp) >= 15 && timestamp[8] == 'T')
485     {
486       struct tm buf;
487       int year;
488
489       year = atoi_4 (timestamp);
490       if (year < 1900)
491         return (time_t)(-1);
492
493       if (endp)
494         *endp = (char*)(timestamp + 15);
495
496       /* Fixme: We would better use a configure test to see whether
497          mktime can handle dates beyond 2038. */
498       if (sizeof (time_t) <= 4 && year >= 2038)
499         return (time_t)2145914603; /* 2037-12-31 23:23:23 */
500
501       memset (&buf, 0, sizeof buf);
502       buf.tm_year = year - 1900;
503       buf.tm_mon = atoi_2 (timestamp+4) - 1;
504       buf.tm_mday = atoi_2 (timestamp+6);
505       buf.tm_hour = atoi_2 (timestamp+9);
506       buf.tm_min = atoi_2 (timestamp+11);
507       buf.tm_sec = atoi_2 (timestamp+13);
508
509 #ifdef HAVE_W32_SYSTEM
510       return _win32_timegm (&buf);
511 #else
512 #ifdef HAVE_TIMEGM
513       return timegm (&buf);
514 #else
515       {
516         time_t tim;
517
518         putenv ("TZ=UTC");
519         tim = mktime (&buf);
520 #ifdef __GNUC__
521 #warning fixme: we must somehow reset TZ here.  It is not threadsafe anyway.
522 #endif
523         return tim;
524       }
525 #endif /* !HAVE_TIMEGM */
526 #endif /* !HAVE_W32_SYSTEM */
527     }
528   else
529     return (time_t)strtoul (timestamp, endp, 10);
530 }
531
532
533
534 u32
535 add_days_to_timestamp( u32 stamp, u16 days )
536 {
537     return stamp + days*86400L;
538 }
539
540
541 /****************
542  * Return a string with a time value in the form: x Y, n D, n H
543  */
544
545 const char *
546 strtimevalue( u32 value )
547 {
548     static char buffer[30];
549     unsigned int years, days, hours, minutes;
550
551     value /= 60;
552     minutes = value % 60;
553     value /= 60;
554     hours = value % 24;
555     value /= 24;
556     days = value % 365;
557     value /= 365;
558     years = value;
559
560     sprintf(buffer,"%uy%ud%uh%um", years, days, hours, minutes );
561     if( years )
562         return buffer;
563     if( days )
564         return strchr( buffer, 'y' ) + 1;
565     return strchr( buffer, 'd' ) + 1;
566 }
567
568
569
570 /* Return a malloced string with the time elapsed between NOW and
571    SINCE.  May return NULL on error. */
572 char *
573 elapsed_time_string (time_t since, time_t now)
574 {
575   char *result;
576   double diff;
577   unsigned long value;
578   unsigned int days, hours, minutes, seconds;
579
580   if (!now)
581     now = gnupg_get_time ();
582
583   diff = difftime (now, since);
584   if (diff < 0)
585     return xtrystrdup ("time-warp");
586
587   seconds = (unsigned long)diff % 60;
588   value = (unsigned long)(diff / 60);
589   minutes = value % 60;
590   value /= 60;
591   hours = value % 24;
592   value /= 24;
593   days = value % 365;
594
595   if (days)
596     result = xtryasprintf ("%ud%uh%um%us", days, hours, minutes, seconds);
597   else if (hours)
598     result = xtryasprintf ("%uh%um%us", hours, minutes, seconds);
599   else if (minutes)
600     result = xtryasprintf ("%um%us", minutes, seconds);
601   else
602     result = xtryasprintf ("%us", seconds);
603
604   return result;
605 }
606
607
608 /*
609  * Note: this function returns GMT
610  */
611 const char *
612 strtimestamp (u32 stamp)
613 {
614   static char buffer[11+5];
615   struct tm *tp;
616   time_t atime = stamp;
617
618   if (IS_INVALID_TIME_T (atime))
619     {
620       strcpy (buffer, "????" "-??" "-??");
621     }
622   else
623     {
624       tp = gmtime( &atime );
625       snprintf (buffer, sizeof buffer, "%04d-%02d-%02d",
626                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
627     }
628   return buffer;
629 }
630
631
632 /*
633  * Note: this function returns GMT
634  */
635 const char *
636 isotimestamp (u32 stamp)
637 {
638   static char buffer[25+5];
639   struct tm *tp;
640   time_t atime = stamp;
641
642   if (IS_INVALID_TIME_T (atime))
643     {
644       strcpy (buffer, "????" "-??" "-??" " " "??" ":" "??" ":" "??");
645     }
646   else
647     {
648       tp = gmtime ( &atime );
649       snprintf (buffer, sizeof buffer, "%04d-%02d-%02d %02d:%02d:%02d",
650                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
651                 tp->tm_hour, tp->tm_min, tp->tm_sec);
652     }
653   return buffer;
654 }
655
656
657 /****************
658  * Note: this function returns local time
659  */
660 const char *
661 asctimestamp (u32 stamp)
662 {
663   static char buffer[50];
664 #if defined (HAVE_STRFTIME) && defined (HAVE_NL_LANGINFO)
665   static char fmt[50];
666 #endif
667   struct tm *tp;
668   time_t atime = stamp;
669
670   if (IS_INVALID_TIME_T (atime))
671     {
672       strcpy (buffer, "????" "-??" "-??");
673       return buffer;
674     }
675
676   tp = localtime( &atime );
677 #ifdef HAVE_STRFTIME
678 # if defined(HAVE_NL_LANGINFO)
679   mem2str( fmt, nl_langinfo(D_T_FMT), DIM(fmt)-3 );
680   if (!strstr( fmt, "%Z" ))
681     strcat( fmt, " %Z");
682   /* NOTE: gcc -Wformat-noliteral will complain here.  I have found no
683      way to suppress this warning.  */
684   strftime (buffer, DIM(buffer)-1, fmt, tp);
685 # elif defined(HAVE_W32CE_SYSTEM)
686   /* tzset is not available but %Z nevertheless prints a default
687      nonsense timezone ("WILDABBR").  Thus we don't print the time
688      zone at all.  */
689   strftime (buffer, DIM(buffer)-1, "%c", tp);
690 # else
691    /* FIXME: we should check whether the locale appends a " %Z" These
692     * locales from glibc don't put the " %Z": fi_FI hr_HR ja_JP lt_LT
693     * lv_LV POSIX ru_RU ru_SU sv_FI sv_SE zh_CN.  */
694   strftime (buffer, DIM(buffer)-1, "%c %Z", tp);
695 # endif
696   buffer[DIM(buffer)-1] = 0;
697 #else
698   mem2str( buffer, asctime(tp), DIM(buffer) );
699 #endif
700   return buffer;
701 }
702
703
704
705 static int
706 days_per_year (int y)
707 {
708   int s ;
709
710   s = !(y % 4);
711   if ( !(y % 100))
712     if ((y%400))
713       s = 0;
714   return s ? 366 : 365;
715 }
716
717 static int
718 days_per_month (int y, int m)
719 {
720   int s;
721
722   switch(m)
723     {
724     case 1: case 3: case 5: case 7: case 8: case 10: case 12:
725       return 31 ;
726     case 2:
727       s = !(y % 4);
728       if (!(y % 100))
729         if ((y % 400))
730           s = 0;
731       return s? 29 : 28 ;
732     case 4: case 6: case 9: case 11:
733       return 30;
734     }
735   BUG();
736 }
737
738
739 /* Convert YEAR, MONTH and DAY into the Julian date.  We assume that
740    it is already noon.  We do not support dates before 1582-10-15. */
741 static unsigned long
742 date2jd (int year, int month, int day)
743 {
744   unsigned long jd;
745
746   jd = 365L * year + 31 * (month-1) + day + JD_DIFF;
747   if (month < 3)
748     year-- ;
749   else
750     jd -= (4 * month + 23) / 10;
751
752   jd += year / 4 - ((year / 100 + 1) *3) / 4;
753
754   return jd ;
755 }
756
757 /* Convert a Julian date back to YEAR, MONTH and DAY.  Return day of
758    the year or 0 on error.  This function uses some more or less
759    arbitrary limits, most important is that days before 1582 are not
760    supported. */
761 static int
762 jd2date (unsigned long jd, int *year, int *month, int *day)
763 {
764   int y, m, d;
765   long delta;
766
767   if (!jd)
768     return 0 ;
769   if (jd < 1721425 || jd > 2843085)
770     return 0;
771
772   y = (jd - JD_DIFF) / 366;
773   d = m = 1;
774
775   while ((delta = jd - date2jd (y, m, d)) > days_per_year (y))
776     y++;
777
778   m = (delta / 31) + 1;
779   while( (delta = jd - date2jd (y, m, d)) > days_per_month (y,m))
780     if (++m > 12)
781       {
782         m = 1;
783         y++;
784       }
785
786   d = delta + 1 ;
787   if (d > days_per_month (y, m))
788     {
789       d = 1;
790       m++;
791     }
792   if (m > 12)
793     {
794       m = 1;
795       y++;
796     }
797
798   if (year)
799     *year = y;
800   if (month)
801     *month = m;
802   if (day)
803     *day = d ;
804
805   return (jd - date2jd (y, 1, 1)) + 1;
806 }
807
808
809 /* Check that the 15 bytes in ATIME represent a valid ISO time.  Note
810    that this function does not expect a string but a plain 15 byte
811    isotime buffer. */
812 gpg_error_t
813 check_isotime (const gnupg_isotime_t atime)
814 {
815   int i;
816   const char *s;
817
818   if (!*atime)
819     return gpg_error (GPG_ERR_NO_VALUE);
820
821   for (s=atime, i=0; i < 8; i++, s++)
822     if (!digitp (s))
823       return gpg_error (GPG_ERR_INV_TIME);
824   if (*s != 'T')
825       return gpg_error (GPG_ERR_INV_TIME);
826   for (s++, i=9; i < 15; i++, s++)
827     if (!digitp (s))
828       return gpg_error (GPG_ERR_INV_TIME);
829   return 0;
830 }
831
832
833 /* Dump the ISO time T to the log stream without a LF.  */
834 void
835 dump_isotime (const gnupg_isotime_t t)
836 {
837   if (!t || !*t)
838     log_printf ("%s", _("[none]"));
839   else
840     log_printf ("%.4s-%.2s-%.2s %.2s:%.2s:%s",
841                 t, t+4, t+6, t+9, t+11, t+13);
842 }
843
844
845 /* Copy one ISO date to another, this is inline so that we can do a
846    minimal sanity check.  A null date (empty string) is allowed.  */
847 void
848 gnupg_copy_time (gnupg_isotime_t d, const gnupg_isotime_t s)
849 {
850   if (*s)
851     {
852       if ((strlen (s) != 15 || s[8] != 'T'))
853         BUG();
854       memcpy (d, s, 15);
855       d[15] = 0;
856     }
857   else
858     *d = 0;
859 }
860
861
862 /* Add SECONDS to ATIME.  SECONDS may not be negative and is limited
863    to about the equivalent of 62 years which should be more then
864    enough for our purposes. */
865 gpg_error_t
866 add_seconds_to_isotime (gnupg_isotime_t atime, int nseconds)
867 {
868   gpg_error_t err;
869   int year, month, day, hour, minute, sec, ndays;
870   unsigned long jd;
871
872   err = check_isotime (atime);
873   if (err)
874     return err;
875
876   if (nseconds < 0 || nseconds >= (0x7fffffff - 61) )
877     return gpg_error (GPG_ERR_INV_VALUE);
878
879   year  = atoi_4 (atime+0);
880   month = atoi_2 (atime+4);
881   day   = atoi_2 (atime+6);
882   hour  = atoi_2 (atime+9);
883   minute= atoi_2 (atime+11);
884   sec   = atoi_2 (atime+13);
885
886   if (year <= 1582) /* The julian date functions don't support this. */
887     return gpg_error (GPG_ERR_INV_VALUE);
888
889   sec    += nseconds;
890   minute += sec/60;
891   sec    %= 60;
892   hour   += minute/60;
893   minute %= 60;
894   ndays  = hour/24;
895   hour   %= 24;
896
897   jd = date2jd (year, month, day) + ndays;
898   jd2date (jd, &year, &month, &day);
899
900   if (year > 9999 || month > 12 || day > 31
901       || year < 0 || month < 1 || day < 1)
902     return gpg_error (GPG_ERR_INV_VALUE);
903
904   snprintf (atime, 16, "%04d%02d%02dT%02d%02d%02d",
905             year, month, day, hour, minute, sec);
906   return 0;
907 }
908
909
910 gpg_error_t
911 add_days_to_isotime (gnupg_isotime_t atime, int ndays)
912 {
913   gpg_error_t err;
914   int year, month, day, hour, minute, sec;
915   unsigned long jd;
916
917   err = check_isotime (atime);
918   if (err)
919     return err;
920
921   if (ndays < 0 || ndays >= 9999*366 )
922     return gpg_error (GPG_ERR_INV_VALUE);
923
924   year  = atoi_4 (atime+0);
925   month = atoi_2 (atime+4);
926   day   = atoi_2 (atime+6);
927   hour  = atoi_2 (atime+9);
928   minute= atoi_2 (atime+11);
929   sec   = atoi_2 (atime+13);
930
931   if (year <= 1582) /* The julian date functions don't support this. */
932     return gpg_error (GPG_ERR_INV_VALUE);
933
934   jd = date2jd (year, month, day) + ndays;
935   jd2date (jd, &year, &month, &day);
936
937   if (year > 9999 || month > 12 || day > 31
938       || year < 0 || month < 1 || day < 1)
939     return gpg_error (GPG_ERR_INV_VALUE);
940
941   snprintf (atime, 16, "%04d%02d%02dT%02d%02d%02d",
942             year, month, day, hour, minute, sec);
943   return 0;
944 }