Merge branch 'STABLE-BRANCH-2-2' into master
[gnupg.git] / common / miscellaneous.c
index 1bab151..0b374e6 100644 (file)
@@ -3,25 +3,35 @@
  *
  * This file is part of GnuPG.
  *
  *
  * This file is part of GnuPG.
  *
- * GnuPG is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3 of the License, or
- * (at your option) any later version.
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either
  *
  *
- * GnuPG is distributed in the hope that it will be useful,
+ *   - the GNU Lesser General Public License as published by the Free
+ *     Software Foundation; either version 3 of the License, or (at
+ *     your option) any later version.
+ *
+ * or
+ *
+ *   - the GNU General Public License as published by the Free
+ *     Software Foundation; either version 2 of the License, or (at
+ *     your option) any later version.
+ *
+ * or both in parallel, as here.
+ *
+ * This file is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include <config.h>
 #include <stdlib.h>
  */
 
 #include <config.h>
 #include <stdlib.h>
+#include <limits.h>
 #include <errno.h>
 
 #include <errno.h>
 
-#define JNLIB_NEED_LOG_LOGV
 #include "util.h"
 #include "iobuf.h"
 #include "i18n.h"
 #include "util.h"
 #include "iobuf.h"
 #include "i18n.h"
@@ -35,14 +45,14 @@ my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
   /* Map the log levels.  */
   switch (level)
     {
   /* Map the log levels.  */
   switch (level)
     {
-    case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
-    case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
-    case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
-    case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
-    case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
-    case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
-    case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
-    default:            level = JNLIB_LOG_ERROR; break;
+    case GCRY_LOG_CONT: level = GPGRT_LOGLVL_CONT; break;
+    case GCRY_LOG_INFO: level = GPGRT_LOGLVL_INFO; break;
+    case GCRY_LOG_WARN: level = GPGRT_LOGLVL_WARN; break;
+    case GCRY_LOG_ERROR:level = GPGRT_LOGLVL_ERROR; break;
+    case GCRY_LOG_FATAL:level = GPGRT_LOGLVL_FATAL; break;
+    case GCRY_LOG_BUG:  level = GPGRT_LOGLVL_BUG; break;
+    case GCRY_LOG_DEBUG:level = GPGRT_LOGLVL_DEBUG; break;
+    default:            level = GPGRT_LOGLVL_ERROR; break;
     }
   log_logv (level, fmt, arg_ptr);
 }
     }
   log_logv (level, fmt, arg_ptr);
 }
@@ -95,6 +105,18 @@ setup_libgcrypt_logging (void)
   gcry_set_outofcore_handler (my_gcry_outofcore_handler, NULL);
 }
 
   gcry_set_outofcore_handler (my_gcry_outofcore_handler, NULL);
 }
 
+
+/* Print an out of core message and let the process die.  The printed
+ * error is taken from ERRNO.  */
+void
+xoutofcore (void)
+{
+  gpg_error_t err = gpg_error_from_syserror ();
+  log_fatal (_("error allocating enough memory: %s\n"), gpg_strerror (err));
+  abort (); /* Never called; just to make the compiler happy.  */
+}
+
+
 /* A wrapper around gcry_cipher_algo_name to return the string
    "AES-128" instead of "AES".  Given that we have an alias in
    libgcrypt for it, it does not harm to too much to return this other
 /* A wrapper around gcry_cipher_algo_name to return the string
    "AES-128" instead of "AES".  Given that we have an alias in
    libgcrypt for it, it does not harm to too much to return this other
@@ -113,6 +135,19 @@ gnupg_cipher_algo_name (int algo)
 }
 
 
 }
 
 
+void
+obsolete_option (const char *configname, unsigned int configlineno,
+                 const char *name)
+{
+  if (configname)
+    log_info (_("%s:%u: obsolete option \"%s\" - it has no effect\n"),
+              configname, configlineno, name);
+  else
+    log_info (_("WARNING: \"%s%s\" is an obsolete option - it has no effect\n"),
+              "--", name);
+}
+
+
 /* Decide whether the filename is stdout or a real filename and return
  * an appropriate string.  */
 const char *
 /* Decide whether the filename is stdout or a real filename and return
  * an appropriate string.  */
 const char *
@@ -135,6 +170,47 @@ print_fname_stdin (const char *s)
 }
 
 
 }
 
 
