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