Fixed card key generation of gpg2.
[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
30 static unsigned long timewarp;
31 static enum { NORMAL = 0, FROZEN, FUTURE, PAST } timemode;
32
33 /* Wrapper for the time(3).  We use this here so we can fake the time
34    for tests */
35 time_t 
36 gnupg_get_time () 
37 {
38   time_t current = time (NULL);
39   if (timemode == NORMAL)
40     return current;
41   else if (timemode == FROZEN)
42     return timewarp;
43   else if (timemode == FUTURE)
44     return current + timewarp;
45   else
46     return current - timewarp;
47 }
48
49
50 /* Return the current time (possibly faked) in ISO format. */
51 void
52 gnupg_get_isotime (gnupg_isotime_t timebuf)
53 {
54   time_t atime = gnupg_get_time ();
55     
56   if (atime < 0)
57     *timebuf = 0;
58   else 
59     {
60       struct tm *tp;
61 #ifdef HAVE_GMTIME_R
62       struct tm tmbuf;
63       
64       tp = gmtime_r (&atime, &tmbuf);
65 #else
66       tp = gmtime (&atime);
67 #endif
68       snprintf (timebuf, 16, "%04d%02d%02dT%02d%02d%02d",
69                 1900 + tp->tm_year, tp->tm_mon+1, tp->tm_mday,
70                 tp->tm_hour, tp->tm_min, tp->tm_sec);
71     }
72 }
73
74
75 /* set the time to NEWTIME so that gnupg_get_time returns a time
76    starting with this one.  With FREEZE set to 1 the returned time
77    will never change.  Just for completeness, a value of (time_t)-1
78    for NEWTIME gets you back to rality. Note that this is obviously
79    not thread-safe but this is not required. */
80 void
81 gnupg_set_time (time_t newtime, int freeze)
82 {
83   time_t current = time (NULL);
84
85   if ( newtime == (time_t)-1 || current == newtime)
86     {
87       timemode = NORMAL;
88       timewarp = 0;
89     }
90   else if (freeze)
91     {
92       timemode = FROZEN;
93       timewarp = current;
94     }
95   else if (newtime > current)
96     {
97       timemode = FUTURE;
98       timewarp = newtime - current;
99     }
100   else
101     {
102       timemode = PAST;
103       timewarp = current - newtime;
104     }
105 }
106
107 /* Returns true when we are in timewarp mode */
108 int
109 gnupg_faked_time_p (void)
110 {
111   return timemode;
112 }
113
114
115 /* This function is used by gpg because OpenPGP defines the timestamp
116    as an unsigned 32 bit value. */
117 u32 
118 make_timestamp (void)
119 {
120   time_t t = gnupg_get_time ();
121
122   if (t == (time_t)-1)
123     log_fatal ("gnupg_get_time() failed\n");
124   return (u32)t;
125 }
126
127
128
129 /****************
130  * Scan a date string and return a timestamp.
131  * The only supported format is "yyyy-mm-dd"
132  * Returns 0 for an invalid date.
133  */
134 u32
135 scan_isodatestr( const char *string )
136 {
137     int year, month, day;
138     struct tm tmbuf;
139     time_t stamp;
140     int i;
141
142     if( strlen(string) != 10 || string[4] != '-' || string[7] != '-' )
143         return 0;
144     for( i=0; i < 4; i++ )
145         if( !digitp (string+i) )
146             return 0;
147     if( !digitp (string+5) || !digitp(string+6) )
148         return 0;
149     if( !digitp(string+8) || !digitp(string+9) )
150         return 0;
151     year = atoi(string);
152     month = atoi(string+5);
153     day = atoi(string+8);
154     /* some basic checks */
155     if( year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 )
156         return 0;
157     memset( &tmbuf, 0, sizeof tmbuf );
158     tmbuf.tm_mday = day;
159     tmbuf.tm_mon = month-1;
160     tmbuf.tm_year = year - 1900;
161     tmbuf.tm_isdst = -1;
162     stamp = mktime( &tmbuf );
163     if( stamp == (time_t)-1 )
164         return 0;
165     return stamp;
166 }
167
168 /* Scan am ISO timestamp and return a epoch based timestamp.  The only
169    supported format is "yyyymmddThhmmss" delimited by white space, nul, a
170    colon or a comma.  Returns (time_t)(-1) for an invalid string.  */
171 time_t
172 isotime2epoch (const char *string)
173 {
174   const char *s;
175   int year, month, day, hour, minu, sec;
176   struct tm tmbuf;
177   int i;
178
179   if (!*string)
180     return (time_t)(-1);
181   for (s=string, i=0; i < 8; i++, s++)
182     if (!digitp (s))
183       return (time_t)(-1);
184   if (*s != 'T')
185       return (time_t)(-1);
186   for (s++, i=9; i < 15; i++, s++)
187     if (!digitp (s))
188       return (time_t)(-1);
189   if ( !(!*s || (isascii (*s) && isspace(*s)) || *s == ':' || *s == ','))
190     return (time_t)(-1);  /* Wrong delimiter.  */
191
192   year  = atoi_4 (string);
193   month = atoi_2 (string + 4);
194   day   = atoi_2 (string + 6);
195   hour  = atoi_2 (string + 9);
196   minu  = atoi_2 (string + 11);
197   sec   = atoi_2 (string + 13);
198
199   /* Basic checks.  */
200   if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31
201       || hour > 23 || minu > 59 || sec > 61 )
202     return (time_t)(-1);
203
204   memset (&tmbuf, 0, sizeof tmbuf);
205   tmbuf.tm_sec  = sec;
206   tmbuf.tm_min  = minu;
207   tmbuf.tm_hour = hour;
208   tmbuf.tm_mday = day;
209   tmbuf.tm_mon  = month-1;
210   tmbuf.tm_year = year - 1900;
211   tmbuf.tm_isdst = -1;
212   return timegm (&tmbuf);
213 }
214
215
216 /* Convert an Epoch time to an iso time stamp. */
217 void
218 epoch2isotime (gnupg_isotime_t timebuf, time_t atime)
219 {
220   if (atime < 0)
221     *timebuf = 0;
222   else 
223     {
224       struct tm *tp;
225 #ifdef HAVE_GMTIME_R
226       struct tm tmbuf;
227       
228       tp = gmtime_r (&atime, &tmbuf);
229 #else
230       tp = gmtime (&atime);
231 #endif
232       snprintf (timebuf, 16, "%04d%02d%02dT%02d%02d%02d",
233                 1900 + tp->tm_year, tp->tm_mon+1, tp->tm_mday,
234                 tp->tm_hour, tp->tm_min, tp->tm_sec);
235     }
236 }
237
238
239
240
241 u32
242 add_days_to_timestamp( u32 stamp, u16 days )
243 {
244     return stamp + days*86400L;
245 }
246
247
248 /****************
249  * Return a string with a time value in the form: x Y, n D, n H
250  */
251
252 const char *
253 strtimevalue( u32 value )
254 {
255     static char buffer[30];
256     unsigned int years, days, hours, minutes;
257
258     value /= 60;
259     minutes = value % 60;
260     value /= 60;
261     hours = value % 24;
262     value /= 24;
263     days = value % 365;
264     value /= 365;
265     years = value;
266
267     sprintf(buffer,"%uy%ud%uh%um", years, days, hours, minutes );
268     if( years )
269         return buffer;
270     if( days )
271         return strchr( buffer, 'y' ) + 1;
272     return strchr( buffer, 'd' ) + 1;
273 }
274
275
276 /*
277  * Note: this function returns GMT
278  */
279 const char *
280 strtimestamp( u32 stamp )
281 {
282     static char buffer[11+5];
283     struct tm *tp;
284     time_t atime = stamp;
285     
286     if (atime < 0) {
287         strcpy (buffer, "????" "-??" "-??");
288     }
289     else {
290         tp = gmtime( &atime );
291         sprintf(buffer,"%04d-%02d-%02d",
292                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
293     }
294     return buffer;
295 }
296
297
298 /*
299  * Note: this function returns GMT
300  */
301 const char *
302 isotimestamp (u32 stamp)
303 {
304   static char buffer[25+5];
305   struct tm *tp;
306   time_t atime = stamp;
307   
308   if (atime < 0)
309     {
310       strcpy (buffer, "????" "-??" "-??" " " "??" ":" "??" ":" "??");
311     }
312   else
313     {
314       tp = gmtime ( &atime );
315       sprintf (buffer,"%04d-%02d-%02d %02d:%02d:%02d",
316                1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
317                tp->tm_hour, tp->tm_min, tp->tm_sec);
318     }
319   return buffer;
320 }
321
322
323 /****************
324  * Note: this function returns local time
325  */
326 const char *
327 asctimestamp( u32 stamp )
328 {
329     static char buffer[50];
330 #if defined (HAVE_STRFTIME) && defined (HAVE_NL_LANGINFO)
331       static char fmt[50];
332 #endif
333     struct tm *tp;
334     time_t atime = stamp;
335
336     if (atime < 0) {
337         strcpy (buffer, "????" "-??" "-??");
338         return buffer;
339     }
340
341     tp = localtime( &atime );
342 #ifdef HAVE_STRFTIME
343 #if defined(HAVE_NL_LANGINFO)
344       mem2str( fmt, nl_langinfo(D_T_FMT), DIM(fmt)-3 );
345       if( strstr( fmt, "%Z" ) == NULL )
346         strcat( fmt, " %Z");
347       /* NOTE: gcc -Wformat-noliteral will complain here.  I have
348          found no way to suppress this warning .*/
349       strftime (buffer, DIM(buffer)-1, fmt, tp);
350 #else
351       /* FIXME: we should check whether the locale appends a " %Z"
352        * These locales from glibc don't put the " %Z":
353        * fi_FI hr_HR ja_JP lt_LT lv_LV POSIX ru_RU ru_SU sv_FI sv_SE zh_CN
354        */
355       strftime( buffer, DIM(buffer)-1, "%c %Z", tp );
356 #endif
357     buffer[DIM(buffer)-1] = 0;
358 #else
359     mem2str( buffer, asctime(tp), DIM(buffer) );
360 #endif
361     return buffer;
362 }
363
364
365
366
367
368
369
370
371
372
373
374
375
376