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 }