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