Detect unsigned time_t and adjust y2038 detection.
[gnupg.git] / util / miscutil.c
1 /* miscutil.c -  miscellaneous utilities
2  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
3  *               2004, 2005 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * GnuPG is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 #include <config.h>
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <string.h>
25 #include <time.h>
26 #include <ctype.h>
27 #ifdef HAVE_LANGINFO_H
28 #include <langinfo.h>
29 #endif
30 #include "types.h"
31 #include "util.h"
32 #include "i18n.h"
33
34 #ifdef HAVE_UNSIGNED_TIME_T
35 # define INVALID_TIME_CHECK(a) ((a) == (time_t)(-1))
36 #else 
37   /* Error or 32 bit time_t and value after 2038-01-19.  */
38 # define INVALID_TIME_CHECK(a) ((a) < 0)
39 #endif
40
41 /****************
42  * I know that the OpenPGP protocol has a Y2106 problem ;-)
43  */
44 u32
45 make_timestamp()
46 {
47     return time(NULL);
48 }
49
50 /****************
51  * Scan a date string and return a timestamp.
52  * The only supported format is "yyyy-mm-dd"
53  * Returns 0 for an invalid date.
54  */
55 u32
56 scan_isodatestr( const char *string )
57 {
58     int year, month, day;
59     struct tm tmbuf;
60     time_t stamp;
61     int i;
62
63     if( strlen(string) != 10 || string[4] != '-' || string[7] != '-' )
64         return 0;
65     for( i=0; i < 4; i++ )
66         if( !digitp(string+i) )
67             return 0;
68     if( !digitp(string+5) || !digitp(string+6) )
69         return 0;
70     if( !digitp(string+8) || !digitp(string+9) )
71         return 0;
72     year = atoi(string);
73     month = atoi(string+5);
74     day = atoi(string+8);
75     /* some basic checks */
76     if( year < 1970 || month < 1 || month > 12 || day < 1 || day > 31 )
77         return 0;
78     memset( &tmbuf, 0, sizeof tmbuf );
79     tmbuf.tm_mday = day;
80     tmbuf.tm_mon = month-1;
81     tmbuf.tm_year = year - 1900;
82     tmbuf.tm_isdst = -1;
83     stamp = mktime( &tmbuf );
84     if( stamp == (time_t)-1 )
85         return 0;
86     return stamp;
87 }
88
89
90 /****************
91  * Return a string with a time value in the form: x Y, n D, n H
92  */
93
94 const char *
95 strtimevalue( u32 value )
96 {
97     static char buffer[30];
98     unsigned int years, days, hours, minutes;
99
100     value /= 60;
101     minutes = value % 60;
102     value /= 60;
103     hours = value % 24;
104     value /= 24;
105     days = value % 365;
106     value /= 365;
107     years = value;
108
109     sprintf(buffer,"%uy%ud%uh%um", years, days, hours, minutes );
110     if( years )
111         return buffer;
112     if( days )
113         return strchr( buffer, 'y' ) + 1;
114     return strchr( buffer, 'd' ) + 1;
115 }
116
117
118 /****************
119  * Note: this function returns GMT
120  */
121 const char *
122 strtimestamp( u32 stamp )
123 {
124     static char buffer[11+5];
125     struct tm *tp;
126     time_t atime = stamp;
127
128     if (INVALID_TIME_CHECK (atime)) {
129         strcpy (buffer, "????" "-??" "-??");
130     }
131     else {
132         tp = gmtime( &atime );
133         sprintf(buffer,"%04d-%02d-%02d",
134                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
135     }
136     return buffer;
137 }
138
139
140 /****************
141  * Note: this function returns GMT
142  */
143 const char *
144 isotimestamp (u32 stamp)
145 {
146     static char buffer[25+5];
147     struct tm *tp;
148     time_t atime = stamp;
149     
150     if (INVALID_TIME_CHECK (atime)) {
151         strcpy (buffer, "????" "-??" "-??" " " "??" ":" "??" ":" "??");
152     }
153     else {
154         tp = gmtime( &atime );
155         sprintf(buffer,"%04d-%02d-%02d %02d:%02d:%02d",
156                 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday,
157                 tp->tm_hour, tp->tm_min, tp->tm_sec);
158     }
159     return buffer;
160 }
161
162
163 /* Scan am ISO timestamp and return an Epoch based timestamp.  The only
164    supported format is "yyyymmddThhmmss" delimited by white space, nul, a
165    colon or a comma.  Returns 0 for an invalid string. */
166 u32
167 isotime2seconds (const char *string)
168 {
169   const char *s;
170   int year, month, day, hour, minu, sec;
171   struct tm tmbuf;
172   int i;
173   time_t result;
174
175   if (!*string)
176     return 0;
177   for (s=string, i=0; i < 8; i++, s++)
178     if (!digitp (s))
179       return 0;
180   if (*s != 'T')
181       return 0;
182   for (s++, i=9; i < 15; i++, s++)
183     if (!digitp (s))
184       return 0;
185   if ( !(!*s || (isascii (*s) && isspace(*s)) || *s == ':' || *s == ','))
186     return 0;  /* Wrong delimiter.  */
187
188   year  = atoi_4 (string);
189   month = atoi_2 (string + 4);
190   day   = atoi_2 (string + 6);
191   hour  = atoi_2 (string + 9);
192   minu  = atoi_2 (string + 11);
193   sec   = atoi_2 (string + 13);
194
195   /* Basic checks.  */
196   if (year < 1970 || month < 1 || month > 12 || day < 1 || day > 31
197       || hour > 23 || minu > 59 || sec > 61 )
198     return 0;
199
200   memset (&tmbuf, 0, sizeof tmbuf);
201   tmbuf.tm_sec  = sec;
202   tmbuf.tm_min  = minu;
203   tmbuf.tm_hour = hour;
204   tmbuf.tm_mday = day;
205   tmbuf.tm_mon  = month-1;
206   tmbuf.tm_year = year - 1900;
207   tmbuf.tm_isdst = -1;
208   result = timegm (&tmbuf);
209   return (result == (time_t)(-1))? 0 : (u32)result;
210 }
211
212
213 /****************
214  * Note: this function returns local time
215  */
216 const char *
217 asctimestamp( u32 stamp )
218 {
219     static char buffer[50];
220 #if defined (HAVE_STRFTIME) && defined (HAVE_NL_LANGINFO)
221       static char fmt[50];
222 #endif
223     struct tm *tp;
224     time_t atime = stamp;
225
226     if (INVALID_TIME_CHECK (atime))
227       {
228         strcpy (buffer, "????" "-??" "-??");
229         return buffer;
230       }
231
232     tp = localtime( &atime );
233 #ifdef HAVE_STRFTIME
234 #if defined(HAVE_NL_LANGINFO)
235       mem2str( fmt, nl_langinfo(D_T_FMT), DIM(fmt)-3 );
236       if( strstr( fmt, "%Z" ) == NULL )
237         strcat( fmt, " %Z");
238       strftime( buffer, DIM(buffer)-1, fmt, tp );
239 #else
240       /* fixme: we should check whether the locale appends a " %Z"
241        * These locales from glibc don't put the " %Z":
242        * fi_FI hr_HR ja_JP lt_LT lv_LV POSIX ru_RU ru_SU sv_FI sv_SE zh_CN
243        */
244       strftime( buffer, DIM(buffer)-1, 
245 #ifdef HAVE_W32_SYSTEM                
246                 "%c"
247 #else
248                 "%c %Z"
249 #endif
250                 , tp );
251 #endif
252     buffer[DIM(buffer)-1] = 0;
253 #else
254     mem2str( buffer, asctime(tp), DIM(buffer) );
255 #endif
256     return buffer;
257 }
258
259
260 /****************
261  * Print a string to FP, but filter all control characters out.
262  */
263 void
264 print_string2( FILE *fp, const byte *p, size_t n, int delim, int delim2 )
265 {
266     for( ; n; n--, p++ )
267         if (*p < 0x20 
268             || *p == 0x7f
269             || *p == delim || *p == delim2
270             || ((delim || delim2) && *p=='\\'))
271           {
272             putc('\\', fp);
273             if( *p == '\n' )
274                 putc('n', fp);
275             else if( *p == '\r' )
276                 putc('r', fp);
277             else if( *p == '\f' )
278                 putc('f', fp);
279             else if( *p == '\v' )
280                 putc('v', fp);
281             else if( *p == '\b' )
282                 putc('b', fp);
283             else if( !*p )
284                 putc('0', fp);
285             else
286                 fprintf(fp, "x%02x", *p );
287           }
288         else
289           putc(*p, fp);
290 }
291
292 void
293 print_string( FILE *fp, const byte *p, size_t n, int delim )
294 {
295   print_string2(fp,p,n,delim,0);
296 }
297
298 /****************
299  * Print an UTF8 string to FP and filter all control characters out.
300  */
301 void
302 print_utf8_string2 ( FILE *fp, const byte *p, size_t n, int delim )
303 {
304     size_t i;
305     char *buf;
306
307     /* we can handle plain ascii simpler, so check for it first */
308     for(i=0; i < n; i++ ) {
309         if( p[i] & 0x80 )
310             break;
311     }
312     if( i < n ) {
313         buf = utf8_to_native ( p, n, delim );
314         /*(utf8 conversion already does the control character quoting)*/
315         fputs( buf, fp );
316         xfree( buf );
317     }
318     else
319         print_string( fp, p, n, delim );
320 }
321
322 void
323 print_utf8_string( FILE *fp, const byte *p, size_t n )
324 {
325     print_utf8_string2 (fp, p, n, 0);
326 }
327
328 /****************
329  * This function returns a string which is suitable for printing
330  * Caller must release it with xfree()
331  */
332 char *
333 make_printable_string( const byte *p, size_t n, int delim )
334 {
335     size_t save_n, buflen;
336     const byte *save_p;
337     char *buffer, *d;
338
339     /* first count length */
340     for(save_n = n, save_p = p, buflen=1 ; n; n--, p++ ) {
341         if( *p < 0x20 || (*p >= 0x7f && *p < 0xa0) || *p == delim ||
342             (delim && *p=='\\')) {
343             if( *p=='\n' || *p=='\r' || *p=='\f'
344                 || *p=='\v' || *p=='\b' || !*p )
345                 buflen += 2;
346             else
347                 buflen += 4;
348         }
349         else
350             buflen++;
351     }
352     p = save_p;
353     n = save_n;
354     /* and now make the string */
355     d = buffer = xmalloc( buflen );
356     for( ; n; n--, p++ ) {
357         if( *p < 0x20 || (*p >= 0x7f && *p < 0xa0) || *p == delim ||
358             (delim && *p=='\\')) {
359             *d++ = '\\';
360             if( *p == '\n' )
361                 *d++ = 'n';
362             else if( *p == '\r' )
363                 *d++ = 'r';
364             else if( *p == '\f' )
365                 *d++ = 'f';
366             else if( *p == '\v' )
367                 *d++ = 'v';
368             else if( *p == '\b' )
369                 *d++ = 'b';
370             else if( !*p )
371                 *d++ = '0';
372             else {
373                 sprintf(d, "x%02x", *p );
374                 d += 3;
375             }
376         }
377         else
378             *d++ = *p;
379     }
380     *d = 0;
381     return buffer;
382 }
383
384 int
385 answer_is_yes_no_default( const char *s, int def_answer )
386 {
387     /* TRANSLATORS: See doc/TRANSLATE about this string. */
388     const char *long_yes = _("yes");
389     const char *short_yes = _("yY");
390     /* TRANSLATORS: See doc/TRANSLATE about this string. */
391     const char *long_no = _("no");
392     const char *short_no = _("nN");
393
394     /* Note: we have to use the local dependent strcasecmp here */
395     if( match_multistr(long_yes,s) )
396         return 1;
397     if( *s && strchr( short_yes, *s ) && !s[1] )
398         return 1;
399     /* test for no strings to catch ambiguities for the next test */
400     if( match_multistr(long_no,s) )
401         return 0;
402     if( *s && strchr( short_no, *s ) && !s[1] )
403         return 0;
404     /* test for the english version (for those who are used to type yes) */
405     if( !ascii_strcasecmp(s, "yes" ) )
406         return 1;
407     if( *s && strchr( "yY", *s ) && !s[1] )
408         return 1;
409     return def_answer;
410 }
411
412 int
413 answer_is_yes( const char *s )
414 {
415   return answer_is_yes_no_default(s,0);
416 }
417
418 /****************
419  * Return 1 for yes, -1 for quit, or 0 for no
420  */
421 int
422 answer_is_yes_no_quit( const char *s )
423 {
424     /* TRANSLATORS: See doc/TRANSLATE about this string. */
425     const char *long_yes = _("yes");
426     /* TRANSLATORS: See doc/TRANSLATE about this string. */
427     const char *long_no = _("no");
428     /* TRANSLATORS: See doc/TRANSLATE about this string. */
429     const char *long_quit = _("quit");
430     const char *short_yes = _("yY");
431     const char *short_no = _("nN");
432     const char *short_quit = _("qQ");
433
434     if( match_multistr(long_no,s) )
435         return 0;
436     if( match_multistr(long_yes,s) )
437         return 1;
438     if( match_multistr(long_quit,s) )
439         return -1;
440     if( *s && strchr( short_no, *s ) && !s[1] )
441         return 0;
442     if( *s && strchr( short_yes, *s ) && !s[1] )
443         return 1;
444     if( *s && strchr( short_quit, *s ) && !s[1] )
445         return -1;
446     /* but not here */
447     if( !ascii_strcasecmp(s, "yes" ) )
448         return 1;
449     if( !ascii_strcasecmp(s, "quit" ) )
450         return -1;
451     if( *s && strchr( "yY", *s ) && !s[1] )
452         return 1;
453     if( *s && strchr( "qQ", *s ) && !s[1] )
454         return -1;
455     return 0;
456 }
457
458 /*
459    Return 1 for okay, 0 for for cancel or DEF_ANSWER for default. 
460  */
461 int
462 answer_is_okay_cancel (const char *s, int def_answer)
463 {
464   /* TRANSLATORS: See doc/TRANSLATE about this string. */
465   const char *long_okay = _("okay|okay");
466   /* TRANSLATORS: See doc/TRANSLATE about this string. */
467   const char *long_cancel = _("cancel|cancel");
468   const char *short_okay = _("oO");
469   const char *short_cancel = _("cC");
470   
471   /* Note: We have to use the locale dependent strcasecmp */
472   if ( match_multistr(long_okay,s) )
473     return 1;
474   if ( match_multistr(long_cancel,s) )
475     return 0;
476   if ( *s && strchr( short_okay, *s ) && !s[1] )
477     return 1;
478   if ( *s && strchr( short_cancel, *s ) && !s[1] )
479     return 0;
480   /* Always test for the English values (not locale here) */
481   if ( !ascii_strcasecmp(s, "okay" ) )
482     return 1;
483   if ( !ascii_strcasecmp(s, "ok" ) )
484     return 1;
485   if ( !ascii_strcasecmp(s, "cancel" ) )
486     return 0;
487   if ( *s && strchr( "oO", *s ) && !s[1] )
488     return 1;
489   if ( *s && strchr( "cC", *s ) && !s[1] )
490     return 0;
491   return def_answer;
492 }
493
494 /* Try match against each substring of multistr, delimited by | */
495 int
496 match_multistr(const char *multistr,const char *match)
497 {
498   do
499     {
500       size_t seglen=strcspn(multistr,"|");
501       if(!seglen)
502         break;
503       /* Using the localized strncasecmp */
504       if(strncasecmp(multistr,match,seglen)==0)
505         return 1;
506       multistr+=seglen;
507       if(*multistr=='|')
508         multistr++;
509     }
510   while(*multistr);
511
512   return 0;
513 }