Adding upstream version 2.2.40.upstream/2.2.40upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 659 insertions, 0 deletions

diff --git a/g10/cpr.c b/g10/cpr.c
new file mode 100644
index 0000000..bc4b715
--- /dev/null
+++ b/g10/cpr.c
@@ -0,0 +1,659 @@
+/* status.c - Status message and command-fd interface
+ * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003,
+ *               2004, 2005, 2006, 2010 Free Software Foundation, Inc.
+ *
+ * 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.
+ *
+ * GnuPG 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
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#ifdef HAVE_SIGNAL_H
+# include <signal.h>
+#endif
+
+#include "gpg.h"
+#include "../common/util.h"
+#include "../common/status.h"
+#include "../common/ttyio.h"
+#include "options.h"
+#include "main.h"
+#include "../common/i18n.h"
+
+#define CONTROL_D ('D' - 'A' + 1)
+
+
+/* The stream to output the status information.  Output is disabled if
+   this is NULL.  */
+static estream_t statusfp;
+
+
+static void
+progress_cb (void *ctx, const char *what, int printchar,
+             int current, int total)
+{
+  char buf[50];
+
+  (void)ctx;
+
+  if ( printchar == '\n' && !strcmp (what, "primegen") )
+    snprintf (buf, sizeof buf, "%.20s X 100 100", what );
+  else
+    snprintf (buf, sizeof buf, "%.20s %c %d %d",
+              what, printchar=='\n'?'X':printchar, current, total );
+  write_status_text (STATUS_PROGRESS, buf);
+}
+
+
+/* Return true if the status message NO may currently be issued.  We
+   need this to avoid synchronization problem while auto retrieving a
+   key.  There it may happen that a status NODATA is issued for a non
+   available key and the user may falsely interpret this has a missing
+   signature. */
+static int
+status_currently_allowed (int no)
+{
+  if (!glo_ctrl.in_auto_key_retrieve)
+    return 1; /* Yes. */
+
+  /* We allow some statis anyway, so that import statistics are
+     correct and to avoid problems if the retrieval subsystem will
+     prompt the user. */
+  switch (no)
+    {
+    case STATUS_GET_BOOL:
+    case STATUS_GET_LINE:
+    case STATUS_GET_HIDDEN:
+    case STATUS_GOT_IT:
+    case STATUS_IMPORTED:
+    case STATUS_IMPORT_OK:
+    case STATUS_IMPORT_CHECK:
+    case STATUS_IMPORT_RES:
+      return 1; /* Yes. */
+    default:
+      break;
+    }
+  return 0; /* No. */
+}
+
+
+void
+set_status_fd (int fd)
+{
+  static int last_fd = -1;
+
+  if (fd != -1 && last_fd == fd)
+    return;
+
+  if (statusfp && statusfp != es_stdout && statusfp != es_stderr )
+    es_fclose (statusfp);
+  statusfp = NULL;
+  if (fd == -1)
+    return;
+
+  if (! gnupg_fd_valid (fd))
+    log_fatal ("status-fd is invalid: %s\n", strerror (errno));
+
+  if (fd == 1)
+    statusfp = es_stdout;
+  else if (fd == 2)
+    statusfp = es_stderr;
+  else
+    statusfp = es_fdopen (fd, "w");
+  if (!statusfp)
+    {
+      log_fatal ("can't open fd %d for status output: %s\n",
+                 fd, strerror (errno));
+    }
+  last_fd = fd;
+
+  gcry_set_progress_handler (progress_cb, NULL);
+}
+
+
+int
+is_status_enabled ()
+{
+  return !!statusfp;
+}
+
+
+void
+write_status ( int no )
+{
+    write_status_text( no, NULL );
+}
+
+
+/* Write a status line with code NO followed by the string TEXT and
+ * directly followed by the remaining strings up to a NULL.  Embedded
+ * CR and LFs in the strings (but not in TEXT) are C-style escaped.*/
+void
+write_status_strings (int no, const char *text, ...)
+{
+  va_list arg_ptr;
+  const char *s;
+
+  if (!statusfp || !status_currently_allowed (no) )
+    return;  /* Not enabled or allowed. */
+
+  es_fputs ("[GNUPG:] ", statusfp);
+  es_fputs (get_status_string (no), statusfp);
+  if ( text )
+    {
+      es_putc ( ' ', statusfp);
+      va_start (arg_ptr, text);
+      s = text;
+      do
+        {
+          for (; *s; s++)
+            {
+              if (*s == '\n')
+                es_fputs ("\\n", statusfp);
+              else if (*s == '\r')
+                es_fputs ("\\r", statusfp);
+              else
+                es_fputc (*(const byte *)s, statusfp);
+            }
+        }
+      while ((s = va_arg (arg_ptr, const char*)));
+      va_end (arg_ptr);
+    }
+  es_putc ('\n', statusfp);
+  if (es_fflush (statusfp) && opt.exit_on_status_write_error)
+    g10_exit (0);
+}
+
+
+void
+write_status_text (int no, const char *text)
+{
+  write_status_strings (no, text, NULL);
+}
+
+
+/* Write a status line with code NO followed by the output of the
+ * printf style FORMAT.  Embedded CR and LFs are C-style escaped.  */
+void
+write_status_printf (int no, const char *format, ...)
+{
+  va_list arg_ptr;
+  char *buf;
+
+  if (!statusfp || !status_currently_allowed (no) )
+    return;  /* Not enabled or allowed. */
+
+  es_fputs ("[GNUPG:] ", statusfp);
+  es_fputs (get_status_string (no), statusfp);
+  if (format)
+    {
+      es_putc ( ' ', statusfp);
+      va_start (arg_ptr, format);
+      buf = gpgrt_vbsprintf (format, arg_ptr);
+      if (!buf)
+        log_error ("error printing status line: %s\n",
+                   gpg_strerror (gpg_err_code_from_syserror ()));
+      else
+        {
+          if (strpbrk (buf, "\r\n"))
+            {
+              const byte *s;
+              for (s=buf; *s; s++)
+                {
+                  if (*s == '\n')
+                    es_fputs ("\\n", statusfp);
+                  else if (*s == '\r')
+                    es_fputs ("\\r", statusfp);
+                  else
+                    es_fputc (*s, statusfp);
+                }
+            }
+          else
+            es_fputs (buf, statusfp);
+          gpgrt_free (buf);
+        }
+
+      va_end (arg_ptr);
+    }
+  es_putc ('\n', statusfp);
+  if (es_fflush (statusfp) && opt.exit_on_status_write_error)
+    g10_exit (0);
+}
+
+
+/* Write an ERROR status line using a full gpg-error error value.  */
+void
+write_status_error (const char *where, gpg_error_t err)
+{
+  if (!statusfp || !status_currently_allowed (STATUS_ERROR))
+    return;  /* Not enabled or allowed. */
+
+  es_fprintf (statusfp, "[GNUPG:] %s %s %u\n",
+              get_status_string (STATUS_ERROR), where, err);
+  if (es_fflush (statusfp) && opt.exit_on_status_write_error)
+    g10_exit (0);
+}
+
+
+/* Same as above but outputs the error code only.  */
+void
+write_status_errcode (const char *where, int errcode)
+{
+  if (!statusfp || !status_currently_allowed (STATUS_ERROR))
+    return;  /* Not enabled or allowed. */
+
+  es_fprintf (statusfp, "[GNUPG:] %s %s %u\n",
+              get_status_string (STATUS_ERROR), where, gpg_err_code (errcode));
+  if (es_fflush (statusfp) && opt.exit_on_status_write_error)
+    g10_exit (0);
+}
+
+
+/* Write a FAILURE status line.  */
+void
+write_status_failure (const char *where, gpg_error_t err)
+{
+  static int any_failure_printed;
+
+  if (!statusfp || !status_currently_allowed (STATUS_FAILURE))
+    return;  /* Not enabled or allowed. */
+  if (any_failure_printed)
+    return;
+  any_failure_printed = 1;
+  es_fprintf (statusfp, "[GNUPG:] %s %s %u\n",
+              get_status_string (STATUS_FAILURE), where, err);
+  if (es_fflush (statusfp) && opt.exit_on_status_write_error)
+    g10_exit (0);
+}
+
+
+/*
+ * Write a status line with a buffer using %XX escapes.  If WRAP is >
+ * 0 wrap the line after this length.  If STRING is not NULL it will
+ * be prepended to the buffer, no escaping is done for string.
+ * A wrap of -1 forces spaces not to be encoded as %20.
+ */
+void
+write_status_text_and_buffer (int no, const char *string,
+                              const char *buffer, size_t len, int wrap)
+{
+  const char *s, *text;
+  int esc, first;
+  int lower_limit = ' ';
+  size_t n, count, dowrap;
+
+  if (!statusfp || !status_currently_allowed (no))
+    return;  /* Not enabled or allowed. */
+
+  if (wrap == -1)
+    {
+      lower_limit--;
+      wrap = 0;
+    }
+
+  text = get_status_string (no);
+  count = dowrap = first = 1;
+  do
+    {
+      if (dowrap)
+        {
+          es_fprintf (statusfp, "[GNUPG:] %s ", text);
+          count = dowrap = 0;
+          if (first && string)
+            {
+              es_fputs (string, statusfp);
+              count += strlen (string);
+              /* Make sure that there is a space after the string.  */
+              if (*string && string[strlen (string)-1] != ' ')
+                {
+                  es_putc (' ', statusfp);
+                  count++;
+                }
+            }
+          first = 0;
+        }
+      for (esc=0, s=buffer, n=len; n; s++, n--)
+        {
+          if (*s == '%' || *(const byte*)s <= lower_limit
+              || *(const byte*)s == 127 )
+            esc = 1;
+          if (wrap && ++count > wrap)
+            dowrap=1;
+          if (esc || dowrap)
+            break;
+        }
+      if (s != buffer)
+        es_fwrite (buffer, s-buffer, 1, statusfp);
+      if ( esc )
+        {
+          es_fprintf (statusfp, "%%%02X", *(const byte*)s );
+          s++; n--;
+        }
+      buffer = s;
+      len = n;
+      if (dowrap && len)
+        es_putc ('\n', statusfp);
+    }
+  while (len);
+
+  es_putc ('\n',statusfp);
+  if (es_fflush (statusfp) && opt.exit_on_status_write_error)
+    g10_exit (0);
+}
+
+
+void
+write_status_buffer (int no, const char *buffer, size_t len, int wrap)
+{
+  write_status_text_and_buffer (no, NULL, buffer, len, wrap);
+}
+
+
+/* Print the BEGIN_SIGNING status message.  If MD is not NULL it is
+   used to retrieve the hash algorithms used for the message. */
+void
+write_status_begin_signing (gcry_md_hd_t md)
+{
+  if (md)
+    {
+      char buf[100];
+      size_t buflen;
+      int i, ga;
+
+      buflen = 0;
+      for (i=1; i <= 110; i++)
+        {
+          ga = map_md_openpgp_to_gcry (i);
+          if (ga && gcry_md_is_enabled (md, ga) && buflen+10 < DIM(buf))
+            {
+              snprintf (buf+buflen, DIM(buf) - buflen,
+                        "%sH%d", buflen? " ":"",i);
+              buflen += strlen (buf+buflen);
+            }
+        }
+      write_status_text (STATUS_BEGIN_SIGNING, buf);
+    }
+  else
+    write_status ( STATUS_BEGIN_SIGNING );
+}
+
+
+static int
+myread(int fd, void *buf, size_t count)
+{
+  int rc;
+  do
+    {
+      rc = read( fd, buf, count );
+    }
+  while (rc == -1 && errno == EINTR);
+
+  if (!rc && count)
+    {
+      static int eof_emmited=0;
+      if ( eof_emmited < 3 )
+        {
+          *(char*)buf = CONTROL_D;
+          rc = 1;
+          eof_emmited++;
+        }
+      else /* Ctrl-D not caught - do something reasonable */
+        {
+#ifdef HAVE_DOSISH_SYSTEM
+#ifndef HAVE_W32CE_SYSTEM
+          raise (SIGINT); /* Nothing to hangup under DOS.  */
+#endif
+#else
+          raise (SIGHUP); /* No more input data.  */
+#endif
+        }
+    }
+  return rc;
+}
+
+
+
+/* Request a string from the client over the command-fd.  If GETBOOL
+   is set the function returns a static string (do not free) if the
+   entered value was true or NULL if the entered value was false.  */
+static char *
+do_get_from_fd ( const char *keyword, int hidden, int getbool )
+{
+  int i, len;
+  char *string;
+
+  if (statusfp != es_stdout)
+    es_fflush (es_stdout);
+
+  write_status_text (getbool? STATUS_GET_BOOL :
+                     hidden? STATUS_GET_HIDDEN : STATUS_GET_LINE, keyword);
+
+  for (string = NULL, i = len = 200; ; i++ )
+    {
+      if (i >= len-1 )
+        {
+          /* On the first iteration allocate a new buffer.  If that
+           * buffer is too short at further iterations do a poor man's
+           * realloc.  */
+          char *save = string;
+          len += 100;
+          string = hidden? xmalloc_secure ( len ) : xmalloc ( len );
+          if (save)
+            {
+              memcpy (string, save, i);
+              xfree (save);
+            }
+          else
+            i = 0;
+	}
+      /* Fixme: why not use our read_line function here? */
+      if ( myread( opt.command_fd, string+i, 1) != 1 || string[i] == '\n'  )
+        break;
+      else if ( string[i] == CONTROL_D )
+        {
+          /* Found ETX - Cancel the line and return a sole ETX.  */
+          string[0] = CONTROL_D;
+          i = 1;
+          break;
+        }
+    }
+  string[i] = 0;
+
+  write_status (STATUS_GOT_IT);
+
+  if (getbool)	 /* Fixme: is this correct??? */
+    return (string[0] == 'Y' || string[0] == 'y') ? "" : NULL;
+
+  return string;
+}
+
+
+
+int
+cpr_enabled()
+{
+    if( opt.command_fd != -1 )
+	return 1;
+    return 0;
+}
+
+char *
+cpr_get_no_help( const char *keyword, const char *prompt )
+{
+    char *p;
+
+    if( opt.command_fd != -1 )
+	return do_get_from_fd ( keyword, 0, 0 );
+    for(;;) {
+	p = tty_get( prompt );
+        return p;
+    }
+}
+
+char *
+cpr_get( const char *keyword, const char *prompt )
+{
+    char *p;
+
+    if( opt.command_fd != -1 )
+	return do_get_from_fd ( keyword, 0, 0 );
+    for(;;) {
+	p = tty_get( prompt );
+	if( *p=='?' && !p[1] && !(keyword && !*keyword)) {
+	    xfree(p);
+	    display_online_help( keyword );
+	}
+	else
+	    return p;
+    }
+}
+
+
+char *
+cpr_get_utf8( const char *keyword, const char *prompt )
+{
+    char *p;
+    p = cpr_get( keyword, prompt );
+    if( p ) {
+	char *utf8 = native_to_utf8( p );
+	xfree( p );
+	p = utf8;
+    }
+    return p;
+}
+
+char *
+cpr_get_hidden( const char *keyword, const char *prompt )
+{
+    char *p;
+
+    if( opt.command_fd != -1 )
+	return do_get_from_fd ( keyword, 1, 0 );
+    for(;;) {
+	p = tty_get_hidden( prompt );
+	if( *p == '?' && !p[1] ) {
+	    xfree(p);
+	    display_online_help( keyword );
+	}
+	else
+	    return p;
+    }
+}
+
+void
+cpr_kill_prompt(void)
+{
+    if( opt.command_fd != -1 )
+	return;
+    tty_kill_prompt();
+    return;
+}
+
+int
+cpr_get_answer_is_yes_def (const char *keyword, const char *prompt, int def_yes)
+{
+    int yes;
+    char *p;
+
+    if( opt.command_fd != -1 )
+	return !!do_get_from_fd ( keyword, 0, 1 );
+    for(;;) {
+	p = tty_get( prompt );
+	trim_spaces(p); /* it is okay to do this here */
+	if( *p == '?' && !p[1] ) {
+	    xfree(p);
+	    display_online_help( keyword );
+	}
+	else {
+	    tty_kill_prompt();
+	    yes = answer_is_yes_no_default (p, def_yes);
+	    xfree(p);
+	    return yes;
+	}
+    }
+}
+
+int
+cpr_get_answer_is_yes (const char *keyword, const char *prompt)
+{
+  return cpr_get_answer_is_yes_def (keyword, prompt, 0);
+}
+
+int
+cpr_get_answer_yes_no_quit( const char *keyword, const char *prompt )
+{
+    int yes;
+    char *p;
+
+    if( opt.command_fd != -1 )
+	return !!do_get_from_fd ( keyword, 0, 1 );
+    for(;;) {
+	p = tty_get( prompt );
+	trim_spaces(p); /* it is okay to do this here */
+	if( *p == '?' && !p[1] ) {
+	    xfree(p);
+	    display_online_help( keyword );
+	}
+	else {
+	    tty_kill_prompt();
+	    yes = answer_is_yes_no_quit(p);
+	    xfree(p);
+	    return yes;
+	}
+    }
+}
+
+
+int
+cpr_get_answer_okay_cancel (const char *keyword,
+                            const char *prompt,
+                            int def_answer)
+{
+  int yes;
+  char *answer = NULL;
+  char *p;
+
+  if( opt.command_fd != -1 )
+    answer = do_get_from_fd ( keyword, 0, 0 );
+
+  if (answer)
+    {
+      yes = answer_is_okay_cancel (answer, def_answer);
+      xfree (answer);
+      return yes;
+    }
+
+  for(;;)
+    {
+      p = tty_get( prompt );
+      trim_spaces(p); /* it is okay to do this here */
+      if (*p == '?' && !p[1])
+        {
+          xfree(p);
+          display_online_help (keyword);
+	}
+      else
+        {
+          tty_kill_prompt();
+          yes = answer_is_okay_cancel (p, def_answer);
+          xfree(p);
+          return yes;
+	}
+    }
+}