+static int
+do_print_utf8_buffer (estream_t stream,
+                      const void *buffer, size_t length,
+                      const char *delimiters, size_t *bytes_written)
+{
+  const char *p = buffer;
+  size_t i;
+
+  /* We can handle plain ascii simpler, so check for it first. */
+  for (i=0; i < length; i++ )
+    {
+      if ( (p[i] & 0x80) )
+        break;
+    }
+  if (i < length)
+    {
+      int delim = delimiters? *delimiters : 0;
+      char *buf;
+      int ret;
+
+      /*(utf8 conversion already does the control character quoting). */
+      buf = utf8_to_native (p, length, delim);
+      if (bytes_written)
+        *bytes_written = strlen (buf);
+      ret = es_fputs (buf, stream);
+      xfree (buf);
+      return ret == EOF? ret : (int)i;
+    }
+  else
+    return es_write_sanitized (stream, p, length, delimiters, bytes_written);
+}
+
+
+void
+print_utf8_buffer3 (estream_t stream, const void *p, size_t n,
+                    const char *delim)
+{
+  do_print_utf8_buffer (stream, p, n, delim, NULL);
+}
+
+
 void
 print_utf8_buffer2 (estream_t stream, const void *p, size_t n, int delim)
 {
 void
 print_utf8_buffer2 (estream_t stream, const void *p, size_t n, int delim)
 {
@@ -142,16 +218,26 @@ print_utf8_buffer2 (estream_t stream, const void *p, size_t n, int delim)
 
   tmp[0] = delim;
   tmp[1] = 0;
 
   tmp[0] = delim;
   tmp[1] = 0;
-  es_write_sanitized_utf8_buffer (stream, p, n, tmp, NULL);
+  do_print_utf8_buffer (stream, p, n, tmp, NULL);
 }
 
 
 void
 print_utf8_buffer (estream_t stream, const void *p, size_t n)
 {
 }
 
 
 void
 print_utf8_buffer (estream_t stream, const void *p, size_t n)
 {
-  es_write_sanitized_utf8_buffer (stream, p, n, NULL, NULL);
+  do_print_utf8_buffer (stream, p, n, NULL, NULL);
 }
 
 }
 
+
+void
+print_utf8_string (estream_t stream, const char *p)
+{
+  if (!p)
+    p = "";
+  do_print_utf8_buffer (stream, p, strlen (p), NULL, NULL);
+}
+
+
 /* Write LENGTH bytes of BUFFER to FP as a hex encoded string.
    RESERVED must be 0. */
 void
 /* Write LENGTH bytes of BUFFER to FP as a hex encoded string.
    RESERVED must be 0. */
 void
@@ -170,10 +256,118 @@ print_hexstring (FILE *fp, const void *buffer, size_t length, int reserved)
 #undef tohex
 }
 
 #undef tohex
 }
 
+
+/* Create a string from the buffer P_ARG of length N which is suitable
+ * for printing.  Caller must release the created string using xfree.
+ * On error ERRNO is set and NULL returned.  Errors are only possible
+ * due to malloc failure.  */
+char *
+try_make_printable_string (const void *p_arg, size_t n, int delim)
+{
+  const unsigned char *p = p_arg;
+  size_t save_n, buflen;
+  const unsigned char *save_p;
+  char *buffer, *d;
+
+  /* First count length. */
+  for (save_n = n, save_p = p, buflen=1 ; n; n--, p++ )
+    {
+      if ( *p < 0x20 || *p == 0x7f || *p == delim  || (delim && *p=='\\'))
+        {
+          if ( *p=='\n' || *p=='\r' || *p=='\f'
+               || *p=='\v' || *p=='\b' || !*p )
+            buflen += 2;
+          else
+            buflen += 5;
+       }
+      else
+        buflen++;
+    }
+  p = save_p;
+  n = save_n;
+  /* And now make the string */
+  d = buffer = xtrymalloc (buflen);
+  for ( ; n; n--, p++ )
+    {
+      if (*p < 0x20 || *p == 0x7f || *p == delim || (delim && *p=='\\')) {
+        *d++ = '\\';
+        if( *p == '\n' )
+          *d++ = 'n';
+        else if( *p == '\r' )
+          *d++ = 'r';
+        else if( *p == '\f' )
+          *d++ = 'f';
+        else if( *p == '\v' )
+          *d++ = 'v';
+        else if( *p == '\b' )
+          *d++ = 'b';
+        else if( !*p )
+          *d++ = '0';
+        else {
+          sprintf(d, "x%02x", *p );
+          d += 3;
+        }
+      }
+      else
+        *d++ = *p;
+    }
+  *d = 0;
+  return buffer;
+}
+
+
+/* Same as try_make_printable_string but terminates the process on
+ * memory shortage.  */
 char *
 make_printable_string (const void *p, size_t n, int delim )
 {
 char *
 make_printable_string (const void *p, size_t n, int delim )
 {
-  return sanitize_buffer (p, n, delim);
+  char *string = try_make_printable_string (p, n, delim);
+  if (!string)
+    xoutofcore ();
+  return string;
+}
+
+
+/* Check whether (BUF,LEN) is valid header for an OpenPGP compressed
+ * packet.  LEN should be at least 6.  */
+static int
+is_openpgp_compressed_packet (unsigned char *buf, size_t len)
+{
+  int c, ctb, pkttype;
+  int lenbytes;
+
+  ctb = *buf++; len--;
+  if (!(ctb & 0x80))
+    return 0; /* Invalid packet.  */
+
+  if ((ctb & 0x40)) /* New style (OpenPGP) CTB.  */
+    {
+      pkttype = (ctb & 0x3f);
+      if (!len)
+        return 0; /* Expected first length octet missing.  */
+      c = *buf++; len--;
+      if (c < 192)
+        ;
+      else if (c < 224)
+        {
+          if (!len)
+            return 0; /* Expected second length octet missing. */
+        }
+      else if (c == 255)
+        {
+          if (len < 4)
+            return 0; /* Expected length octets missing */
+        }
+    }
+  else /* Old style CTB.  */
+    {
+      pkttype = (ctb>>2)&0xf;
+      lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
+      if (len < lenbytes)
+        return 0; /* Not enough length bytes.  */
+    }
+
+  return (pkttype == 8);
 }
 
 
 }
 
 
