common: Support different digest algorithms for ssh fingerprints.
[gnupg.git] / common / miscellaneous.c
1 /* miscellaneous.c - Stuff not fitting elsewhere
2  *      Copyright (C) 2003, 2006 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 <limits.h>
33 #include <errno.h>
34
35 #include "util.h"
36 #include "iobuf.h"
37 #include "i18n.h"
38
39 /* Used by libgcrypt for logging.  */
40 static void
41 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
42 {
43   (void)dummy;
44
45   /* Map the log levels.  */
46   switch (level)
47     {
48     case GCRY_LOG_CONT: level = GPGRT_LOG_CONT; break;
49     case GCRY_LOG_INFO: level = GPGRT_LOG_INFO; break;
50     case GCRY_LOG_WARN: level = GPGRT_LOG_WARN; break;
51     case GCRY_LOG_ERROR:level = GPGRT_LOG_ERROR; break;
52     case GCRY_LOG_FATAL:level = GPGRT_LOG_FATAL; break;
53     case GCRY_LOG_BUG:  level = GPGRT_LOG_BUG; break;
54     case GCRY_LOG_DEBUG:level = GPGRT_LOG_DEBUG; break;
55     default:            level = GPGRT_LOG_ERROR; break;
56     }
57   log_logv (level, fmt, arg_ptr);
58 }
59
60
61 /* This function is called by libgcrypt on a fatal error.  */
62 static void
63 my_gcry_fatalerror_handler (void *opaque, int rc, const char *text)
64 {
65   (void)opaque;
66
67   log_fatal ("libgcrypt problem: %s\n", text ? text : gpg_strerror (rc));
68   abort ();
69 }
70
71
72 /* This function is called by libgcrypt if it ran out of core and
73    there is no way to return that error to the caller.  We do our own
74    function here to make use of our logging functions. */
75 static int
76 my_gcry_outofcore_handler (void *opaque, size_t req_n, unsigned int flags)
77 {
78   static int been_here;  /* Used to protect against recursive calls. */
79
80   (void)opaque;
81
82   if (!been_here)
83     {
84       been_here = 1;
85       if ( (flags & 1) )
86         log_fatal (_("out of core in secure memory "
87                      "while allocating %lu bytes"), (unsigned long)req_n);
88       else
89         log_fatal (_("out of core while allocating %lu bytes"),
90                    (unsigned long)req_n);
91     }
92   return 0; /* Let libgcrypt call its own fatal error handler.
93                Actually this will turn out to be
94                my_gcry_fatalerror_handler. */
95 }
96
97
98 /* Setup libgcrypt to use our own logging functions.  Should be used
99    early at startup. */
100 void
101 setup_libgcrypt_logging (void)
102 {
103   gcry_set_log_handler (my_gcry_logger, NULL);
104   gcry_set_fatalerror_handler (my_gcry_fatalerror_handler, NULL);
105   gcry_set_outofcore_handler (my_gcry_outofcore_handler, NULL);
106 }
107
108
109 /* Print an out of core message and let the process die.  The printed
110  * error is taken from ERRNO.  */
111 void
112 xoutofcore (void)
113 {
114   gpg_error_t err = gpg_error_from_syserror ();
115   log_fatal (_("error allocating enough memory: %s\n"), gpg_strerror (err));
116   abort (); /* Never called; just to make the compiler happy.  */
117 }
118
119
120 /* A wrapper around gcry_cipher_algo_name to return the string
121    "AES-128" instead of "AES".  Given that we have an alias in
122    libgcrypt for it, it does not harm to too much to return this other
123    string.  Some users complained that we print "AES" but "AES192"
124    and "AES256".  We can't fix that in libgcrypt but it is pretty
125    safe to do it in an application. */
126 const char *
127 gnupg_cipher_algo_name (int algo)
128 {
129   const char *s;
130
131   s = gcry_cipher_algo_name (algo);
132   if (!strcmp (s, "AES"))
133     s = "AES128";
134   return s;
135 }
136
137
138 void
139 obsolete_option (const char *configname, unsigned int configlineno,
140                  const char *name)
141 {
142   if (configname)
143     log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
144               configname, configlineno, name);
145   else
146     log_info (_("WARNING: \"%s%s\" is an obsolete option - it has no effect\n"),
147               "--", name);
148 }
149
150
151 /* Decide whether the filename is stdout or a real filename and return
152  * an appropriate string.  */
153 const char *
154 print_fname_stdout (const char *s)
155 {
156     if( !s || (*s == '-' && !s[1]) )
157         return "[stdout]";
158     return s;
159 }
160
161
162 /* Decide whether the filename is stdin or a real filename and return
163  * an appropriate string.  */
164 const char *
165 print_fname_stdin (const char *s)
166 {
167     if( !s || (*s == '-' && !s[1]) )
168         return "[stdin]";
169     return s;
170 }
171
172
173 static int
174 do_print_utf8_buffer (estream_t stream,
175                       const void *buffer, size_t length,
176                       const char *delimiters, size_t *bytes_written)
177 {
178   const char *p = buffer;
179   size_t i;
180
181   /* We can handle plain ascii simpler, so check for it first. */
182   for (i=0; i < length; i++ )
183     {
184       if ( (p[i] & 0x80) )
185         break;
186     }
187   if (i < length)
188     {
189       int delim = delimiters? *delimiters : 0;
190       char *buf;
191       int ret;
192
193       /*(utf8 conversion already does the control character quoting). */
194       buf = utf8_to_native (p, length, delim);
195       if (bytes_written)
196         *bytes_written = strlen (buf);
197       ret = es_fputs (buf, stream);
198       xfree (buf);
199       return ret == EOF? ret : (int)i;
200     }
201   else
202     return es_write_sanitized (stream, p, length, delimiters, bytes_written);
203 }
204
205
206 void
207 print_utf8_buffer3 (estream_t stream, const void *p, size_t n,
208                     const char *delim)
209 {
210   do_print_utf8_buffer (stream, p, n, delim, NULL);
211 }
212
213
214 void
215 print_utf8_buffer2 (estream_t stream, const void *p, size_t n, int delim)
216 {
217   char tmp[2];
218
219   tmp[0] = delim;
220   tmp[1] = 0;
221   do_print_utf8_buffer (stream, p, n, tmp, NULL);
222 }
223
224
225 void
226 print_utf8_buffer (estream_t stream, const void *p, size_t n)
227 {
228   do_print_utf8_buffer (stream, p, n, NULL, NULL);
229 }
230
231 /* Write LENGTH bytes of BUFFER to FP as a hex encoded string.
232    RESERVED must be 0. */
233 void
234 print_hexstring (FILE *fp, const void *buffer, size_t length, int reserved)
235 {
236 #define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A'))
237   const unsigned char *s;
238
239   (void)reserved;
240
241   for (s = buffer; length; s++, length--)
242     {
243       putc ( tohex ((*s>>4)&15), fp);
244       putc ( tohex (*s&15), fp);
245     }
246 #undef tohex
247 }
248
249
250 /* Create a string from the buffer P_ARG of length N which is suitable
251  * for printing.  Caller must release the created string using xfree.
252  * On error ERRNO is set and NULL returned.  Errors are only possible
253  * due to malloc failure.  */
254 char *
255 try_make_printable_string (const void *p_arg, size_t n, int delim)
256 {
257   const unsigned char *p = p_arg;
258   size_t save_n, buflen;
259   const unsigned char *save_p;
260   char *buffer, *d;
261
262   /* First count length. */
263   for (save_n = n, save_p = p, buflen=1 ; n; n--, p++ )
264     {
265       if ( *p < 0x20 || *p == 0x7f || *p == delim  || (delim && *p=='\\'))
266         {
267           if ( *p=='\n' || *p=='\r' || *p=='\f'
268                || *p=='\v' || *p=='\b' || !*p )
269             buflen += 2;
270           else
271             buflen += 5;
272         }
273       else
274         buflen++;
275     }
276   p = save_p;
277   n = save_n;
278   /* And now make the string */
279   d = buffer = xtrymalloc (buflen);
280   for ( ; n; n--, p++ )
281     {
282       if (*p < 0x20 || *p == 0x7f || *p == delim || (delim && *p=='\\')) {
283         *d++ = '\\';
284         if( *p == '\n' )
285           *d++ = 'n';
286         else if( *p == '\r' )
287           *d++ = 'r';
288         else if( *p == '\f' )
289           *d++ = 'f';
290         else if( *p == '\v' )
291           *d++ = 'v';
292         else if( *p == '\b' )
293           *d++ = 'b';
294         else if( !*p )
295           *d++ = '0';
296         else {
297           sprintf(d, "x%02x", *p );
298           d += 3;
299         }
300       }
301       else
302         *d++ = *p;
303     }
304   *d = 0;
305   return buffer;
306 }
307
308
309 /* Same as try_make_printable_string but terminates the process on
310  * memory shortage.  */
311 char *
312 make_printable_string (const void *p, size_t n, int delim )
313 {
314   char *string = try_make_printable_string (p, n, delim);
315   if (!string)
316     xoutofcore ();
317   return string;
318 }
319
320
321 /* Check whether (BUF,LEN) is valid header for an OpenPGP compressed
322  * packet.  LEN should be at least 6.  */
323 static int
324 is_openpgp_compressed_packet (unsigned char *buf, size_t len)
325 {
326   int c, ctb, pkttype;
327   int lenbytes;
328
329   ctb = *buf++; len--;
330   if (!(ctb & 0x80))
331     return 0; /* Invalid packet.  */
332
333   if ((ctb & 0x40)) /* New style (OpenPGP) CTB.  */
334     {
335       pkttype = (ctb & 0x3f);
336       if (!len)
337         return 0; /* Expected first length octet missing.  */
338       c = *buf++; len--;
339       if (c < 192)
340         ;
341       else if (c < 224)
342         {
343           if (!len)
344             return 0; /* Expected second length octet missing. */
345         }
346       else if (c == 255)
347         {
348           if (len < 4)
349             return 0; /* Expected length octets missing */
350         }
351     }
352   else /* Old style CTB.  */
353     {
354       pkttype = (ctb>>2)&0xf;
355       lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
356       if (len < lenbytes)
357         return 0; /* Not enough length bytes.  */
358     }
359
360   return (pkttype == 8);
361 }
362
363
364
365 /*
366  * Check if the file is compressed.
367  */
368 int
369 is_file_compressed (const char *s, int *ret_rc)
370 {
371     iobuf_t a;
372     byte buf[6];
373     int i;
374     int rc = 0;
375     int overflow;
376
377     struct magic_compress_s {
378         size_t len;
379         byte magic[4];
380     } magic[] = {
381         { 3, { 0x42, 0x5a, 0x68, 0x00 } }, /* bzip2 */
382         { 3, { 0x1f, 0x8b, 0x08, 0x00 } }, /* gzip */
383         { 4, { 0x50, 0x4b, 0x03, 0x04 } }, /* (pk)zip */
384     };
385
386     if ( iobuf_is_pipe_filename (s) || !ret_rc )
387         return 0; /* We can't check stdin or no file was given */
388
389     a = iobuf_open( s );
390     if ( a == NULL ) {
391         *ret_rc = gpg_error_from_syserror ();
392         return 0;
393     }
394
395     if ( iobuf_get_filelength( a, &overflow ) < 6 && !overflow) {
396         *ret_rc = 0;
397         goto leave;
398     }
399
400     if ( iobuf_read( a, buf, 6 ) == -1 ) {
401         *ret_rc = a->error;
402         goto leave;
403     }
404
405     for ( i = 0; i < DIM( magic ); i++ ) {
406         if ( !memcmp( buf, magic[i].magic, magic[i].len ) ) {
407             *ret_rc = 0;
408             rc = 1;
409             goto leave;
410         }
411     }
412
413     if (is_openpgp_compressed_packet (buf, 6))
414       {
415         *ret_rc = 0;
416         rc = 1;
417       }
418
419  leave:
420     iobuf_close( a );
421     return rc;
422 }
423
424
425 /* Try match against each substring of multistr, delimited by | */
426 int
427 match_multistr (const char *multistr,const char *match)
428 {
429   do
430     {
431       size_t seglen = strcspn (multistr,"|");
432       if (!seglen)
433         break;
434       /* Using the localized strncasecmp! */
435       if (strncasecmp(multistr,match,seglen)==0)
436         return 1;
437       multistr += seglen;
438       if (*multistr == '|')
439         multistr++;
440     }
441   while (*multistr);
442
443   return 0;
444 }
445
446
447 \f
448 /* Parse the first portion of the version number S and store it at
449    NUMBER.  On success, the function returns a pointer into S starting
450    with the first character, which is not part of the initial number
451    portion; on failure, NULL is returned.  */
452 static const char*
453 parse_version_number (const char *s, int *number)
454 {
455   int val = 0;
456
457   if (*s == '0' && digitp (s+1))
458     return NULL; /* Leading zeros are not allowed.  */
459   for (; digitp (s); s++ )
460     {
461       val *= 10;
462       val += *s - '0';
463     }
464   *number = val;
465   return val < 0? NULL : s;
466 }
467
468 /* Break up the complete string representation of the version number S,
469    which is expected to have this format:
470
471       <major number>.<minor number>.<micro number><patch level>.
472
473    The major, minor and micro number components will be stored at
474    MAJOR, MINOR and MICRO. On success, a pointer to the last
475    component, the patch level, will be returned; on failure, NULL will
476    be returned.  */
477 static const char *
478 parse_version_string (const char *s, int *major, int *minor, int *micro)
479 {
480   s = parse_version_number (s, major);
481   if (!s || *s != '.')
482     return NULL;
483   s++;
484   s = parse_version_number (s, minor);
485   if (!s || *s != '.')
486     return NULL;
487   s++;
488   s = parse_version_number (s, micro);
489   if (!s)
490     return NULL;
491   return s; /* Patchlevel.  */
492 }
493
494 /* Return true if version string is at least version B. */
495 int
496 gnupg_compare_version (const char *a, const char *b)
497 {
498   int a_major, a_minor, a_micro;
499   int b_major, b_minor, b_micro;
500   const char *a_plvl, *b_plvl;
501
502   if (!a || !b)
503     return 0;
504
505   /* Parse version A.  */
506   a_plvl = parse_version_string (a, &a_major, &a_minor, &a_micro);
507   if (!a_plvl )
508     return 0; /* Invalid version number.  */
509
510   /* Parse version B.  */
511   b_plvl = parse_version_string (b, &b_major, &b_minor, &b_micro);
512   if (!b_plvl )
513     return 0; /* Invalid version number.  */
514
515   /* Compare version numbers.  */
516   return (a_major > b_major
517           || (a_major == b_major && a_minor > b_minor)
518           || (a_major == b_major && a_minor == b_minor
519               && a_micro > b_micro)
520           || (a_major == b_major && a_minor == b_minor
521               && a_micro == b_micro
522               && strcmp (a_plvl, b_plvl) >= 0));
523 }
524
525
526 \f
527 /* Parse an --debug style argument.  We allow the use of number values
528  * in the usual C notation or a string with comma separated keywords.
529  *
530  * Returns: 0 on success or -1 and ERRNO set on error.  On success the
531  *          supplied variable is updated by the parsed flags.
532  *
533  * If STRING is NULL the enabled debug flags are printed.
534  *
535  * See doc/DETAILS for a summary of used debug options.
536  */
537 int
538 parse_debug_flag (const char *string, unsigned int *debugvar,
539                   const struct debug_flags_s *flags)
540
541 {
542   unsigned long result = 0;
543   int i, j;
544
545   if (!string)
546     {
547       if (debugvar)
548         {
549           log_info ("enabled debug flags:");
550           for (i=0; flags[i].name; i++)
551             if ((*debugvar & flags[i].flag))
552               log_printf (" %s", flags[i].name);
553           log_printf ("\n");
554         }
555       return 0;
556     }
557
558   while (spacep (string))
559     string++;
560   if (*string == '-')
561     {
562       errno = EINVAL;
563       return -1;
564     }
565
566   if (!strcmp (string, "?") || !strcmp (string, "help"))
567     {
568       log_info ("available debug flags:\n");
569       for (i=0; flags[i].name; i++)
570         log_info (" %5u %s\n", flags[i].flag, flags[i].name);
571       if (flags[i].flag != 77)
572         exit (0);
573     }
574   else if (digitp (string))
575     {
576       errno = 0;
577       result = strtoul (string, NULL, 0);
578       if (result == ULONG_MAX && errno == ERANGE)
579         return -1;
580     }
581   else
582     {
583       char **words;
584       words = strtokenize (string, ",");
585       if (!words)
586         return -1;
587       for (i=0; words[i]; i++)
588         {
589           if (*words[i])
590             {
591               for (j=0; flags[j].name; j++)
592                 if (!strcmp (words[i], flags[j].name))
593                   {
594                     result |= flags[j].flag;
595                     break;
596                   }
597               if (!flags[j].name)
598                 {
599                   if (!strcmp (words[i], "none"))
600                     {
601                       *debugvar = 0;
602                       result = 0;
603                     }
604                   else if (!strcmp (words[i], "all"))
605                     result = ~0;
606                   else
607                     log_info (_("unknown debug flag '%s' ignored\n"), words[i]);
608                 }
609             }
610         }
611       xfree (words);
612     }
613
614   *debugvar |= result;
615   return 0;
616 }