@@ -185,8 +379,9 @@ int
 is_file_compressed (const char *s, int *ret_rc)
 {
     iobuf_t a;
 is_file_compressed (const char *s, int *ret_rc)
 {
     iobuf_t a;
-    byte buf[4];
-    int i, rc = 0;
+    byte buf[6];
+    int i;
+    int rc = 0;
     int overflow;
 
     struct magic_compress_s {
     int overflow;
 
     struct magic_compress_s {
@@ -206,13 +401,14 @@ is_file_compressed (const char *s, int *ret_rc)
         *ret_rc = gpg_error_from_syserror ();
         return 0;
     }
         *ret_rc = gpg_error_from_syserror ();
         return 0;
     }
+    iobuf_ioctl (a, IOBUF_IOCTL_NO_CACHE, 1, NULL);
 
 
-    if ( iobuf_get_filelength( a, &overflow ) < 4 && !overflow) {
+    if ( iobuf_get_filelength( a, &overflow ) < 6 && !overflow) {
         *ret_rc = 0;
         goto leave;
     }
 
         *ret_rc = 0;
         goto leave;
     }
 
-    if ( iobuf_read( a, buf, 4 ) == -1 ) {
+    if ( iobuf_read( a, buf, 6 ) == -1 ) {
         *ret_rc = a->error;
         goto leave;
     }
         *ret_rc = a->error;
         goto leave;
     }
@@ -221,11 +417,17 @@ is_file_compressed (const char *s, int *ret_rc)
         if ( !memcmp( buf, magic[i].magic, magic[i].len ) ) {
             *ret_rc = 0;
             rc = 1;
         if ( !memcmp( buf, magic[i].magic, magic[i].len ) ) {
             *ret_rc = 0;
             rc = 1;
-            break;
+            goto leave;
         }
     }
 
         }
     }
 
-leave:
+    if (is_openpgp_compressed_packet (buf, 6))
+      {
+        *ret_rc = 0;
+        rc = 1;
+      }
+
+ leave:
     iobuf_close( a );
     return rc;
 }
     iobuf_close( a );
     return rc;
 }
@@ -330,3 +532,96 @@ gnupg_compare_version (const char *a, const char *b)
               && a_micro == b_micro
               && strcmp (a_plvl, b_plvl) >= 0));
 }
               && a_micro == b_micro
               && strcmp (a_plvl, b_plvl) >= 0));
 }
+
+
+\f
+/* Parse an --debug style argument.  We allow the use of number values
+ * in the usual C notation or a string with comma separated keywords.
+ *
+ * Returns: 0 on success or -1 and ERRNO set on error.  On success the
+ *          supplied variable is updated by the parsed flags.
+ *
+ * If STRING is NULL the enabled debug flags are printed.
+ *
+ * See doc/DETAILS for a summary of used debug options.
+ */
+int
+parse_debug_flag (const char *string, unsigned int *debugvar,
+                  const struct debug_flags_s *flags)
+
+{
+  unsigned long result = 0;
+  int i, j;
+
+  if (!string)
+    {
+      if (debugvar)
+        {
+          log_info ("enabled debug flags:");
+          for (i=0; flags[i].name; i++)
+            if ((*debugvar & flags[i].flag))
+              log_printf (" %s", flags[i].name);
+          log_printf ("\n");
+        }
+      return 0;
+    }
+
+  while (spacep (string))
+    string++;
+  if (*string == '-')
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  if (!strcmp (string, "?") || !strcmp (string, "help"))
+    {
+      log_info ("available debug flags:\n");
+      for (i=0; flags[i].name; i++)
+        log_info (" %5u %s\n", flags[i].flag, flags[i].name);
+      if (flags[i].flag != 77)
+        exit (0);
+    }
+  else if (digitp (string))
+    {
+      errno = 0;
+      result = strtoul (string, NULL, 0);
+      if (result == ULONG_MAX && errno == ERANGE)
+        return -1;
+    }
+  else
+    {
+      char **words;
+      words = strtokenize (string, ",");
+      if (!words)
+        return -1;
+      for (i=0; words[i]; i++)
+        {
+          if (*words[i])
+            {
+              for (j=0; flags[j].name; j++)
+                if (!strcmp (words[i], flags[j].name))
+                  {
+                    result |= flags[j].flag;
+                    break;
+                  }
+              if (!flags[j].name)
+                {
+                  if (!strcmp (words[i], "none"))
+                    {
+                      *debugvar = 0;
+                      result = 0;
+                    }
+                  else if (!strcmp (words[i], "all"))
+                    result = ~0;
+                  else
+                    log_info (_("unknown debug flag '%s' ignored\n"), words[i]);
+                }
+            }
+        }
+      xfree (words);
+    }
+
+  *debugvar |= result;
+  return 0;
+}